@namiml/sdk-core 3.5.0-dev.202611011626 → 3.5.0-dev.202611020145

package/dist/index.mjs

@@ -104,13 +104,17 @@ const {
 // version — stamped by scripts/version.sh
 NAMI_SDK_VERSION = "3.5.0", 
 // full package version including dev suffix — stamped by scripts/version.sh
-NAMI_SDK_PACKAGE_VERSION = "3.5.0-dev.202611011626", 
+NAMI_SDK_PACKAGE_VERSION = "3.5.0-dev.202611020145", 
 // environments
 PRODUCTION = "production", DEVELOPMENT = "development", 
 // error messages
 PLATFORM_ID_REQUIRED = "Platform ID is required", DEVICE_ID_REQUIRED = "Device ID is required", EXTERNAL_ID_REQUIRED = "External ID is required", SDK_NOT_INITIALIZED = "SDK has not been initialized. Make sure to call Nami.configure() first!", CAMPAIGN_NOT_AVAILABLE = "Campaign is not available", FLOW_SCREENS_NOT_AVAILABLE = "Flow screens not available", UNABLE_TO_UPDATE_CDP_ID = "Unable to update CDP id in anonymous mode", ANONYMOUS_MODE_ALREADY_ON = "Anonymous mode is already turned on.", ANONYMOUS_MODE_ALREADY_OFF = "Anonymous mode is already turned off.", ANONYMOUS_MODE_LOGIN_NOT_ALLOWED = "Login/logout are not available in anonymous mode", SESSION_REQUIRED = "Session is required", DEVICE_ID_NOT_SET = "Nami Device ID is not set", 
 // localstorage keys
-AUTH_DEVICE = "nami_auth_device", NAMI_CONFIGURATION = "nami_configuration", NAMI_PROFILE = "nami_profile", API_CONFIG = "api_config", API_CAMPAIGN_RULES = "api_campaign_rules", API_PAYWALLS = "api_paywalls", API_CAMPAIGN_SESSION_TIMESTAMP = "api_campaign_session_timestamp", API_PRODUCTS = "api_products", API_ACTIVE_ENTITLEMENTS = "api_active_entitlements", SERVER_NAMI_ENTITLEMENTS = "server_active_entitlements", INITIAL_APP_CONFIG = "initial_app_config", INITIAL_CAMPAIGN_RULES = "initial_campaign_rules", INITIAL_PAYWALLS = "initial_paywalls", INITIAL_PRODUCTS = "initial_products", LOCAL_NAMI_ENTITLEMENTS = "local_active_entitlements", CUSTOMER_ATTRIBUTES_KEY_PREFIX = "nami_cmr_attributes_", NAMI_CUSTOMER_JOURNEY_STATE = "nami_customer_journey_state", ANONYMOUS_MODE = "nami_anonymous_mode_v2", ANONYMOUS_UUID = "nami_anonymous_uuid", KEY_SESSION_COUNTER = "nami_session_counter", INITIAL_SESSION_COUNTER_VALUE = 1, NAMI_LAST_IMPRESSION_ID = "nami_last_impression_id", NAMI_PURCHASE_IMPRESSION_ID = "nami_purchase_impression_id", NAMI_LAUNCH_ID = "nami_launch_id", NAMI_SESSION_ID = "nami_session_id", NAMI_LANGUAGE_CODE = "nami_language_code", NAMI_PURCHASE_CHANNEL = "nami_purchase_channel", 
+AUTH_DEVICE = "nami_auth_device", NAMI_CONFIGURATION = "nami_configuration", NAMI_PROFILE = "nami_profile", API_CONFIG = "api_config", API_CAMPAIGN_RULES = "api_campaign_rules", API_PAYWALLS = "api_paywalls", API_CAMPAIGN_SESSION_TIMESTAMP = "api_campaign_session_timestamp", API_PRODUCTS = "api_products", API_ACTIVE_ENTITLEMENTS = "api_active_entitlements", SERVER_NAMI_ENTITLEMENTS = "server_active_entitlements", INITIAL_APP_CONFIG = "initial_app_config", INITIAL_CAMPAIGN_RULES = "initial_campaign_rules", INITIAL_PAYWALLS = "initial_paywalls", INITIAL_PRODUCTS = "initial_products", LOCAL_NAMI_ENTITLEMENTS = "local_active_entitlements", CUSTOMER_ATTRIBUTES_KEY_PREFIX = "nami_cmr_attributes_", NAMI_CUSTOMER_JOURNEY_STATE = "nami_customer_journey_state", 
+// Journey delivery counters (NAM-3229), unrelated to the customer journey state above.
+NAMI_JOURNEY_RULE_STATE = "nami_journey_rule_state", 
+// Set at the first app_install journey evaluation on this device, whatever its outcome (NAM-3233).
+NAMI_JOURNEY_INSTALL_EVALUATED = "nami_journey_install_evaluated", ANONYMOUS_MODE = "nami_anonymous_mode_v2", ANONYMOUS_UUID = "nami_anonymous_uuid", KEY_SESSION_COUNTER = "nami_session_counter", INITIAL_SESSION_COUNTER_VALUE = 1, NAMI_LAST_IMPRESSION_ID = "nami_last_impression_id", NAMI_PURCHASE_IMPRESSION_ID = "nami_purchase_impression_id", NAMI_LAUNCH_ID = "nami_launch_id", NAMI_SESSION_ID = "nami_session_id", NAMI_LANGUAGE_CODE = "nami_language_code", NAMI_PURCHASE_CHANNEL = "nami_purchase_channel", 
 // API settings
 API_VERSION = "v3", BASE_URL_PATH = `sdk/${API_VERSION}/platform`, BASE_URL = "https://app.namiml.com", BASE_STAGING_URL = "https://app-staging.namiml.com", CUSTOM_HOST_PREFIX = "namiAPIHost=", USE_STAGING_API = "useStagingAPI", 
 // // extended client info
@@ -118,6 +122,8 @@ EXTENDED_CLIENT_INFO_PREFIX = "extendedClientInfo", EXTENDED_CLIENT_INFO_DELIMIT
 // Test hook: every platform-config fetch attempt fails before the request leaves.
 // Same namiCommand as Apple's and Android's, so the shared first-run flows drive it.
 SIMULATE_CONFIG_FETCH_FAILURE = "simulateConfigFetchFailure", 
+// Journeys are evaluated but never raised (NAM-5234); on in every e2e suite but the journey ones.
+DISABLE_JOURNEY_DELIVERY = "disableJourneyDelivery", 
 // Test hook: every per-paywall body fetch fails before the request leaves, so the body cache's
 // failure rows can be exercised without a proxy. Same namiCommand as Apple's and Android's (NAM-4357).
 SIMULATE_PAYWALL_FETCH_FAILURE = "simulatePaywallFetchFailure", 
@@ -140,6 +146,9 @@ CONFIG_API_TIMEOUT_LIMIT = 10000,
 // A foreground within this long of the last launch/resume run is skipped — Apple's
 // NamiStartupCoordinator.shouldRunResume window.
 RESUME_THROTTLE_MS = 30000, 
+// A return to the foreground at least this long after the background starts a new session —
+// the unified session boundary Apple and Android share (NAM-3234/3235). Drives journey sessions.
+SESSION_GAP_MS = 30000, 
 // status codes
 STATUS_SUCCESS = 200, STATUS_BAD_REQUEST = 400, STATUS_NOT_FOUND = 404, STATUS_CONFLICT = 409, STATUS_INTERNAL_SERVER_ERROR = 500, 
 // configuration states
@@ -160,7 +169,7 @@ const NAMI_STORAGE_KEYS = [
     API_PRODUCTS, API_ACTIVE_ENTITLEMENTS, SERVER_NAMI_ENTITLEMENTS,
     INITIAL_APP_CONFIG, INITIAL_CAMPAIGN_RULES, INITIAL_PAYWALLS, INITIAL_PRODUCTS,
     LOCAL_NAMI_ENTITLEMENTS,
-    NAMI_CUSTOMER_JOURNEY_STATE,
+    NAMI_CUSTOMER_JOURNEY_STATE, NAMI_JOURNEY_RULE_STATE, NAMI_JOURNEY_INSTALL_EVALUATED,
     ANONYMOUS_MODE, ANONYMOUS_UUID,
     KEY_SESSION_COUNTER, NAMI_LAST_IMPRESSION_ID, NAMI_PURCHASE_IMPRESSION_ID,
     NAMI_LAUNCH_ID, NAMI_SESSION_ID, NAMI_LANGUAGE_CODE, NAMI_PURCHASE_CHANNEL,
@@ -603,7 +612,7 @@ function baseGetTag(value) {
  * _.isObject(null);
  * // => false
  */
-function isObject(value) {
+function isObject$1(value) {
   var type = typeof value;
   return value != null && (type == 'object' || type == 'function');
 }
@@ -632,7 +641,7 @@ var asyncTag = '[object AsyncFunction]',
  * // => false
  */
 function isFunction(value) {
-  if (!isObject(value)) {
+  if (!isObject$1(value)) {
     return false;
   }
   // The use of `Object#toString` avoids issues with the `typeof` operator
@@ -720,7 +729,7 @@ var reIsNative = RegExp('^' +
  *  else `false`.
  */
 function baseIsNative(value) {
-  if (!isObject(value) || isMasked(value)) {
+  if (!isObject$1(value) || isMasked(value)) {
     return false;
   }
   var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
@@ -2296,7 +2305,7 @@ function baseIsMatch(object, source, matchData, customizer) {
  *  equality comparisons, else `false`.
  */
 function isStrictComparable(value) {
-  return value === value && !isObject(value);
+  return value === value && !isObject$1(value);
 }
 
 /**
@@ -3523,6 +3532,23 @@ class StorageService {
     getCustomerJourneyState() {
         return this.getItem(NAMI_CUSTOMER_JOURNEY_STATE);
     }
+    /** The raw journey delivery blob; `journeyStateStore` validates its shape. */
+    getJourneyRuleState() {
+        return this.getItem(NAMI_JOURNEY_RULE_STATE);
+    }
+    setJourneyRuleState(state) {
+        this.setItem(NAMI_JOURNEY_RULE_STATE, state);
+    }
+    removeJourneyRuleState() {
+        this.resetItem(NAMI_JOURNEY_RULE_STATE);
+    }
+    /** Whether the one-time app_install journey evaluation has run on this device. */
+    getJourneyInstallEvaluated() {
+        return this.getItem(NAMI_JOURNEY_INSTALL_EVALUATED) === true;
+    }
+    setJourneyInstallEvaluated() {
+        this.setItem(NAMI_JOURNEY_INSTALL_EVALUATED, true);
+    }
     setSessionCounter() {
         const counter = this.getItem(KEY_SESSION_COUNTER);
         const currentCounter = counter ? parseInt(counter) : INITIAL_SESSION_COUNTER_VALUE
@@ -7145,6 +7171,11 @@ const shouldValidateProductGroups = () => {
     const namiCommands = storageService.getNamiConfig()?.namiCommands;
     return namiCommands?.includes(VALIDATE_PRODUCT_GROUPS) ?? false;
 };
+/** Whether journey delivery is suppressed by the `disableJourneyDelivery` namiCommand (NAM-5234). */
+const shouldDisableJourneyDelivery = () => {
+    const namiCommands = storageService.getNamiConfig()?.namiCommands;
+    return namiCommands?.includes(DISABLE_JOURNEY_DELIVERY) ?? false;
+};
 const shouldLogHTTPRequests = () => {
     const namiCommands = storageService.getNamiConfig()?.namiCommands;
     return namiCommands?.includes(LOG_HTTP_REQUESTS) ?? false;
@@ -57040,7 +57071,7 @@ const TRIGGER_EVENT_TYPES = ["app_install", "session_start"];
 const GOAL_TYPES = ["flow_completed", "user_context_set"];
 const PRIORITIES = ["high", "medium", "low"];
 const oneOf = (allowed, value) => allowed.includes(value) ? value : null;
-const numberOrNull = (value) => (typeof value === "number" ? value : null);
+const numberOrNull$1 = (value) => (typeof value === "number" ? value : null);
 /**
  * Resolves a rule's `journey` object, reading `journey_id` from the top level and the other
  * fields from the `object` envelope when present, else from the top level (the flat contract
@@ -57060,17 +57091,17 @@ function parseJourneyMetadata(dto) {
             ? {
                 type: oneOf(GOAL_TYPES, goal.type),
                 context_key: goal.context_key ?? null,
-                timeout_days: numberOrNull(goal.timeout_days),
-                re_eligibility_days: numberOrNull(goal.re_eligibility_days),
+                timeout_days: numberOrNull$1(goal.timeout_days),
+                re_eligibility_days: numberOrNull$1(goal.re_eligibility_days),
                 re_entry_after_goal: goal.re_entry_after_goal === true,
             }
             : null,
         delivery: {
             show_once: delivery?.show_once === true,
-            max_impressions_total: numberOrNull(delivery?.max_impressions_total),
-            max_per_session: numberOrNull(delivery?.max_per_session),
-            max_per_day: numberOrNull(delivery?.max_per_day),
-            delay_seconds: numberOrNull(delivery?.delay_seconds) ?? 0,
+            max_impressions_total: numberOrNull$1(delivery?.max_impressions_total),
+            max_per_session: numberOrNull$1(delivery?.max_per_session),
+            max_per_day: numberOrNull$1(delivery?.max_per_day),
+            delay_seconds: numberOrNull$1(delivery?.delay_seconds) ?? 0,
         },
     };
 }
@@ -61060,7 +61091,7 @@ var objectCreate = Object.create;
 var baseCreate = (function() {
   function object() {}
   return function(proto) {
-    if (!isObject(proto)) {
+    if (!isObject$1(proto)) {
       return {};
     }
     if (objectCreate) {
@@ -61224,7 +61255,7 @@ function baseClone(value, bitmask, customizer, key, object, stack) {
   if (result !== undefined) {
     return result;
   }
-  if (!isObject(value)) {
+  if (!isObject$1(value)) {
     return value;
   }
   var isArr = isArray(value);
@@ -61788,8 +61819,11 @@ class PaywallState extends SimpleEventTarget {
         this.providers.push(provider);
         return provider;
     }
+    // `PaywallState.providers`, never `this.providers`: called through a subclass (web's
+    // PaywallContextProvider), an assignment to `this.providers` would create a second array on the
+    // subclass and leave this one holding every closed paywall.
     static remove(provider) {
-        this.providers = this.providers.filter(p => p !== provider);
+        PaywallState.providers = PaywallState.providers.filter(p => p !== provider);
     }
     /**
      * Clear the static `providers` array. Called from `Nami.reset()` so
@@ -61798,7 +61832,7 @@ class PaywallState extends SimpleEventTarget {
      * for the next configure() cycle.
      */
     static reset() {
-        this.providers = [];
+        PaywallState.providers = [];
     }
     static get currentProvider() {
         return PaywallState.providers[0];
@@ -62577,6 +62611,612 @@ class StartupTelemetry {
 }
 const startupTelemetry = new StartupTelemetry();
 
+/**
+ * One-shot timer that can pause and resume, keeping the remaining time (NAM-3233). Mirrors
+ * Apple's `JourneyDelayTimer` (NAM-3234). Remaining time is measured with the injected `now`,
+ * a monotonic clock in production, so a wall-clock change cannot shorten or stretch a delay.
+ */
+class JourneyDelayTimer {
+    constructor(now) {
+        this.now = now;
+        this.handle = null;
+        this.fire = null;
+        this.deadline = 0;
+        this.remaining = null;
+    }
+    /** True while a delay is running or paused. */
+    get isPending() {
+        return this.fire !== null;
+    }
+    /** True while a delay is pending but not counting down (paused, or started paused). */
+    get isPaused() {
+        return this.fire !== null && this.handle === null;
+    }
+    /**
+     * Starts the delay, cancelling any pending one first: the previous `fire` never runs. The
+     * single-slot rule (drop a new winner while one waits) is the caller's, which checks
+     * {@link isPending} first.
+     */
+    start(ms, fire) {
+        this.cancel();
+        this.fire = fire;
+        this.arm(ms);
+    }
+    /** Like {@link start}, but the delay begins paused with `ms` remaining until {@link resume}. */
+    startPaused(ms, fire) {
+        this.cancel();
+        this.fire = fire;
+        this.remaining = Math.max(0, ms);
+    }
+    /** Stops the countdown, remembering what is left. No-op unless running. */
+    pause() {
+        if (this.handle === null)
+            return;
+        this.remaining = Math.max(0, this.deadline - this.now());
+        this.disarm();
+    }
+    /** Re-arms with the remaining time. No-op unless paused. */
+    resume() {
+        if (this.fire === null || this.handle !== null || this.remaining === null)
+            return;
+        const left = this.remaining;
+        this.remaining = null;
+        this.arm(left);
+    }
+    /** Clears everything; the pending `fire` never runs. */
+    cancel() {
+        this.disarm();
+        this.fire = null;
+        this.remaining = null;
+    }
+    arm(ms) {
+        const delay = Math.max(0, ms);
+        this.deadline = this.now() + delay;
+        this.handle = setTimeout(() => {
+            const action = this.fire;
+            this.handle = null;
+            this.fire = null;
+            this.remaining = null;
+            action?.();
+        }, delay);
+    }
+    disarm() {
+        if (this.handle !== null)
+            clearTimeout(this.handle);
+        this.handle = null;
+    }
+}
+
+/**
+ * The journey engine's persisted state (NAM-3229), split from the store so the engine can use
+ * these without importing storage. Mirrors Apple's `JourneyRecord.swift` (NAM-3230).
+ */
+const emptyJourneyRecord = () => ({
+    impressionsTotal: 0,
+    sessionKey: null,
+    sessionCount: 0,
+    dayKey: null,
+    dayCount: 0,
+    lastDismissedAt: null,
+    goalAchievedAt: null,
+    enteredAt: null,
+});
+const emptyGlobalRecord = () => ({
+    sessionOrdinal: 0,
+    sessionKey: null,
+    sessionCount: 0,
+    dayKey: null,
+    dayCount: 0,
+    lastAnyImpressionAt: null,
+});
+const emptyJourneySnapshot = () => ({ journeys: {}, global: emptyGlobalRecord() });
+
+const DAY_MS = 86_400_000;
+const PRIORITY_RANK = { high: 0, medium: 1, low: 2 };
+/** A counter stored under `storedKey` reads as 0 once the current key has moved on. */
+const countFor = (storedKey, count, currentKey) => storedKey === currentKey ? count : 0;
+/**
+ * Pure journey eligibility and selection, plus the state transitions that follow (NAM-3229).
+ * Mirrors Apple's `JourneyEngine` (NAM-3230), whose decision order the Android and Roku engines
+ * share. The clock (`now`) and the time zone are injected; it imports no UI, adapter or storage
+ * module, and never mutates the snapshot it is given.
+ */
+class JourneyEngine {
+    /**
+     * @param options.timeZone IANA zone that defines the local day for daily counts, read on every
+     *   call. When absent or returning undefined, the device's local day is used.
+     */
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * The day of `now` as ISO `yyyy-MM-dd`. Always Gregorian with Latin digits: a Buddhist or
+     * Japanese locale calendar must not change the year.
+     */
+    dayKey(now) {
+        const zone = this.options.timeZone?.();
+        if (!zone) {
+            return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+        }
+        const parts = new Intl.DateTimeFormat("en-US", {
+            timeZone: zone,
+            calendar: "gregory",
+            numberingSystem: "latn",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        }).formatToParts(now);
+        const part = (type) => parts.find((p) => p.type === type)?.value ?? "";
+        return `${part("year").padStart(4, "0")}-${part("month")}-${part("day")}`;
+    }
+    /**
+     * Picks the journey to deliver for `event`, applying decision rows 1-10 in payload order.
+     *
+     * - Rules without journey metadata are skipped without a rejection.
+     * - Only the FIRST rule per `journey_id` in payload order is considered. Later rules sharing an
+     *   id neither compete nor get a rejection entry, and the winner's id never appears in
+     *   `rejections`.
+     * - The active window (row 2) is the rule's `not_before`/`expires_at`, strict at both ends.
+     * - Priority ties (`high` > `medium` > `low`) are broken by payload order: the wire has no
+     *   created timestamp, so the server's order is the only deterministic signal.
+     */
+    select({ event, journeys, snapshot, settings, isContentActive, now }) {
+        const today = this.dayKey(now);
+        const rejections = {};
+        const survivors = [];
+        const seen = new Set();
+        for (const rule of journeys) {
+            const journey = parseJourneyMetadata(rule.journey);
+            if (!journey || seen.has(journey.journey_id))
+                continue;
+            seen.add(journey.journey_id);
+            const rejection = this.perJourneyRejection(rule, journey, event, snapshot, settings, today, now);
+            if (rejection)
+                rejections[journey.journey_id] = rejection;
+            else
+                survivors.push({ rule, journey });
+        }
+        const global = this.globalRejection(snapshot.global, settings, isContentActive, today, now);
+        if (global) {
+            for (const s of survivors)
+                rejections[s.journey.journey_id] = global;
+            return { winner: null, rejections };
+        }
+        // The first survivor of the best rank wins, which is the payload-order tiebreak.
+        let winner = null;
+        for (const s of survivors) {
+            if (!winner || PRIORITY_RANK[s.journey.priority] < PRIORITY_RANK[winner.journey.priority])
+                winner = s;
+        }
+        for (const s of survivors)
+            if (s !== winner)
+                rejections[s.journey.journey_id] = "outranked";
+        return { winner, rejections };
+    }
+    /** Rows 1-7. Returns null when the journey passes all of them. */
+    perJourneyRejection(rule, journey, event, snapshot, settings, today, now) {
+        if (!isSupportedJourney(journey) || journey.trigger.event_type !== event)
+            return "triggerMismatch";
+        if (!isCampaignRuleActive(rule.not_before, rule.expires_at, now))
+            return "outsideWindow";
+        const record = snapshot.journeys[journey.journey_id] ?? emptyJourneyRecord();
+        const { delivery, goal } = journey;
+        const nowMs = now.getTime();
+        if (delivery.show_once) {
+            if (record.impressionsTotal >= 1)
+                return "shownOnce";
+        }
+        else {
+            if (delivery.max_impressions_total != null && record.impressionsTotal >= delivery.max_impressions_total)
+                return "totalCap";
+            // A per-journey cap only tightens the global one.
+            const sessionCap = Math.min(delivery.max_per_session ?? settings.max_per_session, settings.max_per_session);
+            const dayCap = Math.min(delivery.max_per_day ?? settings.max_per_day, settings.max_per_day);
+            if (countFor(record.sessionKey, record.sessionCount, snapshot.global.sessionOrdinal) >= sessionCap)
+                return "sessionCap";
+            if (countFor(record.dayKey, record.dayCount, today) >= dayCap)
+                return "dayCap";
+            const days = goal?.re_eligibility_days;
+            if (days != null && record.lastDismissedAt != null && nowMs < record.lastDismissedAt + days * DAY_MS) {
+                return "reEligibility";
+            }
+        }
+        if (record.goalAchievedAt != null && (delivery.show_once || goal?.re_entry_after_goal !== true))
+            return "goalAchieved";
+        const timeout = goal?.timeout_days;
+        if (timeout != null && record.enteredAt != null && nowMs >= record.enteredAt + timeout * DAY_MS)
+            return "timedOut";
+        return null;
+    }
+    /** Rows 8 and 9: device-wide checks, evaluated once per decision. */
+    globalRejection(global, settings, isContentActive, today, now) {
+        if (countFor(global.sessionKey, global.sessionCount, global.sessionOrdinal) >= settings.max_per_session)
+            return "globalSessionCap";
+        if (countFor(global.dayKey, global.dayCount, today) >= settings.max_per_day)
+            return "globalDayCap";
+        if (global.lastAnyImpressionAt != null && now.getTime() < global.lastAnyImpressionAt + settings.cooldown_seconds * 1000) {
+            return "cooldown";
+        }
+        if (settings.suppress_when_active && isContentActive)
+            return "suppressed";
+        return null;
+    }
+    // Transitions
+    /** Records a delivered journey impression: journey and global counters, entry and cooldown. */
+    recordImpression(s, journeyId, now) {
+        const today = this.dayKey(now);
+        const ordinal = s.global.sessionOrdinal;
+        const record = s.journeys[journeyId] ?? emptyJourneyRecord();
+        const out = this.recordExternalImpression(s, now);
+        return this.withRecord(out, journeyId, {
+            ...record,
+            impressionsTotal: record.impressionsTotal + 1,
+            sessionKey: ordinal,
+            sessionCount: countFor(record.sessionKey, record.sessionCount, ordinal) + 1,
+            dayKey: today,
+            dayCount: countFor(record.dayKey, record.dayCount, today) + 1,
+            enteredAt: record.enteredAt ?? now.getTime(),
+        });
+    }
+    /** Records an impression shown outside Nami journeys: global counters and cooldown only. */
+    recordExternalImpression(s, now) {
+        const today = this.dayKey(now);
+        const g = s.global;
+        return {
+            ...s,
+            global: {
+                ...g,
+                sessionKey: g.sessionOrdinal,
+                sessionCount: countFor(g.sessionKey, g.sessionCount, g.sessionOrdinal) + 1,
+                dayKey: today,
+                dayCount: countFor(g.dayKey, g.dayCount, today) + 1,
+                lastAnyImpressionAt: now.getTime(),
+            },
+        };
+    }
+    /** Records a dismiss; it starts the re-eligibility window but never counts as an impression. */
+    recordDismiss(s, journeyId, now) {
+        return this.withRecord(s, journeyId, { ...(s.journeys[journeyId] ?? emptyJourneyRecord()), lastDismissedAt: now.getTime() });
+    }
+    /** Records goal completion and clears entry so a re-entry journey starts a fresh timeout. */
+    recordGoal(s, journeyId, now) {
+        return this.withRecord(s, journeyId, {
+            ...(s.journeys[journeyId] ?? emptyJourneyRecord()),
+            goalAchievedAt: now.getTime(),
+            enteredAt: null,
+        });
+    }
+    withRecord(s, journeyId, record) {
+        return { ...s, journeys: { ...s.journeys, [journeyId]: record } };
+    }
+}
+
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+const stringOrNull = (value) => (typeof value === "string" ? value : null);
+// Each field falls back to its default when missing or mistyped, so a partial blob still loads.
+function decodeRecord(raw) {
+    if (!isObject(raw))
+        return emptyJourneyRecord();
+    return {
+        impressionsTotal: numberOrNull(raw.impressionsTotal) ?? 0,
+        sessionKey: numberOrNull(raw.sessionKey),
+        sessionCount: numberOrNull(raw.sessionCount) ?? 0,
+        dayKey: stringOrNull(raw.dayKey),
+        dayCount: numberOrNull(raw.dayCount) ?? 0,
+        lastDismissedAt: numberOrNull(raw.lastDismissedAt),
+        goalAchievedAt: numberOrNull(raw.goalAchievedAt),
+        enteredAt: numberOrNull(raw.enteredAt),
+    };
+}
+function decodeGlobal(raw) {
+    if (!isObject(raw))
+        return emptyGlobalRecord();
+    return {
+        sessionOrdinal: numberOrNull(raw.sessionOrdinal) ?? 0,
+        sessionKey: numberOrNull(raw.sessionKey),
+        sessionCount: numberOrNull(raw.sessionCount) ?? 0,
+        dayKey: stringOrNull(raw.dayKey),
+        dayCount: numberOrNull(raw.dayCount) ?? 0,
+        lastAnyImpressionAt: numberOrNull(raw.lastAnyImpressionAt),
+    };
+}
+/** A stored blob as a snapshot. A missing, corrupt or wrongly shaped blob reads as empty. */
+function decodeSnapshot(raw) {
+    if (!isObject(raw) || !isObject(raw.journeys))
+        return emptyJourneySnapshot();
+    const journeys = {};
+    for (const [id, record] of Object.entries(raw.journeys))
+        journeys[id] = decodeRecord(record);
+    return { journeys, global: decodeGlobal(raw.global) };
+}
+/**
+ * Persists the journey engine's counters as one JSON blob under `nami_journey_rule_state`. The
+ * key is in `NAMI_STORAGE_KEYS`, so `storageService.clearAll()` wipes it. There is no in-memory
+ * cache: every read goes to storage, so a wipe can never leave stale counters behind.
+ */
+const journeyStateStore = {
+    snapshot() {
+        return decodeSnapshot(storageService.getJourneyRuleState());
+    },
+    /** Applies `transform` to the stored snapshot, persists the result and returns it. */
+    update(transform) {
+        const updated = transform(this.snapshot());
+        storageService.setJourneyRuleState(updated);
+        return updated;
+    },
+    /** Starts a new local session: bumps the ordinal, which re-keys per-session counts to 0. */
+    startSession() {
+        this.update((s) => ({ ...s, global: { ...s.global, sessionOrdinal: s.global.sessionOrdinal + 1 } }));
+    },
+    /** Drops all journey state. */
+    clear() {
+        storageService.removeJourneyRuleState();
+    },
+};
+
+/**
+ * Two-slot, session-scoped store of the most recent launches.
+ *
+ * On `record(rec)` the existing `current` slot is demoted to `previous` and
+ * `rec` becomes the new `current`. Flow conditions read `previous`, which
+ * structurally excludes the placement that is launching right now (the PPO
+ * requirement): the first launch in a session leaves `previous` undefined.
+ *
+ * State is in-memory only and cleared via `reset()` (wired into `Nami.reset()`).
+ */
+class LastLaunchStore {
+    static get shared() {
+        if (!this._shared)
+            this._shared = new LastLaunchStore();
+        return this._shared;
+    }
+    /** The Last Launch — the launch immediately before the current one. */
+    get previous() {
+        return this._previous;
+    }
+    /** Demote `current` → `previous`, then set `current` to `rec`. */
+    record(rec) {
+        this._previous = this._current;
+        this._current = rec;
+    }
+    /** Clear both slots. */
+    reset() {
+        this._current = undefined;
+        this._previous = undefined;
+    }
+}
+
+// `NamiFlowManager` imports the `nami` module back, so importing it here would close a load-order
+// cycle (the one `Nami.reset()` sidesteps with a lazy import). It registers this probe when it
+// loads instead; until then no flow can be open.
+let flowOpenProbe = () => false;
+/** Called by `NamiFlowManager` when its module loads. */
+const registerFlowOpenProbe = (probe) => {
+    flowOpenProbe = probe;
+};
+/** Whether a Nami paywall or flow is on screen: a journey never raises over one (NAM-3233). */
+const isNamiContentActive = () => PaywallState.providers.length > 0 || flowOpenProbe();
+/** Whether the app is visible, per the device adapter; visible when the adapter cannot tell. */
+const isAppVisible = () => getPlatformAdapters().device.isAppVisible?.() ?? true;
+/**
+ * Raises a journey's campaign through the UI adapter, the way `NamiCampaignManager.launch` raises
+ * a placement, and reports whether it was presented (NAM-3233). Mirrors Apple's
+ * `JourneyCoordinator.deliverOnMain` + `raiseCampaign`.
+ *
+ * Re-checks right before the raise: no `Nami.reset()` since the fire (`stillValid`), no paywall or
+ * flow open (whatever `suppress_when_active` says: two would stack), and the app visible. Then the
+ * campaign's content must be there (every flow screen, or the paywall), and the adapter must be able
+ * to present by itself (`presentCampaign`; Expo and the CLI cannot).
+ *
+ * Like a launch, it records the Last Launch store (with no placement label: a journey has no
+ * `value`) and a fresh launch id, so pages, flows, impressions and the rule's segment behave as for
+ * a placement.
+ */
+function presentJourneyCampaign(campaign, stillValid) {
+    const { ui } = getPlatformAdapters();
+    const skip = (reason) => {
+        logger.debug(`Journey raise skipped for rule ${campaign.rule}: ${reason}`);
+        return false;
+    };
+    if (!stillValid())
+        return skip("Nami.reset() ran after it fired");
+    if (isNamiContentActive())
+        return skip("a paywall or flow is already open");
+    if (!isAppVisible())
+        return skip("the app is not visible");
+    if (!ui.presentCampaign)
+        return skip("this platform cannot present a journey");
+    if (campaign.flow) {
+        if (!campaign.flow.object || !hasAllPaywalls(campaign.flow.object.screens ?? [])) {
+            return skip("its flow screens are not available");
+        }
+    }
+    else if (!campaign.paywall || !getPaywall(campaign.paywall)) {
+        return skip("its paywall is not available");
+    }
+    LastLaunchStore.shared.record({ placementLabel: "", tags: campaign.placement_tags ?? [], customAttributes: {} });
+    storageService.setLaunchId(generateUUID());
+    return ui.presentCampaign(campaign, { customAttributes: {} });
+}
+
+const monotonicNow = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+const liveJourneyEnvironment = {
+    now: () => new Date(),
+    monotonicNow,
+    journeys: journeyCampaigns,
+    settings: getJourneySettings,
+    contentActive: isNamiContentActive,
+    isAppVisible,
+    present: presentJourneyCampaign,
+    deliveryDisabled: shouldDisableJourneyDelivery,
+    installMarker: {
+        get: () => storageService.getJourneyInstallEvaluated(),
+        set: () => storageService.setJourneyInstallEvaluated(),
+    },
+};
+const journeyIdOf = (rule) => parseJourneyMetadata(rule.journey)?.journey_id;
+/**
+ * Drives journey delivery for the `app_install` and `session_start` triggers (NAM-3233):
+ * evaluation, the single delay slot, the fire-time re-check, delivery and local impression
+ * accounting. A port of Apple's `JourneyCoordinator` (NAM-3234) minus campaign-rule refresh,
+ * which core gains in NAM-3236. JS is single-threaded, so there is no queue: the reset
+ * generation alone keeps work from before a `Nami.reset()` off the fresh state.
+ *
+ * Guards on the way to a raise:
+ * - A winner chosen while the app is hidden starts its delay paused, a 0-second delay included,
+ *   and only counts down once the app is visible again.
+ * - When the delay ends, the winner is looked up again by `journey_id` in the CURRENT journey
+ *   rules and re-checked against fresh state. Absent (removed or paused by the server, or no
+ *   journeys left at all) means dropped: a failed fetch keeps the previous rules, so an empty
+ *   list really is empty.
+ * - `present` re-checks reset, open content and visibility right before the raise.
+ */
+class JourneyCoordinator {
+    constructor(env) {
+        this.env = env;
+        this.engine = new JourneyEngine();
+        this.resetGeneration = 0;
+        this.backgroundedAt = null;
+        this.delay = new JourneyDelayTimer(env.monotonicNow);
+    }
+    /**
+     * The current reset generation; {@link reset} bumps it. A startup pass reads it when it begins
+     * and hands it back to {@link sessionStarted}.
+     */
+    get generation() {
+        return this.resetGeneration;
+    }
+    /** Whether a delay is pending but not counting down. */
+    get isDelayPaused() {
+        return this.delay.isPaused;
+    }
+    // Triggers and lifecycle
+    /**
+     * A new session began (configure, or a return after the session gap). Advances the journey
+     * session ordinal and evaluates the triggers.
+     *
+     * @param generation the {@link generation} read when the startup pass began. A `Nami.reset()`
+     *   since then makes the call stale, and it is dropped whole: no ordinal bump, no evaluation,
+     *   no install marker. Omitted, nothing is checked.
+     */
+    sessionStarted(isInstallCandidate, generation) {
+        if (generation !== undefined && generation !== this.resetGeneration) {
+            logger.debug("Journey session start dropped: Nami.reset() ran during the startup pass");
+            return;
+        }
+        journeyStateStore.startSession();
+        this.evaluate(isInstallCandidate);
+    }
+    /** Pauses the delay, keeping the remainder, and starts measuring the session gap. */
+    appDidEnterBackground() {
+        this.delay.pause();
+        this.backgroundedAt ??= this.env.monotonicNow();
+    }
+    /**
+     * Resumes the delay with the remaining time, including one held since a hidden start.
+     *
+     * @returns whether this return begins a new session: it came at least {@link SESSION_GAP_MS}
+     *   after the background (the session boundary Apple and Android share). A foreground with no
+     *   background recorded never does.
+     */
+    appWillEnterForeground() {
+        const hiddenAt = this.backgroundedAt;
+        this.backgroundedAt = null;
+        this.delay.resume();
+        return hiddenAt !== null && this.env.monotonicNow() - hiddenAt >= SESSION_GAP_MS;
+    }
+    /** A placement campaign is about to be raised: a journey still waiting must not fire on top of it. */
+    placementWillRaise() {
+        this.delay.cancel();
+    }
+    /** Cancels the delay and invalidates in-flight work (`Nami.reset()`), before the storage wipe. */
+    reset() {
+        this.delay.cancel();
+        this.backgroundedAt = null;
+        this.resetGeneration += 1;
+    }
+    // Evaluation
+    evaluate(isInstallCandidate) {
+        let selected = null;
+        if (isInstallCandidate && !this.env.installMarker.get()) {
+            const winner = this.select("app_install");
+            if (winner)
+                selected = { event: "app_install", winner };
+        }
+        // The marker is set at the first evaluation whether or not a journey won.
+        if (isInstallCandidate)
+            this.env.installMarker.set();
+        if (!selected) {
+            const winner = this.select("session_start");
+            if (winner)
+                selected = { event: "session_start", winner };
+        }
+        if (!selected)
+            return;
+        const { event, winner } = selected;
+        const journeyId = winner.journey.journey_id;
+        if (this.delay.isPending) {
+            logger.debug(`Journey ${journeyId} dropped: another journey is waiting for its delay`);
+            return;
+        }
+        const ms = Math.max(0, winner.journey.delivery.delay_seconds * 1000);
+        const fire = () => this.fire(event, journeyId);
+        if (this.env.isAppVisible()) {
+            this.delay.start(ms, fire);
+        }
+        else {
+            logger.debug(`Journey ${journeyId} held: the app is not visible, its delay starts paused`);
+            this.delay.startPaused(ms, fire);
+        }
+    }
+    decide(event, journeys) {
+        return this.engine.select({
+            event,
+            journeys,
+            snapshot: journeyStateStore.snapshot(),
+            settings: this.env.settings(),
+            isContentActive: this.env.contentActive(),
+            now: this.env.now(),
+        });
+    }
+    select(event) {
+        const { winner, rejections } = this.decide(event, this.env.journeys());
+        if (!winner && Object.keys(rejections).length > 0) {
+            logger.debug(`No ${event} journey selected: ${JSON.stringify(rejections)}`);
+        }
+        return winner;
+    }
+    /** The delay ended: re-resolve the winner, re-check it against fresh state, then deliver. */
+    fire(event, journeyId) {
+        if (!this.env.isAppVisible()) {
+            // The countdown ended out of sight: hold it again until the foreground instead of dropping it.
+            this.delay.startPaused(0, () => this.fire(event, journeyId));
+            return;
+        }
+        const candidate = this.env.journeys().find((rule) => journeyIdOf(rule) === journeyId);
+        if (!candidate) {
+            logger.debug(`Journey ${journeyId} dropped at fire time: no longer in the journey rules`);
+            return;
+        }
+        const { winner, rejections } = this.decide(event, [candidate]);
+        if (!winner) {
+            logger.debug(`Journey ${journeyId} dropped at fire time: ${rejections[journeyId]}`);
+            return;
+        }
+        if (this.env.deliveryDisabled()) {
+            logger.debug(`Journey ${journeyId} not delivered: disableJourneyDelivery is set`);
+            return;
+        }
+        const generation = this.resetGeneration;
+        const stillValid = () => this.resetGeneration === generation;
+        if (!this.env.present(winner.rule, stillValid) || !stillValid())
+            return;
+        journeyStateStore.update((s) => this.engine.recordImpression(s, journeyId, this.env.now()));
+    }
+}
+JourneyCoordinator.shared = new JourneyCoordinator(liveJourneyEnvironment);
+
 class NamiRefs {
     constructor() {
         // In-memory flag for device registration failures (not persisted)
@@ -62592,6 +63232,9 @@ class NamiRefs {
         this.lastConfig = null;
         this.lastStartupRunAt = 0;
         this.startupInFlight = false;
+        // The startup rules fetch, settled either way. With an initial config `configure()` does not
+        // wait for it, but the journey session does, so it evaluates the fetched rules (NAM-3233).
+        this.startupFetch = Promise.resolve();
         // Register this instance to avoid circular dependency issues
         setNamiRefsInstance(this);
     }
@@ -62618,7 +63261,8 @@ class NamiRefs {
         return this.startupDisabled;
     }
     async init(config) {
-        this.isFirstSession = storageService.getDevice() === null && !storageService.getAnonymousMode();
+        this.isFirstSession = this.hasNoDevice();
+        const journeyGeneration = JourneyCoordinator.shared.generation;
         // Cleared per configure so a transient failure cannot disable a later run.
         this.startupDisabled = false;
         // `Nami.configure` has already normalised a missing or undecodable initialConfig to `{}`,
@@ -62631,12 +63275,42 @@ class NamiRefs {
         try {
             if (!(await this.fetchPlatformConfig()))
                 return;
-            await this.runStartupAfterConfig(config);
+            try {
+                await this.runStartupAfterConfig(config);
+            }
+            finally {
+                // Even after a failed step: the rules may be cached (Apple starts it the same way).
+                this.startJourneySession(this.isFirstSession, journeyGeneration);
+            }
         }
         finally {
             this.startupInFlight = false;
         }
     }
+    /**
+     * The app returned to the foreground. A return at least `SESSION_GAP_MS` after the background
+     * starts a new journey session once the {@link resume} config refresh is done, unless startup is
+     * disabled or a configure is already running (it starts its own). Every return runs `resume()`.
+     */
+    async foreground() {
+        const journeys = JourneyCoordinator.shared;
+        const newSession = journeys.appWillEnterForeground();
+        const startNewSession = newSession && this.lastConfig !== null && !this.startupInFlight;
+        const generation = journeys.generation;
+        const isInstallCandidate = this.hasNoDevice();
+        await this.resume();
+        if (startNewSession && !this.startupDisabled) {
+            this.startJourneySession(isInstallCandidate, generation);
+        }
+    }
+    /** No registered device id yet, so the device is a candidate for the `app_install` trigger. */
+    hasNoDevice() {
+        return storageService.getDevice() === null && !storageService.getAnonymousMode();
+    }
+    /** Starts the journey session once the startup rules fetch has settled, without blocking on it. */
+    startJourneySession(isInstallCandidate, generation) {
+        void this.startupFetch.then(() => JourneyCoordinator.shared.sessionStarted(isInstallCandidate, generation));
+    }
     /**
      * The app returned to the foreground. Re-reads the platform config, as Apple's `.appResume`
      * and Android's `onAppComesFromBackground` do, so a config change — the `sdk` kill switch
@@ -62779,6 +63453,7 @@ class NamiRefs {
             }
             throw error;
         });
+        this.startupFetch = promises.then(() => undefined, () => undefined);
         if (!initialConfig.campaign_rules?.length || !initialConfig.paywalls?.length) {
             await promises;
         }
@@ -62950,39 +63625,7 @@ let NamiProfileManager$1 = class NamiProfileManager {
 };
 NamiProfileManager$1.instance = new NamiProfileManager$1();
 
-/**
- * Two-slot, session-scoped store of the most recent launches.
- *
- * On `record(rec)` the existing `current` slot is demoted to `previous` and
- * `rec` becomes the new `current`. Flow conditions read `previous`, which
- * structurally excludes the placement that is launching right now (the PPO
- * requirement): the first launch in a session leaves `previous` undefined.
- *
- * State is in-memory only and cleared via `reset()` (wired into `Nami.reset()`).
- */
-class LastLaunchStore {
-    static get shared() {
-        if (!this._shared)
-            this._shared = new LastLaunchStore();
-        return this._shared;
-    }
-    /** The Last Launch — the launch immediately before the current one. */
-    get previous() {
-        return this._previous;
-    }
-    /** Demote `current` → `previous`, then set `current` to `rec`. */
-    record(rec) {
-        this._previous = this._current;
-        this._current = rec;
-    }
-    /** Clear both slots. */
-    reset() {
-        this._current = undefined;
-        this._previous = undefined;
-    }
-}
-
-var _Nami_isInitialized, _Nami_removeForegroundListener;
+var _Nami_isInitialized, _Nami_removeForegroundListener, _Nami_removeBackgroundListener;
 // NamiFlowManager is intentionally NOT imported at top level — it
 // transitively imports back to this module (`Nami` for logging), and
 // pulling it in here causes a load-order cycle that breaks tests
@@ -62991,6 +63634,7 @@ class Nami {
     constructor() {
         _Nami_isInitialized.set(this, false);
         _Nami_removeForegroundListener.set(this, null);
+        _Nami_removeBackgroundListener.set(this, null);
         this.maxLogging = false;
     }
     get isInitialized() {
@@ -63014,7 +63658,9 @@ class Nami {
      * integrating app, consistent with the Apple and Android SDKs.
      */
     static async reset() {
-        var _a;
+        var _a, _b;
+        // Before the wipe, so a pending journey can neither fire nor record into the fresh store.
+        JourneyCoordinator.shared.reset();
         storageService.clearAll();
         // The per-URL paywall body cache keeps its own prefixed keys and an in-memory index (NAM-4357).
         paywallBodyCache.purgeAll();
@@ -63022,6 +63668,8 @@ class Nami {
         __classPrivateFieldSet(Nami.instance, _Nami_isInitialized, false, "f");
         __classPrivateFieldGet((_a = Nami.instance), _Nami_removeForegroundListener, "f")?.call(_a);
         __classPrivateFieldSet(Nami.instance, _Nami_removeForegroundListener, null, "f");
+        __classPrivateFieldGet((_b = Nami.instance), _Nami_removeBackgroundListener, "f")?.call(_b);
+        __classPrivateFieldSet(Nami.instance, _Nami_removeBackgroundListener, null, "f");
         NamiRefs.instance.clearResumeState();
         // In-memory singleton state that previously survived reset and
         // bled into the next configure() cycle.
@@ -63086,16 +63734,24 @@ class Nami {
         config.initialConfig = {};
     }
     /**
-     * Subscribes the resume config refresh to the host's foreground signal, once per process —
-     * a reconfigure must not stack a second listener (the Android defect NAM-4541 fixed).
+     * Subscribes to the host's foreground and background signals, once per process — a
+     * reconfigure must not stack a second listener (the Android defect NAM-4541 fixed).
      * Registered before startup runs; `resume()` itself skips while startup is in flight.
+     *
+     * A foreground runs the resume config refresh and, after the session gap, a journey session
+     * start (`NamiRefs.foreground`); a background pauses a pending journey and starts the gap
+     * (NAM-3233).
      */
     listenForAppForeground() {
-        if (__classPrivateFieldGet(this, _Nami_removeForegroundListener, "f"))
-            return;
-        __classPrivateFieldSet(this, _Nami_removeForegroundListener, getPlatformAdapters().device.onAppForeground?.(() => {
-            void NamiRefs.instance.resume();
-        }) ?? null, "f");
+        const device = getPlatformAdapters().device;
+        if (!__classPrivateFieldGet(this, _Nami_removeForegroundListener, "f")) {
+            __classPrivateFieldSet(this, _Nami_removeForegroundListener, device.onAppForeground?.(() => {
+                void NamiRefs.instance.foreground();
+            }) ?? null, "f");
+        }
+        if (!__classPrivateFieldGet(this, _Nami_removeBackgroundListener, "f")) {
+            __classPrivateFieldSet(this, _Nami_removeBackgroundListener, device.onAppBackground?.(() => JourneyCoordinator.shared.appDidEnterBackground()) ?? null, "f");
+        }
     }
     async initializeSDK(config) {
         let fullReconfig = false;
@@ -63149,7 +63805,7 @@ class Nami {
         };
     }
 }
-_Nami_isInitialized = new WeakMap(), _Nami_removeForegroundListener = new WeakMap();
+_Nami_isInitialized = new WeakMap(), _Nami_removeForegroundListener = new WeakMap(), _Nami_removeBackgroundListener = new WeakMap();
 Nami.instance = new Nami();
 
 const VALID_STYLES = new Set(['fullscreen', 'sheet', 'compact_sheet', 'modal']);
@@ -64721,6 +65377,8 @@ let NamiFlowManager$2 = class NamiFlowManager {
         this.flowOpen = false;
         this.currentFlow = undefined;
         this.lastAnimatedFlowProgress.clear();
+        // Lets an adapter tear down a presentation it owns, e.g. a web journey (NAM-3233).
+        getPlatformAdapters().ui.onFlowFinished?.();
     }
     /**
      * Gets the last animated progress for a component by ID
@@ -64973,6 +65631,8 @@ let NamiFlowManager$2 = class NamiFlowManager {
         return this.instance.getCurrentFlowStepAutoAdvanceDelay();
     }
 };
+// Journey delivery reads whether a flow is open without importing this module (NAM-3233).
+registerFlowOpenProbe(() => NamiFlowManager$2.isFlowOpen());
 
 var NamiFlowManager$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -66616,6 +67276,9 @@ let NamiCampaignManager$2 = class NamiCampaignManager {
                 customAttributes: (context?.customAttributes ?? {}),
             });
         }
+        // A journey still waiting for its delay must not fire on top of this placement (NAM-3233).
+        if (!campaignNotFound)
+            JourneyCoordinator.shared.placementWillRaise();
         const component = getPlatformAdapters().ui.createPaywall(type, value, context);
         // Generate and store launch ID for successful campaign launch
         const launchId = generateUUID();
@@ -67313,4 +67976,4 @@ var internal = /*#__PURE__*/Object.freeze({
     NamiPurchaseManager: NamiPurchaseManager
 });
 
-export { ALREADY_CONFIGURED, ANONYMOUS_MODE, ANONYMOUS_MODE_ALREADY_OFF, ANONYMOUS_MODE_ALREADY_ON, ANONYMOUS_MODE_LOGIN_NOT_ALLOWED, ANONYMOUS_UUID, APIError, API_ACTIVE_ENTITLEMENTS, API_CAMPAIGN_RULES, API_CAMPAIGN_SESSION_TIMESTAMP, API_CONFIG, API_MAX_CALLS_LIMIT, API_PAYWALLS, API_PRODUCTS, API_RETRY_DELAY_SEC, API_TIMEOUT_LIMIT, API_TRAFFIC_OBSERVER, API_VERSION, AUTH_DEVICE, AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED, AVAILABLE_CAMPAIGNS_CHANGED, AccountStateAction, AnonymousCDPError, AnonymousLoginError, AnonymousModeAlreadyOffError, AnonymousModeAlreadyOnError, BASE_STAGING_URL, BASE_URL, BASE_URL_PATH, BadRequestError, BasicNamiFlow, BorderMap, BorderSideMap, CAMPAIGN_CACHE_TTL_PREFIX, CAMPAIGN_NOT_AVAILABLE, CONFIG_API_TIMEOUT_LIMIT, CONFIG_MAX_ATTEMPTS, CUSTOMER_ATTRIBUTES_KEY_PREFIX, CUSTOMER_JOURNEY_STATE_CHANGED, CUSTOM_HOST_PREFIX, CampaignNotAvailableError, CampaignRuleConversionEventType, CampaignRuleRepository, Capabilities, ClientError, ConfigRepository, ConflictError, CustomerJourneyRepository, DEFAULT_JOURNEY_SETTINGS, DEVELOPMENT, DEVICE_API_TIMEOUT_LIMIT, DEVICE_ID_NOT_SET, DEVICE_ID_REQUIRED, DISABLE_ASYNC_LOGIN_LOGOUT, DeviceIDRequiredError, DeviceRepository, EXTENDED_CLIENT_INFO_DELIMITER, EXTENDED_CLIENT_INFO_PREFIX, EXTENDED_PLATFORM, EXTENDED_PLATFORM_VERSION, EXTERNAL_ID_REQUIRED, EntitlementRepository, EntitlementUtils, ExternalIDRequiredError, FLOW_SCREENS_NOT_AVAILABLE, FlowScreensNotAvailableError, HTML_REGEX, INITIAL_APP_CONFIG, INITIAL_CAMPAIGN_RULES, INITIAL_PAYWALLS, INITIAL_PRODUCTS, INITIAL_SESSION_COUNTER_VALUE, INITIAL_SUCCESS, InternalServerError, KEY_SESSION_COUNTER, LIQUID_VARIABLE_REGEX, LOCAL_NAMI_ENTITLEMENTS, LOG_HTTP_REQUESTS, LOG_HTTP_TRAFFIC, LaunchCampaignError, LaunchContextResolver, LogLevel, MAX_FIXED_STEP_COUNT, MIN_FIXED_STEP_COUNT, NAMI_CONFIGURATION, NAMI_CUSTOMER_JOURNEY_STATE, NAMI_LANGUAGE_CODE, NAMI_LAST_IMPRESSION_ID, NAMI_LAUNCH_ID, NAMI_PROFILE, NAMI_PURCHASE_CHANNEL, NAMI_PURCHASE_IMPRESSION_ID, NAMI_SDK_PACKAGE_VERSION, NAMI_SDK_VERSION, NAMI_SESSION_ID, NAMI_STORAGE_KEYS, Nami, NamiAPI, NamiAnimationType, NamiCampaignManager$1 as NamiCampaignManager, NamiCampaignRuleType, NamiConditionEvaluator, NamiCustomerManager$1 as NamiCustomerManager, NamiEntitlementManager$1 as NamiEntitlementManager, NamiEventEmitter, NamiFlow, NamiFlowActionFunction, NamiFlowManager$1 as NamiFlowManager, NamiFlowStepType, NamiHandoffTag, NamiPaywallAction, NamiPaywallManager$1 as NamiPaywallManager, PaywallManagerEvents as NamiPaywallManagerEvents, NamiPermissionOutcome, NamiPurchaseManager$1 as NamiPurchaseManager, NamiRefs, NamiReservedActions, NotFoundError, PAYWALL_ACTION_EVENT, PLATFORM_ID_REQUIRED, PRODUCTION, PaywallManagerEvents, PaywallRepository, PaywallState, PlacementLabelResolver, PlatformIDRequiredError, ProductRepository, RECONFIG_SUCCESS, RESUME_THROTTLE_MS, RetryLimitExceededError, SDKNotInitializedError, SDK_NOT_INITIALIZED, SERVER_NAMI_ENTITLEMENTS, SESSION_REQUIRED, SHOULD_SHOW_LOADING_INDICATOR, SIMULATE_CONFIG_FETCH_FAILURE, SIMULATE_PAYWALL_FETCH_FAILURE, SKU_TEXT_REGEX, SMART_TEXT_PATTERN, STARTUP_TELEMETRY, STATUS_BAD_REQUEST, STATUS_CONFLICT, STATUS_INTERNAL_SERVER_ERROR, STATUS_NOT_FOUND, STATUS_SUCCESS, SYSTEM_TIME_FILTER_PREFIX, SYSTEM_TIME_TOKEN_PREFIX, SessionService, SimpleEventTarget, StorageService, TIME_OVERRIDE_PREFIX, TRANSPORT_FAILURE_STATUS, UNABLE_TO_UPDATE_CDP_ID, USE_STAGING_API, VALIDATE_PRODUCT_GROUPS, VAR_REGEX, NamiProfileManager$1 as _NamiProfileManager, internal as _internal, activateEntitlementByPurchase, activeEntitlements, aggregateScreenreaderText, allCampaigns, allPaywalls, applyEntitlementActivation, audienceSplitPosition, bestUrlCampaignMatch, bigintToUuid, checkAnySkuHasPromoOffer, checkAnySkuHasTrialOffer, convertISO8601PeriodToText, convertLocale, convertOfferToPricingPhase, createNamiEntitlements, currentSku, didReceiveResponse, empty, evaluateSystemTimeAssertion, evaluateSystemTimeCondition, evenSegmentWidth, extractStandardPricingPhases, firstSet, formatDate, formattedPrice, generateUUID, getApiCampaigns, getApiPaywalls, getBaseUrl, getBillingPeriodNumber, getCurrencyFormat, getDeviceData, getDeviceFormFactor, getDeviceScaleFactor, getEffectiveWebStyle, getEntitlementRefIdsForSku, getExtendedClientInfo, getFreeTrialPeriod, getInitialCampaigns, getInitialPaywalls, getJourneySettings, getPaywall, getPaywallDataFromLabel, getPercentagePriceDifference, getPeriodNumberInDays, getPeriodNumberInWeeks, getPlatformAdapters, getPriceDifference, getPricePerMonth, getProductDetail, getPurchaseAdapter, getReferenceSku, getSkuProductDetailKeys, getSkuSmartTextValue, getSlideSmartTextValue, getStandardBillingPeriod, getSystemTimeNow, getTranslate, getUrlParams, handleErrors, hasAllPaywalls, hasCapability, hasPurchaseManagement, initialState, invokeHandler, isAnonymousMode, isInitialConfigCompressed, isNamiFlowCampaign, isStepsStyle, isSubscription, isSystemTimeAssertion, isValidISODate, isValidUrl, journeyCampaigns, logger, mapAnonymousCampaigns, namiBuySKU, normalizeLaunchContext, parseTimeOverride, parseToSemver, postConversion, productDetail, registerAPITrafficObserver, registerPlatformAdapters, registerPurchaseAdapter, resolveCurrentStep, resolveLoopSource, resolveStepAlignment, resolveStepCount, resolveStepSizing, selectSegment, setActiveNamiEntitlements, shouldValidateProductGroups, skuItems, skuMapFromEntitlements, stepSegmentState, storageService, toDouble, toNamiEntitlements, toNamiSKU, tryParseB64Gzip, tryParseJson, updateRelatedSKUsForNamiEntitlement, uuidFromSplitPosition, validateForm, validateMinSDKVersion, validateTextInput };
+export { ALREADY_CONFIGURED, ANONYMOUS_MODE, ANONYMOUS_MODE_ALREADY_OFF, ANONYMOUS_MODE_ALREADY_ON, ANONYMOUS_MODE_LOGIN_NOT_ALLOWED, ANONYMOUS_UUID, APIError, API_ACTIVE_ENTITLEMENTS, API_CAMPAIGN_RULES, API_CAMPAIGN_SESSION_TIMESTAMP, API_CONFIG, API_MAX_CALLS_LIMIT, API_PAYWALLS, API_PRODUCTS, API_RETRY_DELAY_SEC, API_TIMEOUT_LIMIT, API_TRAFFIC_OBSERVER, API_VERSION, AUTH_DEVICE, AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED, AVAILABLE_CAMPAIGNS_CHANGED, AccountStateAction, AnonymousCDPError, AnonymousLoginError, AnonymousModeAlreadyOffError, AnonymousModeAlreadyOnError, BASE_STAGING_URL, BASE_URL, BASE_URL_PATH, BadRequestError, BasicNamiFlow, BorderMap, BorderSideMap, CAMPAIGN_CACHE_TTL_PREFIX, CAMPAIGN_NOT_AVAILABLE, CONFIG_API_TIMEOUT_LIMIT, CONFIG_MAX_ATTEMPTS, CUSTOMER_ATTRIBUTES_KEY_PREFIX, CUSTOMER_JOURNEY_STATE_CHANGED, CUSTOM_HOST_PREFIX, CampaignNotAvailableError, CampaignRuleConversionEventType, CampaignRuleRepository, Capabilities, ClientError, ConfigRepository, ConflictError, CustomerJourneyRepository, DEFAULT_JOURNEY_SETTINGS, DEVELOPMENT, DEVICE_API_TIMEOUT_LIMIT, DEVICE_ID_NOT_SET, DEVICE_ID_REQUIRED, DISABLE_ASYNC_LOGIN_LOGOUT, DISABLE_JOURNEY_DELIVERY, DeviceIDRequiredError, DeviceRepository, EXTENDED_CLIENT_INFO_DELIMITER, EXTENDED_CLIENT_INFO_PREFIX, EXTENDED_PLATFORM, EXTENDED_PLATFORM_VERSION, EXTERNAL_ID_REQUIRED, EntitlementRepository, EntitlementUtils, ExternalIDRequiredError, FLOW_SCREENS_NOT_AVAILABLE, FlowScreensNotAvailableError, HTML_REGEX, INITIAL_APP_CONFIG, INITIAL_CAMPAIGN_RULES, INITIAL_PAYWALLS, INITIAL_PRODUCTS, INITIAL_SESSION_COUNTER_VALUE, INITIAL_SUCCESS, InternalServerError, KEY_SESSION_COUNTER, LIQUID_VARIABLE_REGEX, LOCAL_NAMI_ENTITLEMENTS, LOG_HTTP_REQUESTS, LOG_HTTP_TRAFFIC, LaunchCampaignError, LaunchContextResolver, LogLevel, MAX_FIXED_STEP_COUNT, MIN_FIXED_STEP_COUNT, NAMI_CONFIGURATION, NAMI_CUSTOMER_JOURNEY_STATE, NAMI_JOURNEY_INSTALL_EVALUATED, NAMI_JOURNEY_RULE_STATE, NAMI_LANGUAGE_CODE, NAMI_LAST_IMPRESSION_ID, NAMI_LAUNCH_ID, NAMI_PROFILE, NAMI_PURCHASE_CHANNEL, NAMI_PURCHASE_IMPRESSION_ID, NAMI_SDK_PACKAGE_VERSION, NAMI_SDK_VERSION, NAMI_SESSION_ID, NAMI_STORAGE_KEYS, Nami, NamiAPI, NamiAnimationType, NamiCampaignManager$1 as NamiCampaignManager, NamiCampaignRuleType, NamiConditionEvaluator, NamiCustomerManager$1 as NamiCustomerManager, NamiEntitlementManager$1 as NamiEntitlementManager, NamiEventEmitter, NamiFlow, NamiFlowActionFunction, NamiFlowManager$1 as NamiFlowManager, NamiFlowStepType, NamiHandoffTag, NamiPaywallAction, NamiPaywallManager$1 as NamiPaywallManager, PaywallManagerEvents as NamiPaywallManagerEvents, NamiPermissionOutcome, NamiPurchaseManager$1 as NamiPurchaseManager, NamiRefs, NamiReservedActions, NotFoundError, PAYWALL_ACTION_EVENT, PLATFORM_ID_REQUIRED, PRODUCTION, PaywallManagerEvents, PaywallRepository, PaywallState, PlacementLabelResolver, PlatformIDRequiredError, ProductRepository, RECONFIG_SUCCESS, RESUME_THROTTLE_MS, RetryLimitExceededError, SDKNotInitializedError, SDK_NOT_INITIALIZED, SERVER_NAMI_ENTITLEMENTS, SESSION_GAP_MS, SESSION_REQUIRED, SHOULD_SHOW_LOADING_INDICATOR, SIMULATE_CONFIG_FETCH_FAILURE, SIMULATE_PAYWALL_FETCH_FAILURE, SKU_TEXT_REGEX, SMART_TEXT_PATTERN, STARTUP_TELEMETRY, STATUS_BAD_REQUEST, STATUS_CONFLICT, STATUS_INTERNAL_SERVER_ERROR, STATUS_NOT_FOUND, STATUS_SUCCESS, SYSTEM_TIME_FILTER_PREFIX, SYSTEM_TIME_TOKEN_PREFIX, SessionService, SimpleEventTarget, StorageService, TIME_OVERRIDE_PREFIX, TRANSPORT_FAILURE_STATUS, UNABLE_TO_UPDATE_CDP_ID, USE_STAGING_API, VALIDATE_PRODUCT_GROUPS, VAR_REGEX, NamiProfileManager$1 as _NamiProfileManager, internal as _internal, activateEntitlementByPurchase, activeEntitlements, aggregateScreenreaderText, allCampaigns, allPaywalls, applyEntitlementActivation, audienceSplitPosition, bestUrlCampaignMatch, bigintToUuid, checkAnySkuHasPromoOffer, checkAnySkuHasTrialOffer, convertISO8601PeriodToText, convertLocale, convertOfferToPricingPhase, createNamiEntitlements, currentSku, didReceiveResponse, empty, evaluateSystemTimeAssertion, evaluateSystemTimeCondition, evenSegmentWidth, extractStandardPricingPhases, firstSet, formatDate, formattedPrice, generateUUID, getApiCampaigns, getApiPaywalls, getBaseUrl, getBillingPeriodNumber, getCurrencyFormat, getDeviceData, getDeviceFormFactor, getDeviceScaleFactor, getEffectiveWebStyle, getEntitlementRefIdsForSku, getExtendedClientInfo, getFreeTrialPeriod, getInitialCampaigns, getInitialPaywalls, getJourneySettings, getPaywall, getPaywallDataFromLabel, getPercentagePriceDifference, getPeriodNumberInDays, getPeriodNumberInWeeks, getPlatformAdapters, getPriceDifference, getPricePerMonth, getProductDetail, getPurchaseAdapter, getReferenceSku, getSkuProductDetailKeys, getSkuSmartTextValue, getSlideSmartTextValue, getStandardBillingPeriod, getSystemTimeNow, getTranslate, getUrlParams, handleErrors, hasAllPaywalls, hasCapability, hasPurchaseManagement, initialState, invokeHandler, isAnonymousMode, isInitialConfigCompressed, isNamiFlowCampaign, isStepsStyle, isSubscription, isSystemTimeAssertion, isValidISODate, isValidUrl, journeyCampaigns, logger, mapAnonymousCampaigns, namiBuySKU, normalizeLaunchContext, parseTimeOverride, parseToSemver, postConversion, productDetail, registerAPITrafficObserver, registerPlatformAdapters, registerPurchaseAdapter, resolveCurrentStep, resolveLoopSource, resolveStepAlignment, resolveStepCount, resolveStepSizing, selectSegment, setActiveNamiEntitlements, shouldValidateProductGroups, skuItems, skuMapFromEntitlements, stepSegmentState, storageService, toDouble, toNamiEntitlements, toNamiSKU, tryParseB64Gzip, tryParseJson, updateRelatedSKUsForNamiEntitlement, uuidFromSplitPosition, validateForm, validateMinSDKVersion, validateTextInput };