@scalebun/react-native 1.0.4 → 1.2.0

package/src/pipeline/queue/persistentQueue.ts

@@ -87,7 +87,7 @@ export class PersistentQueue {
         this.config = { ...DEFAULT_PERSISTENCE_CONFIG, ...config };
         this.meta = this._loadMeta();
 
-        logger.debug(
+        __DEV__ && logger.debug(
             `[PersistentQueue] Initialized: count=${this.meta.count}, ` +
             `bytes=${this.meta.totalBytes}, head=${this.meta.head}, tail=${this.meta.tail}`,
         );
@@ -150,7 +150,7 @@ export class PersistentQueue {
                     this.meta.totalBytes -= raw.length;
                 } else {
                     // Gap — entry was already evicted or corrupted
-                    logger.debug(`[PersistentQueue] Missing entry at seq=${seq}`);
+                    __DEV__ && logger.debug(`[PersistentQueue] Missing entry at seq=${seq}`);
                 }
             }
 
@@ -224,7 +224,7 @@ export class PersistentQueue {
     drainLeftovers(): Envelope[] {
         if (this.meta.count === 0) return [];
 
-        logger.info(
+        __DEV__ && logger.info(
             `[PersistentQueue] Draining ${this.meta.count} leftover envelopes ` +
             `from previous run (${this.meta.totalBytes} bytes)`,
         );
@@ -311,7 +311,7 @@ export class PersistentQueue {
                 totalBytes,
             };
 
-            logger.info(
+            __DEV__ && logger.info(
                 `[PersistentQueue] Recovered metadata: ${meta.count} entries, ` +
                 `head=${meta.head}, tail=${meta.tail}, bytes=${meta.totalBytes}`,
             );
@@ -381,34 +381,5 @@ export class PersistentQueue {
     }
 }
 
-// ─── Factory ────────────────────────────────────────────────────────────────
-
-/**
- * Create a PersistentQueue with the best available backend.
- *
- * If persistence is disabled in config, uses MemoryBackend.
- * Otherwise uses the shared first-party durable backend from createStorageBackend().
- *
- * @param config - Persistence config from SDK init
- * @param backend - Override backend (for tests). If provided, skips auto-detection.
- */
-export function createPersistentQueue(
-    config: Partial<PersistenceConfig> = {},
-    backend?: StorageBackend,
-): PersistentQueue {
-    if (backend) {
-        return new PersistentQueue(backend, config);
-    }
-
-    const mergedConfig = { ...DEFAULT_PERSISTENCE_CONFIG, ...config };
-
-    if (!mergedConfig.enabled) {
-        logger.info('[PersistentQueue] Persistence disabled — using in-memory queue');
-        const { MemoryBackend } = require('../../storage/StorageBackend');
-        return new PersistentQueue(new MemoryBackend(), mergedConfig);
-    }
-
-    const { createStorageBackend } = require('../../storage/StorageBackend');
-    const autoBackend = createStorageBackend();
-    return new PersistentQueue(autoBackend, mergedConfig);
-}
+// (A createPersistentQueue factory used to live here; every construction site builds
+// PersistentQueue directly with an explicit backend, so the factory was verified dead and removed.)

package/src/pipeline/scheduler/flushScheduler.ts

@@ -16,7 +16,7 @@ export class FlushScheduler {
             // Skip if the previous tick's flush hasn't settled — avoids
             // overlapping flushes piling up when the network is slow.
             if (this.running) {
-                logger.debug('[FlushScheduler] Previous flush still running — skipping tick');
+                __DEV__ && logger.debug('[FlushScheduler] Previous flush still running — skipping tick');
                 return;
             }
             this.running = true;

package/src/public/ScaleBunFacade.ts

@@ -234,7 +234,7 @@ class ScaleBunFacade {
                     const realQueue = coreContainer.get<PersistentQueue>('PersistentQueue');
                     const buffered = this._preInitBuffer.popBatch(this._preInitBuffer.length());
                     if (buffered.length > 0) {
-                        logger.debug(`[ScaleBun] Draining ${buffered.length} pre-init events into persistent queue`);
+                        __DEV__ && logger.debug(`[ScaleBun] Draining ${buffered.length} pre-init events into persistent queue`);
                         for (const envelope of buffered) {
                             realQueue.add(envelope);
                         }
@@ -251,6 +251,13 @@ class ScaleBunFacade {
                 // Continue — debug connection is independent of backend API
             }
 
+            // OTA from init config. Without this the whole `ota` config block was
+            // inert: `otaOrchestrator.init()` was reachable only by importing the
+            // orchestrator directly, so an app that followed the documented
+            // `ota: { enabled: true }` path silently got no updates AND no
+            // signature enforcement (sync() gates on the flag init() sets).
+            this._maybeStartOta(rawConfig);
+
             // Auto debug connection from init config — runs regardless of backend status
             const debugConfig = (rawConfig?.desktopDebug ?? rawConfig?.debug) as DebugConnectionConfig | undefined;
             if (debugConfig) {
@@ -264,13 +271,51 @@ class ScaleBunFacade {
         }
     }
 
+    /**
+     * Boot the OTA orchestrator when the init config asks for it.
+     *
+     * `publicSigningKey` is honoured here so signature enforcement is reachable
+     * from configuration alone. The SDK ships no ed25519 implementation, so a
+     * host that pins a key must also supply `ota.verifySignature`; pinning a key
+     * without a verifier is fail-CLOSED by design (signature.ts) — an update
+     * that cannot be verified is not installed. We say that out loud rather than
+     * letting the app discover it as a silent no-update condition.
+     */
+    private _maybeStartOta(rawConfig: any): void {
+        const ota = rawConfig?.ota;
+        if (!ota?.enabled) return;
+        try {
+            // Required lazily: hosts that never enable OTA should not pay for the
+            // module (or touch the native spec) at import time.
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { otaOrchestrator } = require('../features/ota/OtaOrchestrator');
+            const publicKey = ota.publicSigningKey;
+            const verifier = ota.verifySignature;
+            if (publicKey && typeof verifier !== 'function') {
+                logger.warn(
+                    '[ScaleBun] ota.publicSigningKey is set but ota.verifySignature is not a function. ' +
+                        'Signature checking is fail-closed: updates will be REJECTED until a verifier is supplied.',
+                );
+            }
+            otaOrchestrator.init({
+                ...(publicKey ? { signature: { publicKey, verifier } } : {}),
+                ...(typeof ota.healthyTimeoutMs === 'number'
+                    ? { healthyTimeoutMs: ota.healthyTimeoutMs }
+                    : {}),
+            });
+            logger.info('[ScaleBun] OTA enabled from init config.');
+        } catch (err: any) {
+            logger.warn(`[ScaleBun] OTA init failed: ${err?.message ?? err}`);
+        }
+    }
+
     private _autoEnableDebug(debugConfig: DebugConnectionConfig): void {
         try {
             const dbgConfig = buildDebugConfigFromInitConfig(debugConfig);
             if (!dbgConfig) return;
             (dbgConfig as any).__skipDeprecationWarning = true;
             this.enableDebug(dbgConfig);
-            logger.info('[ScaleBun] Debug auto-connected via init({ debug }).');
+            __DEV__ && logger.info('[ScaleBun] Debug auto-connected via init({ debug }).');
         } catch (err: any) {
             logger.warn('[ScaleBun] Auto debug connection failed:', err?.message);
         }
@@ -287,7 +332,7 @@ class ScaleBunFacade {
             const apiBaseUrl = this._apiBaseUrl;
             if (!enabled || !appId || !clientKey || !apiBaseUrl) {
                 if (enabled && !appId) {
-                    logger.info('[ScaleBun] Envelope event tracking disabled — no appId in init config.');
+                    __DEV__ && logger.info('[ScaleBun] Envelope event tracking disabled — no appId in init config.');
                 }
                 return;
             }
@@ -336,7 +381,7 @@ class ScaleBunFacade {
                 onEvent: (eventName, revenue) => this._skanManager?.onEvent(eventName, revenue),
             });
             this._eventTracker.start();
-            logger.info('[ScaleBun] Envelope event tracking started → /v1/batch.');
+            __DEV__ && logger.info('[ScaleBun] Envelope event tracking started → /v1/batch.');
 
             // Android: capture the Play Install Referrer once per install → feeds the
             // deterministic click_id path + a one-off install_referrer event (UTM/gclid).
@@ -859,7 +904,7 @@ class ScaleBunFacade {
             const cfg = await (this._getEngageTransport()?.fetchEngageConfig(context) ?? Promise.resolve(null));
             const messages = cfg?.inAppMessages ?? [];
             const previews = messages.filter((m) => m.preview === true || m.isTest === true);
-            logger.info(
+            __DEV__ && logger.info(
                 `[Engage] debugFetchInAppMessages → ${messages.length} message(s), ${previews.length} test preview(s)`,
             );
             return messages;
@@ -1170,7 +1215,7 @@ class ScaleBunFacade {
                 logger.warn('SDK not initialized. Event dropped:', name);
                 return;
             }
-            logger.debug('Tracking event:', name);
+            __DEV__ && logger.debug('Tracking event:', name);
 
             // Fan this event out to the Engage trigger engine. Same single funnel,
             // extra observer — lets behavioral triggers (custom_event, failed_action,
@@ -1310,7 +1355,7 @@ class ScaleBunFacade {
                 ]);
                 return;
             }
-            logger.debug('Flushing events from persistent queue...');
+            __DEV__ && logger.debug('Flushing events from persistent queue...');
             const httpClient = coreContainer.get<HttpClient>('HttpClient');
             await flushQueue(this._getQueue(), httpClient, getDeviceId());
         });
@@ -1338,10 +1383,10 @@ class ScaleBunFacade {
             const bootstrapPerfFeature = _getPerformanceFeature();
             if (bootstrapPerfFeature) {
                 this._performanceFeature = bootstrapPerfFeature;
-                logger.debug('Performance feature linked from bootstrap');
+                __DEV__ && logger.debug('Performance feature linked from bootstrap');
             }
 
-            logger.info('Debug enabled');
+            __DEV__ && logger.info('Debug enabled');
         });
     }
 
@@ -1496,14 +1541,14 @@ class ScaleBunFacade {
                 return false;
             }
             sm.startSession(metadata as Parameters<SessionManager['startSession']>[0]);
-            logger.info('session.start() ✅ sessionId:', sm.currentSessionId);
+            __DEV__ && logger.info('session.start() ✅ sessionId:', sm.currentSessionId);
             return true;
         },
         end: (reason?: 'ended' | 'timeout'): boolean => {
             const sm = SessionManager.getExistingInstance();
             if (!sm || !sm.isActive) return false;
             sm.endSession(reason);
-            logger.info('session.end() ✅');
+            __DEV__ && logger.info('session.end() ✅');
             return true;
         },
         emitEvent: (type: string, data?: Record<string, unknown>) => {
@@ -1559,13 +1604,13 @@ class ScaleBunFacade {
         /** Set SDK-wide privacy settings for report generation. */
         setPrivacy: (config: PrivacyConfig): void => {
             this._privacyConfig = { ...this._privacyConfig, ...config };
-            logger.debug('[report] Privacy config updated');
+            __DEV__ && logger.debug('[report] Privacy config updated');
         },
 
         /** Set branding for exported reports. */
         setBranding: (config: BrandingConfig): void => {
             this._brandingConfig = { ...this._brandingConfig, ...config };
-            logger.debug('[report] Branding config updated');
+            __DEV__ && logger.debug('[report] Branding config updated');
         },
 
         /** Get current privacy config. */
@@ -1616,9 +1661,9 @@ class ScaleBunFacade {
             try {
                 const { AutoScreenDetector } = require('../features/navigation/AutoScreenDetector');
                 AutoScreenDetector.getInstance().setNavigationRef(ref);
-                logger.info('[ScaleBun] Navigation ref set → auto screen detection active');
+                __DEV__ && logger.info('[ScaleBun] Navigation ref set → auto screen detection active');
             } catch (err: any) {
-                logger.debug('[ScaleBun] Navigation ref stashed (detector not ready):', err?.message);
+                __DEV__ && logger.debug('[ScaleBun] Navigation ref stashed (detector not ready):', err?.message);
             }
         });
     }

package/src/public/types.ts

@@ -78,14 +78,28 @@ export interface ScaleBunInitConfig {
     /** Publishable API key from dashboard */
     publishableKey: string;
     /**
-     * Backend API base URL. Optional — defaults to the ScaleBun cloud.
-     * Override only for staging or a self-hosted backend.
+     * @deprecated The endpoint is LOCKED to the ScaleBun cloud. Any value passed here is accepted
+     * (for backward compatibility) but ignored — the bootstrapper always uses the fixed
+     * `DEFAULT_API_BASE_URL`. To target a different backend, change that constant at build time.
      */
     apiBaseUrl?: string;
     /** @deprecated Use desktopDebug instead */
     debug?: boolean;
-    /** Enable session replay capture. Default: true */
+    /** Enable session replay capture (feature on/off). Default: true */
     sessionReplay?: boolean;
+    /**
+     * Session-replay capture options (SaaS mode).
+     * - `record` (default **true**): auto-start frame recording at cold launch so replays appear out
+     *   of the box. Set `false` for events-only sessions — you can still record on demand with
+     *   `ScaleBun.startSession()`.
+     * - `captureMode` / `intervalMs` / `quality`: tune capture cadence.
+     */
+    replay?: {
+        record?: boolean;
+        captureMode?: 'navigation' | 'interactions' | 'frequency';
+        intervalMs?: number;
+        quality?: 'high' | 'normal' | 'low' | 'grayscale';
+    };
     /** Event flush interval in ms. Default: 5000 */
     flushIntervalMs?: number;
     /** Max events per flush batch. Default: 1000 */
@@ -234,7 +248,6 @@ export interface ExportResult {
  * await ScaleBun.init({
  *   projectId: 'proj_xxx',
  *   publishableKey: 'pk_xxx',
- *   apiBaseUrl: 'https://api.scalebun.com',
  * });
  * ```
  *
@@ -243,7 +256,6 @@ export interface ExportResult {
  * await ScaleBun.init({
  *   projectId: 'proj_xxx',
  *   publishableKey: 'pk_xxx',
- *   apiBaseUrl: 'https://api.scalebun.com',
  *   debug: true,
  * });
  * ```
@@ -254,8 +266,9 @@ export interface SimplifiedInitConfig {
     /** Publishable API key from dashboard */
     publishableKey: string;
     /**
-     * Backend API base URL. Optional — defaults to the ScaleBun cloud.
-     * Override only for staging or a self-hosted backend.
+     * @deprecated The endpoint is LOCKED to the ScaleBun cloud. Any value passed here is accepted
+     * (for backward compatibility) but ignored — the bootstrapper always uses the fixed
+     * `DEFAULT_API_BASE_URL`. To target a different backend, change that constant at build time.
      */
     apiBaseUrl?: string;
 
@@ -271,9 +284,23 @@ export interface SimplifiedInitConfig {
     /** @deprecated Use desktopDebug instead. */
     debug?: DebugConnectionConfig;
 
-    /** Enable session replay capture. Default: true */
+    /** Enable session replay capture (feature on/off). Default: true */
     sessionReplay?: boolean;
 
+    /**
+     * Session-replay capture options (SaaS mode).
+     * - `record` (default **true**): auto-start frame recording at cold launch so replays appear out
+     *   of the box. Set `false` for events-only sessions — you can still record on demand with
+     *   `ScaleBun.startSession()`.
+     * - `captureMode` / `intervalMs` / `quality`: tune capture cadence.
+     */
+    replay?: {
+        record?: boolean;
+        captureMode?: 'navigation' | 'interactions' | 'frequency';
+        intervalMs?: number;
+        quality?: 'high' | 'normal' | 'low' | 'grayscale';
+    };
+
     /** SDK-wide privacy settings */
     privacy?: PrivacyConfig;
 

package/src/push/PushManager.ts

@@ -89,7 +89,7 @@ export class PushManager {
                 return { ok: false, adapter: this.adapter.id, reason: this.reason };
             }
 
-            logger.info('[push] adapter:', this.adapter.id, '—', selection.reason);
+            __DEV__ && logger.info('[push] adapter:', this.adapter.id, '—', selection.reason);
 
             // 1) Permission
             if (!options.skipPermissionRequest) {
@@ -215,7 +215,7 @@ export class PushManager {
      */
     private async syncToken(token: string, force = false): Promise<any> {
         if (!force && token === this.lastSyncedToken) {
-            logger.debug('[push] token unchanged since last registration — skipping');
+            __DEV__ && logger.debug('[push] token unchanged since last registration — skipping');
             return { ok: true, skipped: true };
         }
         const platform = Platform.OS === 'ios' ? 'ios' : 'android';
@@ -224,7 +224,7 @@ export class PushManager {
         // adapter is set (manual setToken before enable).
         const pushProvider: PushProviderId =
             this.adapter?.pushProvider() ?? (platform === 'ios' ? 'apns' : 'fcm');
-        logger.debug(`[push] registering device token with backend (provider=${pushProvider})`);
+        __DEV__ && logger.debug(`[push] registering device token with backend (provider=${pushProvider})`);
         const res = await this.deps.registerToken({ pushToken: token, platform, pushProvider, tokenStatus: 'active' });
         this.lastSyncedToken = token;
         return res;

package/src/push/adapters/NativeBridgeAdapter.ts

@@ -84,7 +84,7 @@ export class NativeBridgeAdapter implements PushAdapter {
     public async createAndroidChannel(_channel: AndroidChannelConfig): Promise<void> {
         // The native bridge has no JS channel API; FCM uses the manifest-declared
         // fallback channel (default_notification_channel_id). No-op on iOS.
-        logger.debug('[push] native adapter relies on FCM fallback channel');
+        __DEV__ && logger.debug('[push] native adapter relies on FCM fallback channel');
     }
 
     public async getToken(): Promise<string | null> {

package/src/push/native/nativeNotifications.ts

@@ -78,7 +78,7 @@ export async function ensureNativeChannel(config: {
             config.description ?? null,
         );
     } catch (err: any) {
-        logger.debug(`[Push.native] ensureChannel failed (fail-soft): ${err?.message}`);
+        __DEV__ && logger.debug(`[Push.native] ensureChannel failed (fail-soft): ${err?.message}`);
         return false;
     }
 }
@@ -102,7 +102,7 @@ export async function showNativeNotification(input: {
             ...(input.notificationId != null ? { notificationId: input.notificationId } : {}),
         });
     } catch (err: any) {
-        logger.debug(`[Push.native] showNotification failed (fail-soft): ${err?.message}`);
+        __DEV__ && logger.debug(`[Push.native] showNotification failed (fail-soft): ${err?.message}`);
         return false;
     }
 }
@@ -124,7 +124,7 @@ export function subscribeNativeNotificationOpened(
         );
         return () => sub.remove();
     } catch (err: any) {
-        logger.debug(`[Push.native] opened subscription failed (fail-soft): ${err?.message}`);
+        __DEV__ && logger.debug(`[Push.native] opened subscription failed (fail-soft): ${err?.message}`);
         return () => {};
     }
 }
@@ -141,20 +141,11 @@ export async function consumeInitialNativeNotification(): Promise<Record<string,
         if (!payload) return null;
         return payload.data ?? {};
     } catch (err: any) {
-        logger.debug(`[Push.native] consumeInitial failed (fail-soft): ${err?.message}`);
+        __DEV__ && logger.debug(`[Push.native] consumeInitial failed (fail-soft): ${err?.message}`);
         return null;
     }
 }
 
-/**
- * iOS (UNUserNotificationCenter): the native module owns the full notification
- * surface — request authorization, foreground presentation, taps, and cold-start.
- * Presence == iOS ScaleBunEngage exposes the notification delegate methods.
- */
-export function hasNativeNotificationDelegate(): boolean {
-    const mod = getModule();
-    return !!(mod?.requestPushPermission && mod?.consumeInitialNotification);
-}
 
 /**
  * iOS: request notification authorization natively. Returns the normalized status
@@ -166,7 +157,7 @@ export async function requestNativePushPermission(): Promise<string | null> {
         if (!mod?.requestPushPermission) return null;
         return await mod.requestPushPermission();
     } catch (err: any) {
-        logger.debug(`[Push.native] requestPushPermission failed (fail-soft): ${err?.message}`);
+        __DEV__ && logger.debug(`[Push.native] requestPushPermission failed (fail-soft): ${err?.message}`);
         return null;
     }
 }
@@ -189,7 +180,7 @@ export function subscribeNativeForegroundNotification(
         );
         return () => sub.remove();
     } catch (err: any) {
-        logger.debug(`[Push.native] foreground subscription failed (fail-soft): ${err?.message}`);
+        __DEV__ && logger.debug(`[Push.native] foreground subscription failed (fail-soft): ${err?.message}`);
         return () => {};
     }
 }
@@ -210,7 +201,7 @@ export async function consumeInitialNativeNotificationFull(): Promise<NativeNoti
             data: payload.data ?? {},
         };
     } catch (err: any) {
-        logger.debug(`[Push.native] consumeInitialFull failed (fail-soft): ${err?.message}`);
+        __DEV__ && logger.debug(`[Push.native] consumeInitialFull failed (fail-soft): ${err?.message}`);
         return null;
     }
 }

package/src/storage/StorageBackend.ts

@@ -244,7 +244,7 @@ export function createStorageBackend(): StorageBackend {
     if (native) {
         try {
             sharedBackend = new NativeKVBackend(native);
-            logger.debug('[StorageBackend] Using native durable backend (ScaleBunStorage)');
+            __DEV__ && logger.debug('[StorageBackend] Using native durable backend (ScaleBunStorage)');
             return sharedBackend;
         } catch (e) {
             logger.warn('[StorageBackend] Native durable store failed to initialize; ' +