@scalebun/react-native 2.0.0 → 2.0.2

package/src/features/ota/OtaOrchestrator.ts

@@ -137,12 +137,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: any) {
     // 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}`);
   }
 }
 
@@ -188,6 +188,8 @@ export class OtaOrchestrator {
     return this.currentBundle;
   }
   private isRestartRequiredState = false;
+  /** Root/jailbreak indicators observed at init; empty when none found. */
+  private integrityIndicators: string[] = [];
   private healthyTimer: ReturnType<typeof setTimeout> | null = null;
   private bootGuardConfig: BootGuardConfig = {};
   private environment: OtaEnvironment | null = null;
@@ -247,7 +249,7 @@ 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(
+        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.',
@@ -256,8 +258,30 @@ export class OtaOrchestrator {
 
       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) as string[]) : [];
+        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(
+      logger.debug(
         `[OTA] Orchestrator initialized (RN ${this.environment.rnVersionString ?? 'unknown'}` +
           `${this.environment.bridgeless ? ', bridgeless' : ''}` +
           `${this.environment.hermes ? `, Hermes HBC v${this.environment.hermesBytecodeVersion ?? '?'}` : ''})`,
@@ -292,6 +316,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);
     });
   }
 
@@ -331,7 +371,7 @@ export class OtaOrchestrator {
           releaseId: record.releaseId ?? undefined,
           sha256: record.sha256,
         } as OtaBundlePayload;
-        __DEV__ && logger.debug(`[OTA] Running bundle v${record.version} (${record.bundleId})`);
+        logger.debug(`[OTA] Running bundle v${record.version} (${record.bundleId})`);
         return;
       }
 
@@ -339,7 +379,7 @@ export class OtaOrchestrator {
       // a reinstall of the app, cleared storage, or a bundle staged by an
       // older SDK. Report the hash so the server can still recognise it.
       this.currentBundle = { sha256: current.sha256 } as OtaBundlePayload;
-      __DEV__ && logger.debug(
+      logger.debug(
         `[OTA] Running an OTA bundle (sha ${String(current.sha256).slice(0, 12)}…) with no local install record.`,
       );
     } catch {
@@ -391,7 +431,7 @@ export class OtaOrchestrator {
     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;
     }
@@ -563,6 +603,14 @@ export class OtaOrchestrator {
     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(): string[] {
+    return [...this.integrityIndicators];
+  }
+
   isRestartRequired(): boolean {
     return this.isRestartRequiredState;
   }
@@ -698,7 +746,7 @@ export class OtaOrchestrator {
         return { status: 'ERROR', 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
@@ -719,7 +767,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 { status: 'UP_TO_DATE' };
@@ -770,7 +818,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
@@ -871,7 +919,7 @@ export class OtaOrchestrator {
 
         // Sprint 7: Try patch first if offered, fall back to full bundle
         if (bundle.patch && NativeScaleBunOta.stagePatch) {
-          __DEV__ && logger.debug(
+          logger.debug(
             `[OTA] Patch available (${(bundle.patch.size / 1024).toFixed(0)} KB vs ` +
               `${(bundle.size / 1024).toFixed(0)} KB full) — trying patch…`,
           );
@@ -883,7 +931,7 @@ export class OtaOrchestrator {
             );
             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');
             }
@@ -972,7 +1020,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.
@@ -1016,7 +1064,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.
    */
-  private startBootGuardHeartbeat(): void {
+  private startBootGuardHeartbeat(preRead?: Record<string, any> | null): void {
     if (!NativeScaleBunOta) return;
 
     // Cancel any existing timer
@@ -1026,22 +1074,28 @@ export class OtaOrchestrator {
     }
 
     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()) as Record<string, any>);
 
       // 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,
@@ -1097,11 +1151,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.
@@ -1121,7 +1175,7 @@ export class OtaOrchestrator {
    */
   restart(): void {
     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/src/features/session/SessionManager.ts

@@ -1105,6 +1105,56 @@ export class SessionManager {
         targetId?: string;
         screenName?: string;
         emitAutomaticAnalytics?: boolean;
+        /**
+         * RN-6 — the native↔JS join's own verdict, and it MUST be declared here.
+         *
+         * This signature ENUMERATES its fields rather than spreading, and the only caller
+         * (ScaleBunDebugRoot's native listener) invokes it through `(sm as any)`. So a field
+         * added at the call site and not added here is dropped in silence, with no type
+         * error anywhere — which is precisely how these three nearly shipped as a no-op.
+         *
+         * 'exact' = one JS start was clearly closest. 'ambiguous' = two were within
+         * CORRELATION_MARGIN_MS of each other, so target/ui/screenName were deliberately
+         * withheld rather than guessed. 'none' = no start within tolerance, meaning the JS
+         * handler never fired. The last two are kept distinct because they have different
+         * fixes and collapsing them would hide which is happening in production.
+         */
+        correlation?: 'exact' | 'ambiguous' | 'none';
+        correlationDeltaMs?: number | null;
+        correlationRunnerUpDeltaMs?: number | null;
+        /**
+         * RN-1/RN-2 — which kind of identity `targetId` is. Declared here for the same reason as
+         * the correlation fields above: this signature enumerates, and its only caller goes
+         * through `(sm as any)`, so an undeclared field is dropped in silence.
+         */
+        targetSource?: 'testID' | 'path' | 'component' | 'none';
+        /** RN-8: where the screen name came from. Declared here because this signature enumerates. */
+        screenSource?: 'manual' | 'navigation' | 'none';
+        /**
+         * RN-13: the target control's rectangle in capture-base fractions. Declared here because
+         * this signature ENUMERATES — the sixth field to need it, after three correlation fields,
+         * targetSource and screenSource.
+         */
+        targetRect?: { x: number; y: number; width: number; height: number };
+        /**
+         * RN-3: content offset of the nearest ancestor scroller. Declared here because this
+         * signature ENUMERATES — the seventh field to need it.
+         */
+        scrollX?: number;
+        scrollY?: number;
+        scrollSource?: 'wrapper' | 'none';
+        /**
+         * RN-4: list row identity. Declared here because this signature ENUMERATES — the eighth
+         * and ninth fields to need it.
+         */
+        itemKey?: string;
+        itemIndex?: number;
+        /**
+         * RN-15: tap position within the target control. Declared here because this signature
+         * ENUMERATES — the tenth and eleventh fields to need it.
+         */
+        localU?: number;
+        localV?: number;
     }): void {
         // Exact-duplicate suppression — see _lastGestureSig. Signature is the gesture type plus
         // raw coordinates verbatim; String() keeps undefined coords distinct from 0 (a payload
@@ -1136,6 +1186,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/src/public/ScaleBunFacade.ts

@@ -235,7 +235,7 @@ class ScaleBunFacade {
                     const realQueue = coreContainer.get<PersistentQueue>('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);
                         }
@@ -369,7 +369,9 @@ class ScaleBunFacade {
             }
             const clientKey = this._clientKey;
             const apiUrl = this._apiBaseUrl;
-            if (!clientKey || !apiUrl) return;
+            if (!clientKey || !apiUrl) {
+                return;
+            }
 
             this._otaCheckInFlight = true;
             try {
@@ -430,7 +432,7 @@ class ScaleBunFacade {
             if (!dbgConfig) return;
             (dbgConfig as any).__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: any) {
             logger.warn('[ScaleBun] Auto debug connection failed:', err?.message);
         }
@@ -447,7 +449,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;
             }
@@ -499,7 +501,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.
             //
@@ -1174,7 +1176,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(
+            logger.info(
                 `[Engage] debugFetchInAppMessages → ${messages.length} message(s), ${previews.length} test preview(s)`,
             );
             return messages;
@@ -1485,7 +1487,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,
@@ -1650,7 +1652,7 @@ class ScaleBunFacade {
                 ]);
                 return;
             }
-            __DEV__ && logger.debug('Flushing events from persistent queue...');
+            logger.debug('Flushing events from persistent queue...');
             const httpClient = coreContainer.get<HttpClient>('HttpClient');
             await flushQueue(this._getQueue(), httpClient, getDeviceId());
         });
@@ -1678,10 +1680,10 @@ 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');
         });
     }
 
@@ -1836,14 +1838,14 @@ class ScaleBunFacade {
                 return false;
             }
             sm.startSession(metadata as Parameters<SessionManager['startSession']>[0]);
-            __DEV__ && logger.info('session.start() ✅ sessionId:', sm.currentSessionId);
+            logger.info('session.start() ✅ sessionId:', sm.currentSessionId);
             return true;
         },
         end: (reason?: 'ended' | 'timeout'): boolean => {
             const sm = SessionManager.getExistingInstance();
             if (!sm || !sm.isActive) return false;
             sm.endSession(reason);
-            __DEV__ && logger.info('session.end() ✅');
+            logger.info('session.end() ✅');
             return true;
         },
         emitEvent: (type: string, data?: Record<string, unknown>) => {
@@ -1899,13 +1901,13 @@ class ScaleBunFacade {
         /** Set SDK-wide privacy settings for report generation. */
         setPrivacy: (config: PrivacyConfig): void => {
             this._privacyConfig = { ...this._privacyConfig, ...config };
-            __DEV__ && logger.debug('[report] Privacy config updated');
+            logger.debug('[report] Privacy config updated');
         },
 
         /** Set branding for exported reports. */
         setBranding: (config: BrandingConfig): void => {
             this._brandingConfig = { ...this._brandingConfig, ...config };
-            __DEV__ && logger.debug('[report] Branding config updated');
+            logger.debug('[report] Branding config updated');
         },
 
         /** Get current privacy config. */
@@ -1956,9 +1958,9 @@ class ScaleBunFacade {
             try {
                 const { 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: any) {
-                __DEV__ && logger.debug('[ScaleBun] Navigation ref stashed (detector not ready):', err?.message);
+                logger.debug('[ScaleBun] Navigation ref stashed (detector not ready):', err?.message);
             }
         });
     }

package/src/public/types.ts

@@ -334,6 +334,16 @@ export interface SimplifiedInitConfig {
     appId?: string;
     /** SDK client key (SaaS mode). Also used to authenticate the envelope lane. */
     clientKey?: string;
+    /**
+     * Patch React Native's ScrollView export so every scroll view reports its scroll offset,
+     * giving taps their content depth without the app swapping to ScaleBunScrollView.
+     *
+     * OFF BY DEFAULT because it changes what the host renders, not merely what the SDK records:
+     * every scroll view in the app — including ones inside libraries you did not write — routes
+     * through an SDK wrapper. Turn it on deliberately. With it off, taps on a plain ScrollView
+     * report no content depth and say so, rather than reporting a fabricated offset of 0.
+     */
+    autoInstrumentScrollViews?: boolean;
     /** Platform OVERRIDE — auto-detected from Platform.OS when omitted (integrations should omit it). */
     platform?: 'ios' | 'android' | 'web' | 'react_native';
     /**

package/src/specs/NativeScaleBunOta.ts

@@ -34,6 +34,9 @@ export interface Spec extends TurboModule {
    */
   getTrustedKeyIds(): string;
 
+  /** JSON array of root/jailbreak indicator strings; [] when none found. */
+  getDeviceIntegrity(): string;
+
   /**
    * Returns JSON with current slot state:
    * { current: { bundleId, version, sha256, installedAt } | null,