@namiml/sdk-core 3.5.0-dev.202611011853 → 3.5.0-dev.202611021820

package/dist/index.cjs

@@ -106,7 +106,7 @@ const {
 // version — stamped by scripts/version.sh
 NAMI_SDK_VERSION: exports.NAMI_SDK_VERSION = "3.5.0", 
 // full package version including dev suffix — stamped by scripts/version.sh
-NAMI_SDK_PACKAGE_VERSION: exports.NAMI_SDK_PACKAGE_VERSION = "3.5.0-dev.202611011853", 
+NAMI_SDK_PACKAGE_VERSION: exports.NAMI_SDK_PACKAGE_VERSION = "3.5.0-dev.202611021820", 
 // environments
 PRODUCTION: exports.PRODUCTION = "production", DEVELOPMENT: exports.DEVELOPMENT = "development", 
 // error messages
@@ -114,7 +114,9 @@ PLATFORM_ID_REQUIRED: exports.PLATFORM_ID_REQUIRED = "Platform ID is required",
 // localstorage keys
 AUTH_DEVICE: exports.AUTH_DEVICE = "nami_auth_device", NAMI_CONFIGURATION: exports.NAMI_CONFIGURATION = "nami_configuration", NAMI_PROFILE: exports.NAMI_PROFILE = "nami_profile", API_CONFIG: exports.API_CONFIG = "api_config", API_CAMPAIGN_RULES: exports.API_CAMPAIGN_RULES = "api_campaign_rules", API_PAYWALLS: exports.API_PAYWALLS = "api_paywalls", API_CAMPAIGN_SESSION_TIMESTAMP: exports.API_CAMPAIGN_SESSION_TIMESTAMP = "api_campaign_session_timestamp", API_PRODUCTS: exports.API_PRODUCTS = "api_products", API_ACTIVE_ENTITLEMENTS: exports.API_ACTIVE_ENTITLEMENTS = "api_active_entitlements", SERVER_NAMI_ENTITLEMENTS: exports.SERVER_NAMI_ENTITLEMENTS = "server_active_entitlements", INITIAL_APP_CONFIG: exports.INITIAL_APP_CONFIG = "initial_app_config", INITIAL_CAMPAIGN_RULES: exports.INITIAL_CAMPAIGN_RULES = "initial_campaign_rules", INITIAL_PAYWALLS: exports.INITIAL_PAYWALLS = "initial_paywalls", INITIAL_PRODUCTS: exports.INITIAL_PRODUCTS = "initial_products", LOCAL_NAMI_ENTITLEMENTS: exports.LOCAL_NAMI_ENTITLEMENTS = "local_active_entitlements", CUSTOMER_ATTRIBUTES_KEY_PREFIX: exports.CUSTOMER_ATTRIBUTES_KEY_PREFIX = "nami_cmr_attributes_", NAMI_CUSTOMER_JOURNEY_STATE: exports.NAMI_CUSTOMER_JOURNEY_STATE = "nami_customer_journey_state", 
 // Journey delivery counters (NAM-3229), unrelated to the customer journey state above.
-NAMI_JOURNEY_RULE_STATE: exports.NAMI_JOURNEY_RULE_STATE = "nami_journey_rule_state", ANONYMOUS_MODE: exports.ANONYMOUS_MODE = "nami_anonymous_mode_v2", ANONYMOUS_UUID: exports.ANONYMOUS_UUID = "nami_anonymous_uuid", KEY_SESSION_COUNTER: exports.KEY_SESSION_COUNTER = "nami_session_counter", INITIAL_SESSION_COUNTER_VALUE: exports.INITIAL_SESSION_COUNTER_VALUE = 1, NAMI_LAST_IMPRESSION_ID: exports.NAMI_LAST_IMPRESSION_ID = "nami_last_impression_id", NAMI_PURCHASE_IMPRESSION_ID: exports.NAMI_PURCHASE_IMPRESSION_ID = "nami_purchase_impression_id", NAMI_LAUNCH_ID: exports.NAMI_LAUNCH_ID = "nami_launch_id", NAMI_SESSION_ID: exports.NAMI_SESSION_ID = "nami_session_id", NAMI_LANGUAGE_CODE: exports.NAMI_LANGUAGE_CODE = "nami_language_code", NAMI_PURCHASE_CHANNEL: exports.NAMI_PURCHASE_CHANNEL = "nami_purchase_channel", 
+NAMI_JOURNEY_RULE_STATE: exports.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: exports.NAMI_JOURNEY_INSTALL_EVALUATED = "nami_journey_install_evaluated", ANONYMOUS_MODE: exports.ANONYMOUS_MODE = "nami_anonymous_mode_v2", ANONYMOUS_UUID: exports.ANONYMOUS_UUID = "nami_anonymous_uuid", KEY_SESSION_COUNTER: exports.KEY_SESSION_COUNTER = "nami_session_counter", INITIAL_SESSION_COUNTER_VALUE: exports.INITIAL_SESSION_COUNTER_VALUE = 1, NAMI_LAST_IMPRESSION_ID: exports.NAMI_LAST_IMPRESSION_ID = "nami_last_impression_id", NAMI_PURCHASE_IMPRESSION_ID: exports.NAMI_PURCHASE_IMPRESSION_ID = "nami_purchase_impression_id", NAMI_LAUNCH_ID: exports.NAMI_LAUNCH_ID = "nami_launch_id", NAMI_SESSION_ID: exports.NAMI_SESSION_ID = "nami_session_id", NAMI_LANGUAGE_CODE: exports.NAMI_LANGUAGE_CODE = "nami_language_code", NAMI_PURCHASE_CHANNEL: exports.NAMI_PURCHASE_CHANNEL = "nami_purchase_channel", 
 // API settings
 API_VERSION: exports.API_VERSION = "v3", BASE_URL_PATH: exports.BASE_URL_PATH = `sdk/${exports.API_VERSION}/platform`, BASE_URL: exports.BASE_URL = "https://app.namiml.com", BASE_STAGING_URL: exports.BASE_STAGING_URL = "https://app-staging.namiml.com", CUSTOM_HOST_PREFIX: exports.CUSTOM_HOST_PREFIX = "namiAPIHost=", USE_STAGING_API: exports.USE_STAGING_API = "useStagingAPI", 
 // // extended client info
@@ -122,6 +124,8 @@ EXTENDED_CLIENT_INFO_PREFIX: exports.EXTENDED_CLIENT_INFO_PREFIX = "extendedClie
 // 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: exports.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: exports.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: exports.SIMULATE_PAYWALL_FETCH_FAILURE = "simulatePaywallFetchFailure", 
@@ -144,6 +148,9 @@ CONFIG_API_TIMEOUT_LIMIT: exports.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: exports.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: exports.SESSION_GAP_MS = 30000, 
 // status codes
 STATUS_SUCCESS: exports.STATUS_SUCCESS = 200, STATUS_BAD_REQUEST: exports.STATUS_BAD_REQUEST = 400, STATUS_NOT_FOUND: exports.STATUS_NOT_FOUND = 404, STATUS_CONFLICT: exports.STATUS_CONFLICT = 409, STATUS_INTERNAL_SERVER_ERROR: exports.STATUS_INTERNAL_SERVER_ERROR = 500, 
 // configuration states
@@ -164,7 +171,7 @@ const NAMI_STORAGE_KEYS = [
     exports.API_PRODUCTS, exports.API_ACTIVE_ENTITLEMENTS, exports.SERVER_NAMI_ENTITLEMENTS,
     exports.INITIAL_APP_CONFIG, exports.INITIAL_CAMPAIGN_RULES, exports.INITIAL_PAYWALLS, exports.INITIAL_PRODUCTS,
     exports.LOCAL_NAMI_ENTITLEMENTS,
-    exports.NAMI_CUSTOMER_JOURNEY_STATE, exports.NAMI_JOURNEY_RULE_STATE,
+    exports.NAMI_CUSTOMER_JOURNEY_STATE, exports.NAMI_JOURNEY_RULE_STATE, exports.NAMI_JOURNEY_INSTALL_EVALUATED,
     exports.ANONYMOUS_MODE, exports.ANONYMOUS_UUID,
     exports.KEY_SESSION_COUNTER, exports.NAMI_LAST_IMPRESSION_ID, exports.NAMI_PURCHASE_IMPRESSION_ID,
     exports.NAMI_LAUNCH_ID, exports.NAMI_SESSION_ID, exports.NAMI_LANGUAGE_CODE, exports.NAMI_PURCHASE_CHANNEL,
@@ -607,7 +614,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');
 }
@@ -636,7 +643,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
@@ -724,7 +731,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;
@@ -2300,7 +2307,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);
 }
 
 /**
@@ -3537,6 +3544,13 @@ class StorageService {
     removeJourneyRuleState() {
         this.resetItem(exports.NAMI_JOURNEY_RULE_STATE);
     }
+    /** Whether the one-time app_install journey evaluation has run on this device. */
+    getJourneyInstallEvaluated() {
+        return this.getItem(exports.NAMI_JOURNEY_INSTALL_EVALUATED) === true;
+    }
+    setJourneyInstallEvaluated() {
+        this.setItem(exports.NAMI_JOURNEY_INSTALL_EVALUATED, true);
+    }
     setSessionCounter() {
         const counter = this.getItem(exports.KEY_SESSION_COUNTER);
         const currentCounter = counter ? parseInt(counter) : exports.INITIAL_SESSION_COUNTER_VALUE
@@ -7159,6 +7173,11 @@ const shouldValidateProductGroups = () => {
     const namiCommands = storageService.getNamiConfig()?.namiCommands;
     return namiCommands?.includes(exports.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(exports.DISABLE_JOURNEY_DELIVERY) ?? false;
+};
 const shouldLogHTTPRequests = () => {
     const namiCommands = storageService.getNamiConfig()?.namiCommands;
     return namiCommands?.includes(exports.LOG_HTTP_REQUESTS) ?? false;
@@ -57054,7 +57073,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
@@ -57074,17 +57093,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,
         },
     };
 }
@@ -61074,7 +61093,7 @@ var objectCreate = Object.create;
 var baseCreate = (function() {
   function object() {}
   return function(proto) {
-    if (!isObject(proto)) {
+    if (!isObject$1(proto)) {
       return {};
     }
     if (objectCreate) {
@@ -61238,7 +61257,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);
@@ -61802,8 +61821,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
@@ -61812,7 +61834,7 @@ class PaywallState extends SimpleEventTarget {
      * for the next configure() cycle.
      */
     static reset() {
-        this.providers = [];
+        PaywallState.providers = [];
     }
     static get currentProvider() {
         return PaywallState.providers[0];
@@ -62591,6 +62613,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 >= exports.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)
@@ -62606,6 +63234,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);
     }
@@ -62632,7 +63263,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 `{}`,
@@ -62645,12 +63277,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
@@ -62793,6 +63455,7 @@ class NamiRefs {
             }
             throw error;
         });
+        this.startupFetch = promises.then(() => undefined, () => undefined);
         if (!initialConfig.campaign_rules?.length || !initialConfig.paywalls?.length) {
             await promises;
         }
@@ -62964,39 +63627,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
@@ -63005,6 +63636,7 @@ class Nami {
     constructor() {
         _Nami_isInitialized.set(this, false);
         _Nami_removeForegroundListener.set(this, null);
+        _Nami_removeBackgroundListener.set(this, null);
         this.maxLogging = false;
     }
     get isInitialized() {
@@ -63028,7 +63660,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();
@@ -63036,6 +63670,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.
@@ -63100,16 +63736,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;
@@ -63163,7 +63807,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']);
@@ -64735,6 +65379,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
@@ -64987,6 +65633,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,
@@ -66630,6 +67278,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();