@scalebun/react-native 1.1.0 → 1.2.1

package/src/features/replay/integrations/network/networkAdapter.ts

@@ -47,70 +47,15 @@ export function reportNetworkRequest(request: NetworkRequestSummary): void {
 
         breadcrumbCollector.addNetworkBreadcrumb(sanitized).catch(() => { });
     } catch (err: any) {
-        logger.debug(`Network breadcrumb failed: ${err?.message}`);
+        __DEV__ && logger.debug(`Network breadcrumb failed: ${err?.message}`);
     }
 }
 
-/**
- * Set a filter function to control which URLs are recorded.
- * Return true to include, false to exclude.
- */
-export function setNetworkUrlFilter(filter: ((url: string) => boolean) | null): void {
-    _urlFilter = filter;
-}
-
 /** Enable/disable network breadcrumb collection */
 export function setNetworkEnabled(enabled: boolean): void {
     _enabled = enabled;
 }
 
-/**
- * Optional: create a fetch wrapper that auto-reports requests.
- * This does NOT replace global fetch — it wraps it for convenience.
- */
-export function createTrackedFetch(originalFetch: typeof fetch): typeof fetch {
-    return async function trackedFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-        const startTime = Date.now();
-        const method = init?.method ?? 'GET';
-        const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
-        const requestSize = init?.body ? new Blob([init.body as any]).size : 0;
-
-        try {
-            const response = await originalFetch(input, init);
-            const duration = Date.now() - startTime;
-
-            reportNetworkRequest({
-                method,
-                url,
-                statusCode: response.status,
-                durationMs: duration,
-                requestSizeBytes: requestSize,
-                responseSizeBytes: 0, // Can't reliably get without reading body
-                error: !response.ok,
-                startTimestamp: startTime,
-            });
-
-            return response;
-        } catch (err: any) {
-            const duration = Date.now() - startTime;
-
-            reportNetworkRequest({
-                method,
-                url,
-                statusCode: 0,
-                durationMs: duration,
-                requestSizeBytes: requestSize,
-                responseSizeBytes: 0,
-                error: true,
-                errorMessage: err?.message,
-                startTimestamp: startTime,
-            });
-
-            throw err;
-        }
-    };
-}
-
 /** Basic URL sanitization: mask tokens/keys in query params */
 function sanitizeUrl(url: string): string {
     try {

package/src/features/replay/integrations/react-navigation/navigationIntegration.ts

@@ -65,7 +65,7 @@ export function useReplayNavigation(navigationRef: any): void {
                     }
                 });
 
-                logger.debug(`Screen: ${previousRouteName ?? '(none)'} → ${currentRouteName}`);
+                __DEV__ && logger.debug(`Screen: ${previousRouteName ?? '(none)'} → ${currentRouteName}`);
             }
         });
 

package/src/features/replay/integrations/touch/ReplayRoot.tsx

@@ -95,7 +95,7 @@ export function ReplayRoot({ children, disableInteractionTracking = false }: Rep
         // Also trigger a frame capture for interaction modes
         bridgeAdapter.captureFrame('interaction').catch(() => { });
 
-        logger.debug(`Interaction: ${interactionType} at (${Math.round(touch.pageX)}, ${Math.round(touch.pageY)})`);
+        __DEV__ && logger.debug(`Interaction: ${interactionType} at (${Math.round(touch.pageX)}, ${Math.round(touch.pageY)})`);
     }, [disableInteractionTracking]);
 
     return (

package/src/features/replay/pipeline/batching/batchManager.ts

@@ -116,7 +116,7 @@ class BatchManager {
             logger.warn('Batch queue full — dropping oldest batch');
         }
 
-        logger.debug(`Batch created: ${batch.batchId} (${batch.frames.length} frames, ${batch.events.length} events)`);
+        __DEV__ && logger.debug(`Batch created: ${batch.batchId} (${batch.frames.length} frames, ${batch.events.length} events)`);
         return batch;
     }
 

package/src/features/replay/pipeline/retry/retryPolicy.ts

@@ -49,7 +49,7 @@ export async function withRetry<T>(
             }
 
             const delay = calculateDelay(attempt, config);
-            logger.debug(`${label}: retry ${attempt + 1}/${config.maxAttempts} in ${delay}ms`);
+            __DEV__ && logger.debug(`${label}: retry ${attempt + 1}/${config.maxAttempts} in ${delay}ms`);
             await sleep(delay);
         }
     }

package/src/features/replay/public/api.ts

@@ -81,7 +81,7 @@ export const ReplaySdk = {
             }
 
             if (!config.enabled) {
-                logger.info('SDK disabled via config');
+                __DEV__ && logger.info('SDK disabled via config');
                 return;
             }
 
@@ -91,7 +91,7 @@ export const ReplaySdk = {
             // Desktop transport (always, if debugTransport provided)
             if (opts?.debugTransport) {
                 transports.push(new DesktopReplayTransport(opts.debugTransport));
-                logger.info('Desktop replay transport enabled');
+                __DEV__ && logger.info('Desktop replay transport enabled');
             }
 
             // Backend transport (flag-controlled + env check)
@@ -103,9 +103,9 @@ export const ReplaySdk = {
                         apiKey: config.apiKey,
                         batchSize: config.uploadBatchSize,
                     }));
-                    logger.info('Backend replay transport enabled');
+                    __DEV__ && logger.info('Backend replay transport enabled');
                 } else {
-                    logger.info('Backend replay transport skipped (dev/emulator mode)');
+                    __DEV__ && logger.info('Backend replay transport skipped (dev/emulator mode)');
                 }
             }
 
@@ -129,7 +129,7 @@ export const ReplaySdk = {
             try {
                 const success = await sessionOrchestrator.initialize(config);
                 if (success) {
-                    logger.info('SDK initialized with native module');
+                    __DEV__ && logger.info('SDK initialized with native module');
                 } else {
                     logger.warn('Native module not available — transport-only mode');
                 }
@@ -138,7 +138,7 @@ export const ReplaySdk = {
             }
 
             _initialized = true;
-            logger.info('SDK initialized successfully');
+            __DEV__ && logger.info('SDK initialized successfully');
         }, undefined);
     },
 
@@ -358,7 +358,7 @@ export const ReplaySdk = {
 
             _initialized = false;
             _config = null;
-            logger.info('SDK destroyed');
+            __DEV__ && logger.info('SDK destroyed');
         }, undefined);
     },
 };

package/src/features/replay/replay/session/sessionOrchestrator.ts

@@ -53,10 +53,10 @@ class SessionOrchestrator {
         try {
             const success = await bridgeAdapter.initialize(config);
             if (!success) {
-                logger.info('Native replay module not available — running in transport-only mode');
+                __DEV__ && logger.info('Native replay module not available — running in transport-only mode');
             }
         } catch (nativeErr: any) {
-            logger.info('Native replay module not available:', nativeErr?.message);
+            __DEV__ && logger.info('Native replay module not available:', nativeErr?.message);
         }
 
         // Listen to native events (no-ops if native not available)
@@ -66,7 +66,7 @@ class SessionOrchestrator {
         this._appStateSubscription = AppState.addEventListener('change', this._onAppStateChange);
 
         this._initialized = true;
-        logger.info('SessionOrchestrator initialized');
+        __DEV__ && logger.info('SessionOrchestrator initialized');
 
         // Auto-start if configured
         if (config.autoStart && config.enabled) {
@@ -93,7 +93,7 @@ class SessionOrchestrator {
         this._startDurationTimer();
         this._startFrequencyTimerIfNeeded();
 
-        logger.info(`Session started: ${this._sessionId}`);
+        __DEV__ && logger.info(`Session started: ${this._sessionId}`);
     }
 
     async stop(): Promise<void> {
@@ -107,7 +107,7 @@ class SessionOrchestrator {
         this._state = SessionState.Idle;
         clock.resetClock();
 
-        logger.info(`Session stopped: ${this._sessionId}`);
+        __DEV__ && logger.info(`Session stopped: ${this._sessionId}`);
         this._sessionId = null;
         this._startedAt = 0;
     }
@@ -117,7 +117,7 @@ class SessionOrchestrator {
         this._state = SessionState.Paused;
         this._stopTimers();
         await bridgeAdapter.pauseSession();
-        logger.debug('Session paused');
+        __DEV__ && logger.debug('Session paused');
     }
 
     async resume(): Promise<void> {
@@ -126,7 +126,7 @@ class SessionOrchestrator {
         this._startDurationTimer();
         this._startFrequencyTimerIfNeeded();
         await bridgeAdapter.resumeSession();
-        logger.debug('Session resumed');
+        __DEV__ && logger.debug('Session resumed');
     }
 
     // ─── Capture ────────────────────────────────────────────────────────
@@ -231,7 +231,7 @@ class SessionOrchestrator {
 
     private _setupNativeEventListeners(): void {
         replayEventEmitter.onSessionStateChanged((event: SessionStateChangedEvent) => {
-            logger.debug(`Native state: ${event.previousState} → ${event.newState}`);
+            __DEV__ && logger.debug(`Native state: ${event.previousState} → ${event.newState}`);
         });
 
         replayEventEmitter.onSessionLimitReached((event: SessionLimitReachedEvent) => {
@@ -278,7 +278,7 @@ class SessionOrchestrator {
         this._state = SessionState.Idle;
         this._sessionId = null;
         this._config = null;
-        logger.info('SessionOrchestrator destroyed');
+        __DEV__ && logger.info('SessionOrchestrator destroyed');
     }
 }
 

package/src/features/session/BackendSessionAdapter.ts

@@ -214,9 +214,9 @@ export class BackendSessionAdapter implements SessionTransport {
         this.objectStorageActive = this.config.useObjectStorage;
         this.nativeOutboxEnabled =
             this.config.enableNativeFileOutbox && this.config.nativeOutboxUploadEnabled;
-        logger.info(`[ScaleBun Replay] backendUpload enabled`);
-        logger.info(`[ScaleBun Replay] backendBaseUrl: ${this.config.endpoint}`);
-        logger.info(`[ScaleBun Replay] transport fan-out active: desktop yes, backend yes`);
+        __DEV__ && logger.info(`[ScaleBun Replay] backendUpload enabled`);
+        __DEV__ && logger.info(`[ScaleBun Replay] backendBaseUrl: ${this.config.endpoint}`);
+        __DEV__ && logger.info(`[ScaleBun Replay] transport fan-out active: desktop yes, backend yes`);
     }
 
     // ─── SessionTransport Interface ─────────────────────────────────────
@@ -234,10 +234,10 @@ export class BackendSessionAdapter implements SessionTransport {
         this.currentSessionId = session.sessionId;
         this._startFlushTimer();
 
-        logger.info(`[ScaleBun Replay] session start requested`);
-        logger.info(`[ScaleBun Replay] sessionId: ${session.sessionId}`);
-        logger.info(`[ScaleBun Replay] deviceId: ${session.deviceId}`);
-        logger.info(`[ScaleBun Replay] recordingSessionId: ${session.sessionId}`);
+        __DEV__ && logger.info(`[ScaleBun Replay] session start requested`);
+        __DEV__ && logger.info(`[ScaleBun Replay] sessionId: ${session.sessionId}`);
+        __DEV__ && logger.info(`[ScaleBun Replay] deviceId: ${session.deviceId}`);
+        __DEV__ && logger.info(`[ScaleBun Replay] recordingSessionId: ${session.sessionId}`);
 
         // One-row merge: when recording adopted the always-on analytics id
         // (SessionManager.startSession), the INGESTION_START row already exists.
@@ -245,11 +245,11 @@ export class BackendSessionAdapter implements SessionTransport {
         // journey/network/errors/perf flush to INGESTION_*(analyticsId). Legacy
         // mode (no clientKey, distinct minted id) still posts /replay/sessions.
         if (this.config.clientKey && session.sessionId === this._analyticsSessionId) {
-            logger.info(`[ScaleBun Replay] recording attached to analytics session ${session.sessionId} (no new row)`);
+            __DEV__ && logger.info(`[ScaleBun Replay] recording attached to analytics session ${session.sessionId} (no new row)`);
             return;
         }
 
-        logger.info(`[ScaleBun Replay] backend session upload started`);
+        __DEV__ && logger.info(`[ScaleBun Replay] backend session upload started`);
 
         const startEndpoint = this.config.clientKey ? ENDPOINTS.INGESTION_START : '/replay/sessions';
 
@@ -290,19 +290,19 @@ export class BackendSessionAdapter implements SessionTransport {
                         environment: m?.buildType,
                     },
                 };
-                logger.debug(`[BackendSessionAdapter] POST session start: ${session.sessionId}`);
+                __DEV__ && logger.debug(`[BackendSessionAdapter] POST session start: ${session.sessionId}`);
                 return this._post(startEndpoint, payload);
             })
             .then(() => {
                 // §11: row now exists — release the child-lane flush gate for this id.
                 this._startedSessionIds.add(session.sessionId);
-                logger.info(`[ScaleBun Replay] backend session upload success`);
+                __DEV__ && logger.info(`[ScaleBun Replay] backend session upload success`);
             })
             .catch(() => logger.info(`[ScaleBun Replay] backend session upload failure`));
     }
 
     sendSessionEnd(session: Session): void {
-        logger.info(`[ScaleBun Replay] finalize started`);
+        __DEV__ && logger.info(`[ScaleBun Replay] finalize started`);
         // Flush all pending data first, then finalize
         Promise.all([
             this._flushFrames(),
@@ -317,7 +317,7 @@ export class BackendSessionAdapter implements SessionTransport {
             // shared row mid-foreground and orphan later track() events — so flush
             // (above) but skip finalize. Legacy/distinct-id sessions finalize normally.
             if (this.config.clientKey && session.sessionId === this._analyticsSessionId) {
-                logger.info(`[ScaleBun Replay] recording ended; analytics session ${session.sessionId} stays open`);
+                __DEV__ && logger.info(`[ScaleBun Replay] recording ended; analytics session ${session.sessionId} stays open`);
                 return;
             }
             const finalizeEndpoint = this.config.clientKey
@@ -336,9 +336,9 @@ export class BackendSessionAdapter implements SessionTransport {
                 },
             );
         }).then(() => {
-            logger.info(`[ScaleBun Replay] finalize success`);
+            __DEV__ && logger.info(`[ScaleBun Replay] finalize success`);
         }).catch(() => { 
-            logger.info(`[ScaleBun Replay] finalize failure`);
+            __DEV__ && logger.info(`[ScaleBun Replay] finalize failure`);
         }).finally(() => {
             this._stopFlushTimer();
             // Keep the row-ready gate OPEN for a merged analytics session. The analytics
@@ -352,7 +352,7 @@ export class BackendSessionAdapter implements SessionTransport {
             }
             // Session end: drain any durably-stored telemetry from the native outbox.
             this._triggerNativeFlush();
-            logger.debug(`[BackendSessionAdapter] Session finalized: ${session.sessionId}`);
+            __DEV__ && logger.debug(`[BackendSessionAdapter] Session finalized: ${session.sessionId}`);
         });
     }
 
@@ -423,9 +423,9 @@ export class BackendSessionAdapter implements SessionTransport {
             // The pre-ack flush at the top of this method is gated off until now, so
             // this is what actually drains the pre-ready buffer (no premature 404).
             this._flushAnalyticsEvents().catch(() => { });
-            logger.info(`[ScaleBun Analytics] session start upload success: ${session.sessionId}`);
+            __DEV__ && logger.info(`[ScaleBun Analytics] session start upload success: ${session.sessionId}`);
         } catch {
-            logger.info(`[ScaleBun Analytics] session start upload failure`);
+            __DEV__ && logger.info(`[ScaleBun Analytics] session start upload failure`);
         }
     }
 
@@ -504,7 +504,7 @@ export class BackendSessionAdapter implements SessionTransport {
                 ? ENDPOINTS.INGESTION_EVENTS(sessionId)
                 : `/replay/sessions/${sessionId}/events`;
             await this._post(eventsEndpoint, { events });
-            logger.debug(`[BackendSessionAdapter] Flushed ${batch.length} analytics event(s)`);
+            __DEV__ && logger.debug(`[BackendSessionAdapter] Flushed ${batch.length} analytics event(s)`);
         } catch (err) {
             if (!BackendSessionAdapter._isPermanentHttpError(err)) this.pendingAnalyticsEvents.unshift(...batch);
         }
@@ -542,10 +542,10 @@ export class BackendSessionAdapter implements SessionTransport {
             // Confirmed delivered → drop the marker so the foreground reconciler does
             // NOT re-finalize this id (first half of the no-double-finalize guard).
             if (this._pendingFinalizeId === sessionId) this._pendingFinalizeId = null;
-            logger.debug(`[BackendSessionAdapter] Analytics session finalized: ${sessionId}`);
+            __DEV__ && logger.debug(`[BackendSessionAdapter] Analytics session finalized: ${sessionId}`);
         } catch {
             // Leave the marker set — foreground reconciliation will retry the close.
-            logger.info(`[ScaleBun Analytics] finalize failure (will reconcile on foreground): ${sessionId}`);
+            __DEV__ && logger.info(`[ScaleBun Analytics] finalize failure (will reconcile on foreground): ${sessionId}`);
         }
     }
 
@@ -567,9 +567,9 @@ export class BackendSessionAdapter implements SessionTransport {
                 ? ENDPOINTS.INGESTION_FINALIZE(sessionId)
                 : `/replay/sessions/${sessionId}/finalize`;
             await this._post(finalizeEndpoint, { endedAt: Date.now() });
-            logger.info(`[ScaleBun Analytics] reconciled finalize on foreground: ${sessionId}`);
+            __DEV__ && logger.info(`[ScaleBun Analytics] reconciled finalize on foreground: ${sessionId}`);
         } catch {
-            logger.info(`[ScaleBun Analytics] foreground reconcile finalize failed: ${sessionId}`);
+            __DEV__ && logger.info(`[ScaleBun Analytics] foreground reconcile finalize failed: ${sessionId}`);
         } finally {
             // Clear after a foreground attempt regardless of outcome: JS is live here
             // so a transient network error is rare, and the server-side idle-close
@@ -596,11 +596,11 @@ export class BackendSessionAdapter implements SessionTransport {
     sendEvent(event: JourneyEvent): void {
         if (this.destroyed) return;
 
-        logger.info(`[ScaleBun Replay] event recorded`);
-        logger.info(`  eventId: ${event.eventId}`);
-        logger.info(`  type: ${event.type}`);
-        logger.info(`  timestamp: ${event.ts}`);
-        logger.info(`  sessionId: ${event.sessionId}`);
+        __DEV__ && logger.info(`[ScaleBun Replay] event recorded`);
+        __DEV__ && logger.info(`  eventId: ${event.eventId}`);
+        __DEV__ && logger.info(`  type: ${event.type}`);
+        __DEV__ && logger.info(`  timestamp: ${event.ts}`);
+        __DEV__ && logger.info(`  sessionId: ${event.sessionId}`);
 
         this.pendingEvents.push(event);
 
@@ -612,11 +612,11 @@ export class BackendSessionAdapter implements SessionTransport {
     sendFrame(frame: ReplayFrame, imageData: string): void {
         if (this.destroyed) return;
 
-        logger.info(`[ScaleBun Replay] frame captured`);
-        logger.info(`  frameId: ${frame.frameId}`);
-        logger.info(`  timestamp: ${frame.ts}`);
-        logger.info(`  sessionId: ${frame.sessionId}`);
-        logger.info(`  width/height: ${frame.width}x${frame.height}`);
+        __DEV__ && logger.info(`[ScaleBun Replay] frame captured`);
+        __DEV__ && logger.info(`  frameId: ${frame.frameId}`);
+        __DEV__ && logger.info(`  timestamp: ${frame.ts}`);
+        __DEV__ && logger.info(`  sessionId: ${frame.sessionId}`);
+        __DEV__ && logger.info(`  width/height: ${frame.width}x${frame.height}`);
         
         this.pendingFrames.push({ frame, imageData });
 
@@ -953,7 +953,7 @@ export class BackendSessionAdapter implements SessionTransport {
             this.pendingFrames.unshift(...remaining);
             return;
         }
-        logger.debug(`[BackendSessionAdapter] Flushed ${batch.length} frame(s)`);
+        __DEV__ && logger.debug(`[BackendSessionAdapter] Flushed ${batch.length} frame(s)`);
         // Delivered — the durable snapshot (if any) is now redundant. Clear it once
         // the in-memory buffer is fully drained so a later kill can't replay
         // already-uploaded frames.
@@ -1054,13 +1054,13 @@ export class BackendSessionAdapter implements SessionTransport {
         batch: Array<{ frame: ReplayFrame; imageData: string }>,
     ): Promise<void> {
         if (batch.length === 0) return;
-        logger.info(`[replay.sdk.frame] backend frame upload started`, { count: batch.length });
+        __DEV__ && logger.info(`[replay.sdk.frame] backend frame upload started`, { count: batch.length });
 
         // Object-storage path: presign → PUT bytes → post key-only metadata.
         if (this.objectStorageActive && this.config.clientKey) {
             const result = await this._uploadFramesViaStorage(sessionId, batch);
             if (result === 'sent') {
-                logger.info(`[replay.sdk.frame] backend frame upload success (object storage)`);
+                __DEV__ && logger.info(`[replay.sdk.frame] backend frame upload success (object storage)`);
                 return;
             }
             // 'disabled' → storage not configured server-side; fall through to inline.
@@ -1072,7 +1072,7 @@ export class BackendSessionAdapter implements SessionTransport {
             ? ENDPOINTS.INGESTION_FRAMES(sessionId)
             : `/replay/sessions/${sessionId}/frames`;
         await this._post(framesEndpoint, { frames });
-        logger.info(`[replay.sdk.frame] backend frame upload success`);
+        __DEV__ && logger.info(`[replay.sdk.frame] backend frame upload success`);
     }
 
     // ─── Cross-kill frame recovery ──────────────────────────────────────
@@ -1212,7 +1212,7 @@ export class BackendSessionAdapter implements SessionTransport {
             return;
         }
 
-        logger.info(`[replay.sdk.frame] recovering ${items.length} frame(s) for prior session ${sessionId}`);
+        __DEV__ && logger.info(`[replay.sdk.frame] recovering ${items.length} frame(s) for prior session ${sessionId}`);
         /**
          * DELETE ONLY WHAT WAS ACCEPTED.
          *
@@ -1291,7 +1291,7 @@ export class BackendSessionAdapter implements SessionTransport {
         const events = batch.map(e => this._leanEvent(e, e.sessionId));
 
         try {
-            logger.info(`[replay.sdk.event] backend event upload started`, { count: batch.length });
+            __DEV__ && logger.info(`[replay.sdk.event] backend event upload started`, { count: batch.length });
             // Durable native outbox owns delivery when active (no duplicate JS POST).
             // The native enqueue is NOT gated on row-readiness: it writes to disk and its
             // uploader handles ordering/retry, so it must accept data even while offline.
@@ -1305,8 +1305,8 @@ export class BackendSessionAdapter implements SessionTransport {
                 eventsEndpoint,
                 { events },
             );
-            logger.info(`[replay.sdk.event] backend event upload success`);
-            logger.debug(`[BackendSessionAdapter] Flushed ${batch.length} event(s)`);
+            __DEV__ && logger.info(`[replay.sdk.event] backend event upload success`);
+            __DEV__ && logger.debug(`[BackendSessionAdapter] Flushed ${batch.length} event(s)`);
         } catch (err) {
             if (BackendSessionAdapter._isPermanentHttpError(err)) return;
             logger.warn(`[replay.sdk.error] backend event upload failure`, { count: batch.length });

package/src/features/session/DesktopSessionTransport.ts

@@ -11,7 +11,9 @@
  */
 
 import type { DebugTransport } from '../../debug/transport';
-import { PROTOCOL_VERSION } from '../../debug/protocol';
+// The SDK-owned constant, not the debug/protocol shim — the shim re-exports from the vendored
+// schema module, which would pull every desktop wire-message schema into production bundles.
+import { PROTOCOL_VERSION } from '../../core/constants/protocol';
 import { logger } from '../../core/logger/internalLogger';
 import type {
     SessionTransport,
@@ -96,7 +98,7 @@ export class DesktopSessionTransport implements SessionTransport {
     private _send(name: string, data: Record<string, unknown>): void {
         try {
             if (this.transport.getState() !== 'connected') {
-                logger.debug(`[DesktopSessionTransport] Not connected, buffering: ${name}`);
+                __DEV__ && logger.debug(`[DesktopSessionTransport] Not connected, buffering: ${name}`);
             }
 
             const msg = {

package/src/features/session/JourneyEventPipeline.ts

@@ -206,7 +206,7 @@ export class JourneyEventPipeline {
             if (evKey === key && (now - ev.ts) < this.config.dedupeWindowMs) {
                 ev.payload = opts?.payload;
                 this.lastEventConfidence = (opts?.payload as any)?.confidence ?? null;
-                logger.debug('[JourneyEventPipeline] replaced low-confidence event with native-high');
+                __DEV__ && logger.debug('[JourneyEventPipeline] replaced low-confidence event with native-high');
                 // Re-emit so transport receives the corrected coordinates.
                 // Backend uses upsert on eventId, so this overwrites the stale record.
                 try { this.onEmit?.(ev); } catch { /* transport must not crash pipeline */ }

package/src/features/session/ReplayCaptureManager.ts

@@ -350,10 +350,10 @@ export class ReplayCaptureManager {
             this.frequencyTimer = setInterval(() => {
                 this.triggerCapture('frequency').catch(() => { });
             }, intervalMs);
-            logger.debug(`[ReplayCaptureManager] Frequency mode: every ${intervalMs}ms`);
+            __DEV__ && logger.debug(`[ReplayCaptureManager] Frequency mode: every ${intervalMs}ms`);
         }
 
-        logger.debug(`[ReplayCaptureManager] Started (mode=${this.config.captureMode})`);
+        __DEV__ && logger.debug(`[ReplayCaptureManager] Started (mode=${this.config.captureMode})`);
     }
 
     /** Stop capture — cancels ALL pending timers and increments generation */
@@ -408,7 +408,7 @@ export class ReplayCaptureManager {
         // Clear dedup state
         this.lastCaptureIntent = null;
 
-        logger.debug('[ReplayCaptureManager] Stopped (all timers cancelled, generation incremented)');
+        __DEV__ && logger.debug('[ReplayCaptureManager] Stopped (all timers cancelled, generation incremented)');
     }
 
     /** Notify of a screen change — triggers cancellable delayed capture */
@@ -450,7 +450,7 @@ export class ReplayCaptureManager {
                 this.pendingInteractionTimeout = null;
                 this.pendingInteractionPoint = undefined;
                 this.pendingInteractionScreen = undefined;
-                logger.debug(
+                __DEV__ && logger.debug(
                     `[ReplayCaptureManager] Pending interaction absorbed by navigation to ${screenName}`,
                 );
             }
@@ -470,7 +470,7 @@ export class ReplayCaptureManager {
                 absorbedInteractionPoint = stale.interactionPoint;
                 // Evict the stale frame from the frames list
                 this.frames = this.frames.filter(f => f.frameId !== stale.frameId);
-                logger.debug(
+                __DEV__ && logger.debug(
                     `[ReplayCaptureManager] Late absorption: evicted stale interaction frame ` +
                     `${stale.frameId} on ${stale.screen}, navigation to ${screenName}`,
                 );
@@ -490,7 +490,7 @@ export class ReplayCaptureManager {
                 if (this._inFlightInteractionPoint) {
                     absorbedInteractionPoint = this._inFlightInteractionPoint;
                 }
-                logger.debug(
+                __DEV__ && logger.debug(
                     `[ReplayCaptureManager] In-flight interaction suppressed by navigation to ${screenName}`,
                 );
             }
@@ -531,7 +531,7 @@ export class ReplayCaptureManager {
         // Semantic dedup: if a navigation capture is pending for the SAME screen,
         // the navigation frame will represent the post-interaction state.
         if (this.pendingNavTimeout && this.pendingNavScreen === screen) {
-            logger.debug('[ReplayCaptureManager] Interaction suppressed — navigation pending for same screen');
+            __DEV__ && logger.debug('[ReplayCaptureManager] Interaction suppressed — navigation pending for same screen');
             return;
         }
 
@@ -591,7 +591,7 @@ export class ReplayCaptureManager {
             clearTimeout(this.pendingNavTimeout);
             this.pendingNavTimeout = null;
             this.pendingNavScreen = null;
-            logger.debug('[ReplayCaptureManager] Navigation capture cancelled — loading-end supersedes for same screen');
+            __DEV__ && logger.debug('[ReplayCaptureManager] Navigation capture cancelled — loading-end supersedes for same screen');
         }
 
         // Track which screen this loading capture is for
@@ -674,7 +674,7 @@ export class ReplayCaptureManager {
 
             // Same reason + same screen within cooldown → semantic duplicate
             if (sameReason && sameScreen && withinCooldown) {
-                logger.debug(
+                __DEV__ && logger.debug(
                     `[ReplayCaptureManager] Semantic dedup: ${reason}@${screenName} suppressed ` +
                     `(same intent within ${SAME_INTENT_COOLDOWN_MS}ms)`,
                 );
@@ -739,7 +739,7 @@ export class ReplayCaptureManager {
                 if (this._suppressInFlightInteraction) {
                     this._suppressInFlightInteraction = false;
                     discardStaged();
-                    logger.debug('[ReplayCaptureManager] In-flight interaction suppressed — navigation arrived during capture');
+                    __DEV__ && logger.debug('[ReplayCaptureManager] In-flight interaction suppressed — navigation arrived during capture');
                     return null;
                 }
             }
@@ -748,7 +748,7 @@ export class ReplayCaptureManager {
             // discard the result to prevent stale frames
             if (gen !== this.captureGeneration) {
                 discardStaged();
-                logger.debug('[ReplayCaptureManager] Stale capture discarded (generation mismatch)');
+                __DEV__ && logger.debug('[ReplayCaptureManager] Stale capture discarded (generation mismatch)');
                 return null;
             }
 
@@ -760,7 +760,7 @@ export class ReplayCaptureManager {
             if (!result) {
                 // Native capture unavailable — log warning, return null
                 // NO JS fallback — this is by design
-                logger.debug('[ReplayCaptureManager] Native capture returned null — frame not captured');
+                __DEV__ && logger.debug('[ReplayCaptureManager] Native capture returned null — frame not captured');
                 return null;
             }
 
@@ -784,7 +784,7 @@ export class ReplayCaptureManager {
             const changeDetection = this.config.changeDetection !== false;
             if (changeDetection && reason === 'frequency' && !changed && !heartbeatDue) {
                 discardStaged();
-                logger.debug('[ReplayCaptureManager] Change-trigger suppressed identical frequency frame');
+                __DEV__ && logger.debug('[ReplayCaptureManager] Change-trigger suppressed identical frequency frame');
                 return null;
             }
 
@@ -891,7 +891,7 @@ export class ReplayCaptureManager {
                 try {
                     const committed = await this.outboxCapture?.commit(meta);
                     if (!committed) {
-                        logger.debug('[ReplayCaptureManager] Outbox commit failed — frame staged but not uploadable');
+                        __DEV__ && logger.debug('[ReplayCaptureManager] Outbox commit failed — frame staged but not uploadable');
                     }
                 } catch {
                     // Commit failure must not crash capture; orphan is swept later.