@scalebun/react-native 2.0.0 → 2.0.2

package/lib/module/features/journey/uiState.js

@@ -49,7 +49,10 @@ const clean = s => typeof s === 'string' ? s.replace(/[;:|]/g, '').trim().slice(
 export function setUiState(name, value) {
   const n = clean(name);
   const v = clean(value);
-  if (n && v) declared.set(n, v);
+  if (!n || !v) return;
+  if (declared.get(n) === v) return;
+  declared.set(n, v);
+  notifyChanged();
 }
 
 /**
@@ -61,7 +64,9 @@ export function setUiState(name, value) {
  * screen.
  */
 export function clearUiState(name) {
+  const before = declared.size;
   if (name === undefined) declared.clear();else declared.delete(clean(name));
+  if (declared.size !== before) notifyChanged();
 }
 
 /**
@@ -83,4 +88,76 @@ export function uiStateSignature() {
   }
   return signature || undefined;
 }
+
+/**
+ * RN-11 — TELL SOMEONE THE STATE CHANGED, so a frame can exist for it.
+ *
+ * THE GAP. Declaring a state used to mutate a Map and nothing else. Nothing captured a frame, so
+ * the visual for a declared state existed only if a screenshot happened to be taken for some other
+ * reason — a navigation, a timer, or the interaction capture that fires AFTER the touch and
+ * photographs the outcome. A state could therefore be recorded as a fact with no picture of it
+ * anywhere, or with a picture of the state that replaced it.
+ *
+ * The native capture reasons are NAVIGATION, MANUAL, INTERACTION and TIMER. None of them is "the
+ * UI changed shape", which is exactly the moment a heatmap needs a frame.
+ *
+ * FIRING ON A REAL CHANGE ONLY, AND WHY THAT IS THE SDK'S JOB. The advice above says to call
+ * `setUiState` when the state changes rather than on every render — but that is advice to the
+ * host, not a guarantee. A component that declares its state inside render is ordinary React, and
+ * trusting the caller would mean a screenshot per render: a performance disaster in exactly the
+ * apps that instrument most carefully. So a redundant set — same dimension, same value — is now a
+ * no-op, and the change test lives here where it cannot be got wrong by a host.
+ *
+ * COALESCED, because a transition usually declares several dimensions in one tick ("drawer:open"
+ * and "overlay:visible" belong to one visual change). Notifying per call would capture the
+ * intermediate shapes, which are states the user never saw.
+ *
+ * The listener is deliberately NOT given the signature. A subscriber that wants it calls
+ * `uiStateSignature()` at the moment it acts, which is the value that will actually be attached
+ * to the next tap; handing over a snapshot invites acting on a state that has already moved on.
+ */
+
+const listeners = new Set();
+let pending = null;
+
+/**
+ * Subscribe to declared-state changes. Returns an unsubscribe.
+ *
+ * Registration is idempotent per function reference, so a component that re-subscribes on every
+ * render does not accumulate listeners — a leak that would only show up in long sessions.
+ */
+export function onUiStateChange(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** Drop every listener and any pending notification. For teardown between sessions. */
+export function resetUiStateListeners() {
+  listeners.clear();
+  if (pending !== null) {
+    clearTimeout(pending);
+    pending = null;
+  }
+}
+
+/** For assertions that a re-subscribing caller has not leaked. */
+export function uiStateListenerCount() {
+  return listeners.size;
+}
+function notifyChanged() {
+  if (pending !== null) return;
+  pending = setTimeout(() => {
+    pending = null;
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch {
+        /* One bad subscriber must not stop the others, and must never surface to the host: a
+           screenshot is not worth an app crash. */
+      }
+    }
+  }, 0);
+}
 //# sourceMappingURL=uiState.js.map

package/lib/module/features/navigation/AutoScreenDetector.js

@@ -36,6 +36,15 @@ export class AutoScreenDetector {
   _manualScreen = null;
   _manualScreenTs = 0;
   _autoScreen = null;
+  /**
+   * When `_autoScreen` was last written.
+   *
+   * Needed so `getCurrentScreen()` can prefer whichever source spoke MOST RECENTLY.
+   * Without a timestamp the only comparison available was "is the manual value still
+   * fresh", which is a different question and gave the wrong answer — see the note on
+   * `_currentScreen()`.
+   */
+  _autoScreenTs = 0;
   /** `name#key` of the last auto-detected screen VISIT — see _extractActiveVisit. */
   _autoVisitSig = null;
   _navigationRef = null;
@@ -110,6 +119,7 @@ export class AutoScreenDetector {
       if (this.isManualScreenActive()) return;
       if (name !== this._autoScreen) {
         this._autoScreen = name;
+        this._autoScreenTs = Date.now();
         this._autoVisitSig = name; // native lifecycle carries no route key — name-only visit
         this._emitScreenChange(name, 'heuristic');
       }
@@ -117,8 +127,19 @@ export class AutoScreenDetector {
   }
 
   /**
-   * Check if a manual screen is currently active.
-   * Used by auto-detection to yield to manual overrides.
+   * Should a WRITER defer to the manual screen right now?
+   *
+   * THIS IS A PRECEDENCE GATE, NOT A VALIDITY TEST, and conflating the two was a real
+   * bug. Its job is what the cooldown constant says: for a short window after a manual
+   * beacon fires, an auto source must not overwrite it — the poller runs every 1500 ms
+   * and would otherwise clobber a fresh declaration with whatever it inferred.
+   *
+   * `getCurrentScreen()` used to reuse this as "is the manual screen still the current
+   * screen", which made a declared screen READABLE for only 2000 ms. Nothing called
+   * `setManualScreen` in production, so the effect was latent — but the moment the
+   * `<ScaleBunScreen>` beacon was wired to it (RN-8), every tap more than two seconds
+   * after a screen mounted would have lost its name, which is very nearly every tap. A
+   * fix that introduced that would have been worse than the gap it closed.
    */
   isManualScreenActive() {
     if (!this._manualScreen) return false;
@@ -178,6 +199,7 @@ export class AutoScreenDetector {
                   const visit = this._extractActiveVisit(state);
                   if (visit && this._visitSig(visit) !== this._autoVisitSig) {
                     this._autoScreen = visit.name;
+                    this._autoScreenTs = Date.now();
                     this._autoVisitSig = this._visitSig(visit);
                     this._emitScreenChange(visit.name, 'navRef');
                   }
@@ -196,6 +218,7 @@ export class AutoScreenDetector {
           const visit = this._extractActiveVisit(state);
           if (visit) {
             this._autoScreen = visit.name;
+            this._autoScreenTs = Date.now();
             this._autoVisitSig = this._visitSig(visit);
             this._emitScreenChange(visit.name, 'navRef');
           }
@@ -239,6 +262,7 @@ export class AutoScreenDetector {
             const visit = this._extractActiveVisit(state);
             if (visit && this._visitSig(visit) !== this._autoVisitSig) {
               this._autoScreen = visit.name;
+              this._autoScreenTs = Date.now();
               this._autoVisitSig = this._visitSig(visit);
               this._emitScreenChange(visit.name, 'heuristic');
             }
@@ -495,16 +519,61 @@ export class AutoScreenDetector {
     this._listeners = [];
     this._manualScreen = null;
     this._autoScreen = null;
+    this._autoScreenTs = 0;
     this._navigationRef = null;
     _instance = null;
   }
 
   /** Get the current best-known screen name */
   getCurrentScreen() {
-    if (this._manualScreen && this.isManualScreenActive()) {
-      return this._manualScreen;
+    return this._currentScreen().name;
+  }
+
+  /**
+   * WHERE the current screen name came from, or 'none'.
+   *
+   * Recorded on every interaction (RN-8) so low screen coverage is DIAGNOSABLE rather
+   * than merely visible. Production shows 13.8% of Android interactions carrying a
+   * screen and 0.5% on iOS, and those numbers cannot today distinguish three different
+   * causes: the app never instrumented anything, the app instrumented manually and the
+   * value never reached interactions, or auto-detection ran and failed. Those have
+   * different owners and different fixes, and guessing between them is how a P0 stays
+   * open.
+   */
+  getCurrentScreenSource() {
+    return this._currentScreen().source;
+  }
+
+  /**
+   * LAST WRITER WINS between the manual beacon and auto-detection.
+   *
+   * A screen declared by `<ScaleBunScreen name>` stays current until something else
+   * declares a different one — that is what mounting a screen means. It does not
+   * expire, which is the correction here: the previous rule returned the manual name
+   * only while it was under 2000 ms old and then silently fell back to the auto value,
+   * which in a manually-instrumented app is `null`.
+   *
+   * Comparing timestamps rather than hard-coding a priority also handles the real
+   * interleaving: an app can use React Navigation for most screens AND drop a manual
+   * beacon on one modal, and whichever spoke last is the truth.
+   */
+  _currentScreen() {
+    const manual = this._manualScreen;
+    const auto = this._autoScreen;
+    if (manual && (!auto || this._manualScreenTs >= this._autoScreenTs)) {
+      return {
+        name: manual,
+        source: 'manual'
+      };
     }
-    return this._autoScreen;
+    if (auto) return {
+      name: auto,
+      source: 'navigation'
+    };
+    return {
+      name: null,
+      source: 'none'
+    };
   }
 
   // ─── Internal ───────────────────────────────────────────────────────

package/lib/module/features/ota/OtaOrchestrator.js

@@ -113,12 +113,12 @@ async function deliverOtaEvents(params) {
       })
     });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    __DEV__ && logger.debug(`[OTA] Delivered ${items.length} telemetry event(s)`);
+    logger.debug(`[OTA] Delivered ${items.length} telemetry event(s)`);
   } catch (err) {
     // Failed delivery must not fail the update — but the events must not be
     // lost either: requeue so the next sync retries them.
     for (const e of events) otaEventEmitter.emit(e);
-    __DEV__ && logger.debug(`[OTA] Telemetry delivery failed (will retry next sync): ${err?.message}`);
+    logger.debug(`[OTA] Telemetry delivery failed (will retry next sync): ${err?.message}`);
   }
 }
 
@@ -138,6 +138,8 @@ export class OtaOrchestrator {
     return this.currentBundle;
   }
   isRestartRequiredState = false;
+  /** Root/jailbreak indicators observed at init; empty when none found. */
+  integrityIndicators = [];
   healthyTimer = null;
   bootGuardConfig = {};
   environment = null;
@@ -193,12 +195,30 @@ export class OtaOrchestrator {
         // We cannot see which form the host used — the identity check after
         // restart is what proves it — but naming the right fix up front turns
         // a confusing silent failure into a one-line correction.
-        __DEV__ && logger.debug('[OTA] React Native >= 0.82 detected. The only valid Android integration is ' + 'getDefaultReactHost(..., jsBundleFilePath = ScaleBunOtaModule.getJSBundleFile(ctx)) — ' + 'ReactNativeHost and its getJSBundleFile() override no longer exist.');
+        logger.debug('[OTA] React Native >= 0.82 detected. The only valid Android integration is ' + 'getDefaultReactHost(..., jsBundleFilePath = ScaleBunOtaModule.getJSBundleFile(ctx)) — ' + 'ReactNativeHost and its getJSBundleFile() override no longer exist.');
       }
       this.initialized = true;
       this.enabled = true;
+
+      // Device integrity signal.
+      //
+      // Reported, not enforced. Root defeats any check made from inside the app,
+      // so this is not a boundary — it is context. It tells an operator that a
+      // device's OTA slot is writable by other processes, which is what makes the
+      // launch-time hash re-check in SlotManager meaningful rather than paranoid.
+      // A host app that wants to withhold updates on such devices can read
+      // `deviceIntegrityIndicators()` and decide for itself.
+      try {
+        const raw = NativeScaleBunOta?.getDeviceIntegrity?.();
+        this.integrityIndicators = raw ? JSON.parse(raw) : [];
+        if (this.integrityIndicators.length > 0) {
+          logger.warn(`[OTA] Device integrity indicators present: ${this.integrityIndicators.join(', ')}. ` + 'Updates still install and are still signature-verified, but an installed ' + 'bundle on this device can be modified by other privileged processes.');
+        }
+      } catch {
+        this.integrityIndicators = [];
+      }
       this.bootGuardConfig = config ?? {};
-      __DEV__ && logger.debug(`[OTA] Orchestrator initialized (RN ${this.environment.rnVersionString ?? 'unknown'}` + `${this.environment.bridgeless ? ', bridgeless' : ''}` + `${this.environment.hermes ? `, Hermes HBC v${this.environment.hermesBytecodeVersion ?? '?'}` : ''})`);
+      logger.debug(`[OTA] Orchestrator initialized (RN ${this.environment.rnVersionString ?? 'unknown'}` + `${this.environment.bridgeless ? ', bridgeless' : ''}` + `${this.environment.hermes ? `, Hermes HBC v${this.environment.hermesBytecodeVersion ?? '?'}` : ''})`);
 
       // ONE read of the slot state, shared by both boot-time consumers.
       //
@@ -229,6 +249,22 @@ export class OtaOrchestrator {
 
       // Prove the bundle we installed is the bundle that loaded.
       this.verifyRunningBundleIdentity();
+
+      // Boot-guard health is a LOCAL fact: this process booted from the staged
+      // bundle and did not crash. The heartbeat used to start only on the
+      // `action === 'NONE'` branch of sync(), so confirming a good bundle needed
+      // a successful network round-trip that returned exactly that answer — a
+      // device offline, rate-limited, or still being offered an update could
+      // never clear its marker, and the guard reverted a bundle that was working.
+      //
+      // It runs HERE, last, and is handed the slot state that was already read.
+      // Starting it earlier made it call getSlotState() itself, and that read is
+      // consume-on-read for the revert record — it swallowed the revert before
+      // checkBootGuardRecovery() could name the bundle that failed, so a
+      // crash-rollback went unreported. It also read bootGuardConfig before
+      // init() had assigned it, so healthyAfterMs silently fell back to the
+      // default.
+      this.startBootGuardHeartbeat(slotState);
     });
   }
 
@@ -267,7 +303,7 @@ export class OtaOrchestrator {
           releaseId: record.releaseId ?? undefined,
           sha256: record.sha256
         };
-        __DEV__ && logger.debug(`[OTA] Running bundle v${record.version} (${record.bundleId})`);
+        logger.debug(`[OTA] Running bundle v${record.version} (${record.bundleId})`);
         return;
       }
 
@@ -277,7 +313,7 @@ export class OtaOrchestrator {
       this.currentBundle = {
         sha256: current.sha256
       };
-      __DEV__ && logger.debug(`[OTA] Running an OTA bundle (sha ${String(current.sha256).slice(0, 12)}…) with no local install record.`);
+      logger.debug(`[OTA] Running an OTA bundle (sha ${String(current.sha256).slice(0, 12)}…) with no local install record.`);
     } catch {
       // Slot state unreadable — treat as factory bundle.
     }
@@ -325,7 +361,7 @@ export class OtaOrchestrator {
     // this bundle" and answers by serving the same bundle again, forever.
     if (!record.identityToken) return;
     if (running === record.identityToken) {
-      __DEV__ && logger.debug('[OTA] Install verified — running bundle matches what was installed.');
+      logger.debug('[OTA] Install verified — running bundle matches what was installed.');
       this.retireIdentityToken(record);
       return;
     }
@@ -458,6 +494,14 @@ export class OtaOrchestrator {
   isEnabled() {
     return this.enabled;
   }
+
+  /**
+   * Root/jailbreak indicators detected on this device, as stable reason strings.
+   * Empty means nothing was detected — not proof the device is clean.
+   */
+  deviceIntegrityIndicators() {
+    return [...this.integrityIndicators];
+  }
   isRestartRequired() {
     return this.isRestartRequiredState;
   }
@@ -565,7 +609,7 @@ export class OtaOrchestrator {
           error: 'OTA native module disabled or missing'
         };
       }
-      __DEV__ && logger.debug('[OTA] Sync started…');
+      logger.debug('[OTA] Sync started…');
 
       // The funnel's denominator, for devices already on an OTA bundle. Emitted
       // before the request, so a check that fails outright still counts as a
@@ -584,7 +628,7 @@ export class OtaOrchestrator {
       }
       const checkRes = await this.checkForUpdate(params);
       if (checkRes.action === 'NONE') {
-        __DEV__ && logger.debug('[OTA] App is up to date');
+        logger.debug('[OTA] App is up to date');
         // If we booted from an OTA bundle and it's healthy, clear the boot guard
         this.startBootGuardHeartbeat();
         return {
@@ -642,7 +686,7 @@ export class OtaOrchestrator {
         version: bundle.version
       });
       const downloadStart = Date.now();
-      __DEV__ && logger.debug(`[OTA] Downloading update v${bundle.version}…`);
+      logger.debug(`[OTA] Downloading update v${bundle.version}…`);
 
       // Live progress: native tick → DOWNLOAD_PROGRESS (feeds useOtaUpdate) →
       // throttled POST to the live tracker. `bundle.size` is the authoritative
@@ -740,13 +784,13 @@ export class OtaOrchestrator {
 
         // Sprint 7: Try patch first if offered, fall back to full bundle
         if (bundle.patch && NativeScaleBunOta.stagePatch) {
-          __DEV__ && logger.debug(`[OTA] Patch available (${(bundle.patch.size / 1024).toFixed(0)} KB vs ` + `${(bundle.size / 1024).toFixed(0)} KB full) — trying patch…`);
+          logger.debug(`[OTA] Patch available (${(bundle.patch.size / 1024).toFixed(0)} KB vs ` + `${(bundle.size / 1024).toFixed(0)} KB full) — trying patch…`);
           try {
             staged = await NativeScaleBunOta.stagePatch(bundle.patch.url, bundle.patch.sha256, bundle.sha256 // expected full-bundle hash after patching
             );
             if (staged) {
               patchUsed = true;
-              __DEV__ && logger.debug('[OTA] Patch applied successfully');
+              logger.debug('[OTA] Patch applied successfully');
             } else {
               logger.warn('[OTA] Patch staging returned false — falling back to full bundle');
             }
@@ -837,7 +881,7 @@ export class OtaOrchestrator {
         releaseId: bundle.releaseId,
         version: bundle.version
       });
-      __DEV__ && logger.debug(`[OTA] Update v${bundle.version} installed successfully!`);
+      logger.debug(`[OTA] Update v${bundle.version} installed successfully!`);
 
       // Deliver telemetry BEFORE a restart tears the JS runtime down —
       // an INSTALLED event queued but not sent would vanish with the process.
@@ -883,7 +927,7 @@ export class OtaOrchestrator {
    * native boot-guard marker. If JS crashes before the timer fires, the
    * marker stays set and native code reverts on next cold start.
    */
-  startBootGuardHeartbeat() {
+  startBootGuardHeartbeat(preRead) {
     if (!NativeScaleBunOta) return;
 
     // Cancel any existing timer
@@ -892,20 +936,23 @@ export class OtaOrchestrator {
       this.healthyTimer = null;
     }
     try {
-      const stateJson = NativeScaleBunOta.getSlotState();
-      const state = JSON.parse(stateJson);
+      // getSlotState() is CONSUME-ON-READ for the revert record, so a caller that
+      // has already read it passes the parsed result down rather than letting
+      // this read again and swallow a rollback. `null` is a real answer (module
+      // absent or payload unreadable) — only `undefined` means "nobody read it".
+      const state = preRead !== undefined ? preRead : JSON.parse(NativeScaleBunOta.getSlotState());
 
       // Only run the heartbeat if boot-guard marker is present
       // (meaning we're running from a freshly-applied OTA bundle)
-      if (!state.bootMarkerPresent) {
+      if (!state?.bootMarkerPresent) {
         return;
       }
       const healthyMs = this.bootGuardConfig.healthyAfterMs ?? DEFAULT_HEALTHY_AFTER_MS;
-      __DEV__ && logger.debug(`[OTA] Boot guard active — marking healthy after ${healthyMs}ms`);
+      logger.debug(`[OTA] Boot guard active — marking healthy after ${healthyMs}ms`);
       this.healthyTimer = setTimeout(() => {
         noThrow(() => {
           NativeScaleBunOta?.markHealthy();
-          __DEV__ && logger.info('[OTA] Boot guard cleared — bundle marked healthy ✓');
+          logger.info('[OTA] Boot guard cleared — bundle marked healthy ✓');
           this.healthyTimer = null;
 
           // The honest activation signal. INSTALLED is emitted optimistically,
@@ -960,11 +1007,11 @@ export class OtaOrchestrator {
             /* the restart below makes cleanup moot */
           }
           this.resumeRestartArmed = false;
-          __DEV__ && logger.info('[OTA] App resumed — activating the staged update now');
+          logger.info('[OTA] App resumed — activating the staged update now');
           this.restart();
         }
       });
-      __DEV__ && logger.debug('[OTA] Update staged — will activate on next resume (ON_NEXT_RESUME)');
+      logger.debug('[OTA] Update staged — will activate on next resume (ON_NEXT_RESUME)');
     } catch {
       // AppState unavailable (tests, exotic hosts): the update still activates
       // on the next cold start, which is the documented fallback behaviour.
@@ -984,7 +1031,7 @@ export class OtaOrchestrator {
    */
   restart() {
     noThrow(() => {
-      __DEV__ && logger.info('[OTA] Triggering app restart…');
+      logger.info('[OTA] Triggering app restart…');
       if (NativeScaleBunOta && typeof NativeScaleBunOta.restartApp === 'function') {
         NativeScaleBunOta.restartApp();
       } else if (DevSettings && typeof DevSettings.reload === 'function') {

package/lib/module/features/session/SessionManager.js

@@ -954,6 +954,69 @@ export class SessionManager {
       state_status: stateStatus,
       ui: details?.ui,
       target_id: details?.targetId,
+      /**
+       * RN-6 — shipped with the row so the join is auditable instead of assumed.
+       *
+       * Without it, an interaction with no `target_id` is ambiguous in the worst way:
+       * it could mean the control genuinely had no identity, or that the correlation
+       * refused and the identity exists but could not be attributed. Those are
+       * different defects with different owners, and the accounting lane cannot give
+       * an honest unplaceable REASON without knowing which.
+       *
+       * Undefined on the JS-fallback path (no native event, so nothing was joined),
+       * which is itself the correct answer there rather than a fabricated 'exact'.
+       */
+      correlation: details?.correlation,
+      correlation_delta_ms: details?.correlationDeltaMs,
+      correlation_runner_up_delta_ms: details?.correlationRunnerUpDeltaMs,
+      /**
+       * RN-1/RN-2 — stored alongside `target_id` so a reader can tell an authored
+       * identifier from a structural inference. 'path' means the app authored no testID
+       * and the identity was derived from component names, which is useful but will
+       * change under refactoring; a dashboard that presents the two identically invites
+       * someone to trust a key that is about to move.
+       */
+      target_source: details?.targetSource,
+      /**
+       * RN-8 — stored so "13.8% of interactions have a screen" becomes answerable.
+       * 'none' means the app instrumented nothing the SDK could see; 'manual' means a
+       * <ScaleBunScreen> beacon; 'navigation' means the React Navigation hook. Three
+       * different owners behind one number that today has none.
+       */
+      screen_source: details?.screenSource,
+      /**
+       * RN-13 — what makes "the heat is on this control" checkable instead of assumed.
+       * Absent when the control could not be measured synchronously, which is a fact worth
+       * storing: an unmeasurable control and a mis-placed tap are different findings.
+       */
+      target_rect: details?.targetRect,
+      /**
+       * RN-3 — the backend already reads scrollX/scrollY off the payload into the fact
+       * table's own columns (it has done since the web SDK, which sends `sx`/`sy`), so
+       * these need no migration. Mobile simply never sent them.
+       *
+       * `scroll_source` says whether an offset was available at all: 'none' means the app
+       * uses a plain <ScrollView> rather than the SDK's wrapper, which is a coverage gap in
+       * the integration and not a tap at the top of a list.
+       */
+      scrollX: details?.scrollX,
+      scrollY: details?.scrollY,
+      scroll_source: details?.scrollSource,
+      /**
+       * RN-4 — what stops a recycled native view merging two different rows into one
+       * hotspot. The key is the app's own keyExtractor output, so it is stable across
+       * scrolling and across sessions; the index is carried so a recycled slot (same index,
+       * different key) can be proven rather than inferred.
+       */
+      item_key: details?.itemKey,
+      item_index: details?.itemIndex,
+      /**
+       * RN-15 — where in the control, not just which control. Turns "they tapped Add to
+       * Cart" into "they tapped its left edge", which is what tells you whether a hit area
+       * is right. Outside 0..1 is a hitSlop tap and is kept as such.
+       */
+      local_u: details?.localU,
+      local_v: details?.localV,
       gestureType,
       x: details?.x,
       y: details?.y,

package/lib/module/public/ScaleBunFacade.js

@@ -169,7 +169,7 @@ class ScaleBunFacade {
           const realQueue = coreContainer.get('PersistentQueue');
           const buffered = this._preInitBuffer.popBatch(this._preInitBuffer.length());
           if (buffered.length > 0) {
-            __DEV__ && logger.debug(`[ScaleBun] Draining ${buffered.length} pre-init events into persistent queue`);
+            logger.debug(`[ScaleBun] Draining ${buffered.length} pre-init events into persistent queue`);
             for (const envelope of buffered) {
               realQueue.add(envelope);
             }
@@ -297,7 +297,9 @@ class ScaleBunFacade {
       }
       const clientKey = this._clientKey;
       const apiUrl = this._apiBaseUrl;
-      if (!clientKey || !apiUrl) return;
+      if (!clientKey || !apiUrl) {
+        return;
+      }
       this._otaCheckInFlight = true;
       try {
         const info = await bridgeAdapter.getDeviceInfo();
@@ -354,7 +356,7 @@ class ScaleBunFacade {
       if (!dbgConfig) return;
       dbgConfig.__skipDeprecationWarning = true;
       this.enableDebug(dbgConfig);
-      __DEV__ && logger.info('[ScaleBun] Debug auto-connected via init({ debug }).');
+      logger.info('[ScaleBun] Debug auto-connected via init({ debug }).');
     } catch (err) {
       logger.warn('[ScaleBun] Auto debug connection failed:', err?.message);
     }
@@ -371,7 +373,7 @@ class ScaleBunFacade {
       const apiBaseUrl = this._apiBaseUrl;
       if (!enabled || !appId || !clientKey || !apiBaseUrl) {
         if (enabled && !appId) {
-          __DEV__ && logger.info('[ScaleBun] Envelope event tracking disabled — no appId in init config.');
+          logger.info('[ScaleBun] Envelope event tracking disabled — no appId in init config.');
         }
         return;
       }
@@ -423,7 +425,7 @@ class ScaleBunFacade {
         onEvent: (eventName, revenue) => this._skanManager?.onEvent(eventName, revenue)
       });
       this._eventTracker.start();
-      __DEV__ && logger.info('[ScaleBun] Envelope event tracking started → /v1/batch.');
+      logger.info('[ScaleBun] Envelope event tracking started → /v1/batch.');
 
       // Complete the device context from the native bridge.
       //
@@ -1105,7 +1107,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);
-      __DEV__ && logger.info(`[Engage] debugFetchInAppMessages → ${messages.length} message(s), ${previews.length} test preview(s)`);
+      logger.info(`[Engage] debugFetchInAppMessages → ${messages.length} message(s), ${previews.length} test preview(s)`);
       return messages;
     },
     /** Upload a survey/NPS/feedback response (idempotent, rides the outbox). */
@@ -1390,7 +1392,7 @@ class ScaleBunFacade {
         logger.warn('SDK not initialized. Event dropped:', name);
         return;
       }
-      __DEV__ && logger.debug('Tracking event:', name);
+      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,
@@ -1563,7 +1565,7 @@ class ScaleBunFacade {
         await Promise.all([this._eventTracker?.flush() ?? Promise.resolve(), adapter?.flushAnalytics() ?? Promise.resolve()]);
         return;
       }
-      __DEV__ && logger.debug('Flushing events from persistent queue...');
+      logger.debug('Flushing events from persistent queue...');
       const httpClient = coreContainer.get('HttpClient');
       await flushQueue(this._getQueue(), httpClient, getDeviceId());
     });
@@ -1586,9 +1588,9 @@ class ScaleBunFacade {
       const bootstrapPerfFeature = _getPerformanceFeature();
       if (bootstrapPerfFeature) {
         this._performanceFeature = bootstrapPerfFeature;
-        __DEV__ && logger.debug('Performance feature linked from bootstrap');
+        logger.debug('Performance feature linked from bootstrap');
       }
-      __DEV__ && logger.info('Debug enabled');
+      logger.info('Debug enabled');
     });
   }
 
@@ -1740,14 +1742,14 @@ class ScaleBunFacade {
         return false;
       }
       sm.startSession(metadata);
-      __DEV__ && logger.info('session.start() ✅ sessionId:', sm.currentSessionId);
+      logger.info('session.start() ✅ sessionId:', sm.currentSessionId);
       return true;
     },
     end: reason => {
       const sm = SessionManager.getExistingInstance();
       if (!sm || !sm.isActive) return false;
       sm.endSession(reason);
-      __DEV__ && logger.info('session.end() ✅');
+      logger.info('session.end() ✅');
       return true;
     },
     emitEvent: (type, data) => {
@@ -1805,7 +1807,7 @@ class ScaleBunFacade {
         ...this._privacyConfig,
         ...config
       };
-      __DEV__ && logger.debug('[report] Privacy config updated');
+      logger.debug('[report] Privacy config updated');
     },
     /** Set branding for exported reports. */
     setBranding: config => {
@@ -1813,7 +1815,7 @@ class ScaleBunFacade {
         ...this._brandingConfig,
         ...config
       };
-      __DEV__ && logger.debug('[report] Branding config updated');
+      logger.debug('[report] Branding config updated');
     },
     /** Get current privacy config. */
     getPrivacy: () => ({
@@ -1868,9 +1870,9 @@ class ScaleBunFacade {
           AutoScreenDetector
         } = require('../features/navigation/AutoScreenDetector');
         AutoScreenDetector.getInstance().setNavigationRef(ref);
-        __DEV__ && logger.info('[ScaleBun] Navigation ref set → auto screen detection active');
+        logger.info('[ScaleBun] Navigation ref set → auto screen detection active');
       } catch (err) {
-        __DEV__ && logger.debug('[ScaleBun] Navigation ref stashed (detector not ready):', err?.message);
+        logger.debug('[ScaleBun] Navigation ref stashed (detector not ready):', err?.message);
       }
     });
   }

package/lib/typescript/core/config/schema.d.ts

@@ -86,6 +86,8 @@ export interface ScaleBunConfig {
         redactBodies?: boolean;
     };
     captureInteractionHeatmap: boolean;
+    /** RN-3 zero-config scroll instrumentation. OFF by default — it changes what the HOST renders. */
+    autoInstrumentScrollViews: boolean;
     /** Opt-in: capture console.* into the Logs lane in SaaS mode. Default false. */
     captureConsoleLogs: boolean;
     ota?: {