@scalebun/react-native 1.0.1 → 1.0.3

package/src/features/engage/engageThrottle.ts

@@ -49,11 +49,24 @@ const STORAGE_PREFIX = 'scalebun_engage_throttle:';
  */
 export class EngageThrottleStore {
     private readonly backend: StorageBackend;
+    /**
+     * Shows in THIS session, backing `maxImpressionsPerSession`.
+     *
+     * Deliberately in-memory rather than persisted: on mobile a session is an app run, and this
+     * store is constructed once per provider mount, so the map's lifetime already is the session's.
+     * Persisting it would outlive the session it is meant to bound.
+     */
+    private readonly sessionShows = new Map<string, number>();
 
     constructor(backend: StorageBackend = createStorageBackend()) {
         this.backend = backend;
     }
 
+    /** How many times this surface has been shown in the current session. */
+    sessionShowCount(campaignId: string): number {
+        return this.sessionShows.get(campaignId) ?? 0;
+    }
+
     private keyFor(campaignId: string): string {
         return `${STORAGE_PREFIX}${campaignId}`;
     }
@@ -130,15 +143,28 @@ export class EngageThrottleStore {
             completed: fresh ? false : prev.completed,
             revision: revision ?? prev.revision,
         });
+        // A new revision is a new design: its session count starts over with its durable counters.
+        this.sessionShows.set(campaignId, fresh ? 1 : this.sessionShowCount(campaignId) + 1);
     }
 
-    /** Mark a campaign as completed (response submitted) — a hard `showOnce` stop. */
-    markCompleted(campaignId: string, now: number = Date.now()): void {
+    /**
+     * Mark a campaign as completed (response submitted, or an in-app message closed) — a hard stop.
+     *
+     * The `revision` MUST be carried through. This wrote the record without one, which silently
+     * disabled the revision check in `passesThrottle` for the rest of that campaign's life on the
+     * device: that check only fires when BOTH the live config and the stored state carry a revision,
+     * so a state stamped `undefined` can never be invalidated. The result was the exact opposite of
+     * the web bug — once a user closed an in-app message, editing the campaign could never bring the
+     * new version back to them. Callers that know the served revision pass it; legacy callers that
+     * don't keep whatever was already stored rather than erasing it.
+     */
+    markCompleted(campaignId: string, now: number = Date.now(), revision?: string): void {
         const prev = this.get(campaignId);
         this.write(campaignId, {
             impressions: prev.impressions,
             lastShownAt: prev.lastShownAt || now,
             completed: true,
+            revision: revision ?? prev.revision,
         });
     }
 }
@@ -168,6 +194,7 @@ function passesThrottle(
     state: CampaignThrottleState,
     now: number,
     revision?: string,
+    sessionShows = 0,
 ): boolean {
     // Revision invalidation: if the live config carries a newer revision than the one
     // the persisted state was recorded against, the campaign's content/design changed —
@@ -192,6 +219,15 @@ function passesThrottle(
         return false;
     }
 
+    // maxImpressionsPerSession: cap within this app run, under any lifetime cap above.
+    if (
+        typeof throttle.maxImpressionsPerSession === 'number' &&
+        throttle.maxImpressionsPerSession > 0 &&
+        sessionShows >= throttle.maxImpressionsPerSession
+    ) {
+        return false;
+    }
+
     // cooldownHours: enforce a quiet window since the last impression.
     if (typeof throttle.cooldownHours === 'number' && state.lastShownAt > 0) {
         const elapsedMs = now - state.lastShownAt;
@@ -219,9 +255,10 @@ export function isCampaignEligible(
     campaign: EngageCampaignConfig,
     state: CampaignThrottleState,
     now: number = Date.now(),
+    sessionShows = 0,
 ): boolean {
     if (!campaign.enabled) return false;
-    return passesThrottle(campaign.id, campaign.throttle, state, now);
+    return passesThrottle(campaign.id, campaign.throttle, state, now, undefined, sessionShows);
 }
 
 /**
@@ -234,8 +271,9 @@ export function isInAppEligible(
     message: InAppMessageConfig,
     state: CampaignThrottleState,
     now: number = Date.now(),
+    sessionShows = 0,
 ): boolean {
-    return passesThrottle(message.id, message.throttle, state, now, message.revision);
+    return passesThrottle(message.id, message.throttle, state, now, message.revision, sessionShows);
 }
 
 /**
@@ -292,7 +330,7 @@ export function selectCampaignToRender(
             typeof campaign.triggerConfig?.seconds === 'number' &&
             campaign.triggerConfig.seconds !== options.seconds
         ) continue;
-        if (isCampaignEligible(campaign, store.get(campaign.id), now)) {
+        if (isCampaignEligible(campaign, store.get(campaign.id), now, store.sessionShowCount(campaign.id))) {
             return campaign;
         }
     }
@@ -342,7 +380,7 @@ export function selectInAppToRender(
             typeof options.seconds === 'number' &&
             message.delaySeconds !== options.seconds
         ) continue;
-        if (isInAppEligible(message, store.get(message.id), now)) {
+        if (isInAppEligible(message, store.get(message.id), now, store.sessionShowCount(message.id))) {
             return message;
         }
     }

package/src/features/engage/engageTypes.ts

@@ -69,6 +69,12 @@ export interface Throttle {
     showOnce?: boolean;
     cooldownHours?: number;
     maxImpressions?: number;
+    /**
+     * Cap WITHIN one session (one app run), independent of the lifetime caps above. The in-app
+     * builder writes this on every campaign and `deriveInAppMirror` now carries it to the wire, so
+     * ignoring it here would be offering an authoring control that does nothing on this platform.
+     */
+    maxImpressionsPerSession?: number;
     samplePct?: number;
 }
 

package/src/features/navigation/AutoScreenDetector.ts

@@ -56,6 +56,8 @@ export class AutoScreenDetector {
     private _started = false;
     private _lastEmittedScreen: string | null = null;
     private _navDebounceTimer: ReturnType<typeof setTimeout> | null = null;
+    /** Whether the React Navigation exports were actually replaced — see _autoHookReactNavigation. */
+    private _autoHookInstalled = false;
 
     /** Cooldown: after manual screen is set, suppress auto-detection for this duration */
     private static MANUAL_COOLDOWN_MS = 2000;
@@ -330,6 +332,37 @@ export class AutoScreenDetector {
             if (!reactNav || reactNav.__scalebunAutoHooked) return;
 
             const detector = this;
+            /** How many entry points were verifiably replaced — 0 means detection is dead. */
+            let installed = 0;
+
+            /**
+             * Replace an export, on a module whose exports are GETTERS.
+             *
+             * `@react-navigation/native` ships ESM whose index is only re-exports, and every bundler
+             * compiles `export { X } from './X.js'` to an accessor with a getter and no setter. Plain
+             * assignment to that throws in strict mode — which is what the three patch points here
+             * used to do, inside a `catch` that discarded the error. The hook reported success, no
+             * container ref was ever captured, and the whole screen-name pipeline stayed empty.
+             *
+             * Defining the property works where assigning does not, and the read-back is what makes
+             * a future failure visible instead of silent.
+             */
+            const redefine = (key: string, value: unknown): boolean => {
+                try {
+                    Object.defineProperty(reactNav, key, {
+                        value,
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                    });
+                } catch {
+                    try {
+                        reactNav[key] = value;
+                    } catch { /* genuinely frozen — reported by the read-back below */ }
+                }
+                return reactNav[key] === value;
+            };
+
             const register = (ref: any) => {
                 try {
                     const container = ref?.current ?? ref;
@@ -362,7 +395,7 @@ export class AutoScreenDetector {
                     return React.createElement(Original, { ...props, ref: setRef });
                 });
                 (Wrapped as any).displayName = 'ScaleBunNavigationContainer';
-                try { reactNav.NavigationContainer = Wrapped; } catch { /* frozen export — skip */ }
+                if (redefine('NavigationContainer', Wrapped)) installed++;
             }
 
             // 2. createNavigationContainerRef — apps that build the ref manually.
@@ -373,7 +406,7 @@ export class AutoScreenDetector {
                     try { detector.setNavigationRef(ref); } catch { /* no-throw */ }
                     return ref;
                 };
-                try { reactNav.createNavigationContainerRef = patchedCreate; } catch { /* skip */ }
+                if (redefine('createNavigationContainerRef', patchedCreate)) installed++;
             }
 
             // 3. useNavigationContainerRef — hook variant of (2).
@@ -384,14 +417,36 @@ export class AutoScreenDetector {
                     try { detector.setNavigationRef(ref); } catch { /* no-throw */ }
                     return ref;
                 };
-                try { reactNav.useNavigationContainerRef = patchedHook; } catch { /* skip */ }
+                if (redefine('useNavigationContainerRef', patchedHook)) installed++;
             }
 
+            this._autoHookInstalled = installed > 0;
             try { reactNav.__scalebunAutoHooked = true; } catch { /* frozen — best-effort */ }
-            logger.debug('[AutoScreenDetector] React Navigation auto-hook installed');
+
+            if (installed === 0) {
+                // Said out loud. The previous silence is why this shipped broken: an app with screen
+                // detection completely dead looked identical to one with it working.
+                logger.warn(
+                    '[AutoScreenDetector] React Navigation is installed but none of its exports could be ' +
+                    'wrapped — screens will not be detected automatically. Pass your container ref to ' +
+                    'ScaleBun.setNavigationRef(ref) to restore screen names.',
+                );
+            } else {
+                logger.debug(`[AutoScreenDetector] React Navigation auto-hook installed (${installed}/3 entry points)`);
+            }
         } catch { /* @react-navigation/native not installed — heuristic remains fallback */ }
     }
 
+    /**
+     * Did the zero-config hook actually take effect?
+     *
+     * Exposed because "we tried" and "it worked" were previously the same observable state, and the
+     * difference between them is every screen name in the product.
+     */
+    isAutoHookInstalled(): boolean {
+        return this._autoHookInstalled;
+    }
+
     /** Stop auto-detection and clean up */
     stop(): void {
         if (this._navDebounceTimer) {