@scalebun/react-native 1.1.0 → 1.2.0

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.

package/src/features/session/SessionManager.ts

@@ -205,7 +205,7 @@ export class SessionManager {
      */
     setBackendTransport(transport: BackendSessionAdapter): void {
         this._backendTransport = transport;
-        logger.info('[SessionManager] Backend transport attached (replay → backend upload enabled)');
+        __DEV__ && logger.info('[SessionManager] Backend transport attached (replay → backend upload enabled)');
     }
 
     /** Expose the backend transport so features can queue network/errors/performance. */
@@ -235,7 +235,7 @@ export class SessionManager {
      */
     setDesktopTransport(debugTransport: DebugTransport): void {
         this.desktopTransport = new DesktopSessionTransport(debugTransport);
-        logger.info('[SessionManager] Desktop transport attached');
+        __DEV__ && logger.info('[SessionManager] Desktop transport attached');
     }
 
     // ─── Session Lifecycle ──────────────────────────────────────────────
@@ -278,7 +278,7 @@ export class SessionManager {
         // Hot-swap into active capture manager if session is running
         if (this.active && this.captureManager) {
             (this.captureManager as any).nativeCapture = captureFn;
-            logger.info('[SessionManager] Capture function updated (hot-swap)');
+            __DEV__ && logger.info('[SessionManager] Capture function updated (hot-swap)');
         }
     }
 
@@ -288,7 +288,7 @@ export class SessionManager {
     startSession(metadata?: Partial<SessionMetadata>): void {
         try {
             if (this.active) {
-                logger.debug('[SessionManager] Session already active, skipping start');
+                __DEV__ && logger.debug('[SessionManager] Session already active, skipping start');
                 return;
             }
 
@@ -461,12 +461,12 @@ export class SessionManager {
             // Set timeout
             if (this.config.maxDurationMs > 0) {
                 this.timeoutTimer = setTimeout(() => {
-                    logger.debug('[SessionManager] Session timeout reached');
+                    __DEV__ && logger.debug('[SessionManager] Session timeout reached');
                     this.endSession('timeout');
                 }, this.config.maxDurationMs);
             }
 
-            logger.info(`[SessionManager] Session started: ${sessionId}`);
+            __DEV__ && logger.info(`[SessionManager] Session started: ${sessionId}`);
 
             // ── Replay initial screen ──────────────────────────────────────
             // If the user was already on a screen before pressing Record
@@ -566,7 +566,7 @@ export class SessionManager {
             this.captureManager.clear();
             // (this.active already set to false above)
 
-            logger.info(
+            __DEV__ && logger.info(
                 `[SessionManager] Session ended: ${this.session.sessionId} ` +
                 `(${reason}, sync=${decision.shouldSync}, priority=${decision.priority})`,
             );
@@ -805,7 +805,7 @@ export class SessionManager {
 
                 const alreadyNormalized = this._normalizeInteractionPayload(p);
 
-                logger.debug(
+                __DEV__ && logger.debug(
                     `[TapAccuracy] sink platform=${p.platform ?? '?'} space=${p.coordinateSpace ?? '?'} ` +
                     `source=${alreadyNormalized ? (p.confidence === 'high' ? 'native-high' : 'js-precomputed') : 'js-estimated'} ` +
                     `norm=(${p.normalizedX},${p.normalizedY}) base=(${p.viewportWidth}x${p.viewportHeight})`,
@@ -963,7 +963,7 @@ export class SessionManager {
 
             this.crashAnchors.push(anchor);
 
-            logger.debug(
+            __DEV__ && logger.debug(
                 `[SessionManager] Crash anchored: ${crashEventId}, ` +
                 `protected ${anchor.nearbyEventIds.length} events, ` +
                 `${anchor.nearbyFrameIds.length} frames`,

package/src/features/session/SyncDecisionEngine.ts

@@ -71,7 +71,7 @@ export class SyncDecisionEngine {
 
             const decision = this._policy(enrichedCandidate);
 
-            logger.debug(
+            __DEV__ && logger.debug(
                 `[SyncDecisionEngine] Session ${candidate.sessionId}: ` +
                 `shouldSync=${decision.shouldSync}, priority=${decision.priority}, ` +
                 `reason="${decision.reason}"`,

package/src/features/skan/skanBridge.ts

@@ -35,27 +35,19 @@ export async function updateSkanConversionValue(
     try {
         const mod = getSkanModule();
         if (!mod?.updateConversionValue) {
-            logger.debug('[SKAN] Native module unavailable — conversion value not sent');
+            __DEV__ && logger.debug('[SKAN] Native module unavailable — conversion value not sent');
             return false;
         }
         const fine = Math.max(0, Math.min(63, Math.round(value)));
         await mod.updateConversionValue(fine, coarseValue ?? null, !!lockWindow);
-        logger.debug(`[SKAN] updateConversionValue(${fine}, ${coarseValue ?? '-'}, lock=${lockWindow})`);
+        __DEV__ && logger.debug(`[SKAN] updateConversionValue(${fine}, ${coarseValue ?? '-'}, lock=${lockWindow})`);
         return true;
     } catch (err) {
-        logger.debug(`[SKAN] updateConversionValue failed: ${(err as Error)?.message}`);
+        __DEV__ && logger.debug(`[SKAN] updateConversionValue failed: ${(err as Error)?.message}`);
         return false;
     }
 }
 
-/** Register the app's SKAdNetwork attribution at first launch (iOS 11.3+). No-op elsewhere. */
-export async function registerSkanAttribution(): Promise<void> {
-    try {
-        const mod = getSkanModule();
-        if (!mod?.registerAppForAttribution) return;
-        await mod.registerAppForAttribution();
-        logger.debug('[SKAN] registered app for attribution');
-    } catch {
-        // No-throw.
-    }
-}
+// (registerSkanAttribution was removed: nothing in the SDK or any consumer ever called it, so SKAN
+// attribution registration never actually happened. If the feature is wanted, wire it from the
+// facade's init path rather than restoring an orphaned export — see git history for the body.)

package/src/features/skan/skanConversionManager.ts

@@ -106,7 +106,7 @@ export class SkanConversionManager {
                 headers: { 'x-scalebun-client-key': this.clientKey },
             });
             if (!res.ok) {
-                logger.debug(`[SKAN] schema fetch HTTP ${res.status}`);
+                __DEV__ && logger.debug(`[SKAN] schema fetch HTTP ${res.status}`);
                 return;
             }
             const json: any = await res.json();
@@ -118,12 +118,12 @@ export class SkanConversionManager {
                 } catch {
                     /* no-throw */
                 }
-                logger.debug(
+                __DEV__ && logger.debug(
                     `[SKAN] schema loaded (enabled=${this.enabled}, ${this.schema.length} rules)`,
                 );
             }
         } catch (err) {
-            logger.debug(`[SKAN] schema fetch failed: ${(err as Error)?.message}`);
+            __DEV__ && logger.debug(`[SKAN] schema fetch failed: ${(err as Error)?.message}`);
         }
     }
 
@@ -142,12 +142,12 @@ export class SkanConversionManager {
             this.persist();
 
             void this.applyCv(rule.value, rule.coarse, rule.lockWindow ?? false);
-            logger.debug(
+            __DEV__ && logger.debug(
                 `[SKAN] event '${eventName}' → CV ${rule.value}` +
                     `${rule.coarse ? `/${rule.coarse}` : ''}${rule.lockWindow ? ' (locked)' : ''}`,
             );
         } catch (err) {
-            logger.debug(`[SKAN] onEvent('${eventName}') failed: ${(err as Error)?.message}`);
+            __DEV__ && logger.debug(`[SKAN] onEvent('${eventName}') failed: ${(err as Error)?.message}`);
         }
     }
 

package/src/integrations/fetch/fetchInterceptor.ts

@@ -177,6 +177,6 @@ export function installFetchInterceptor(
             }
         };
 
-        logger.debug('Fetch Interceptor installed');
+        __DEV__ && logger.debug('Fetch Interceptor installed');
     });
 }

package/src/integrations/xhr/xhrInterceptor.ts

@@ -226,6 +226,6 @@ export function installXHRInterceptor(
             return originalSend.apply(this, arguments as any);
         };
 
-        logger.debug('XHR Interceptor installed');
+        __DEV__ && logger.debug('XHR Interceptor installed');
     });
 }