@scalebun/react-native 1.13.0 → 2.0.1

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);
                         }
@@ -275,17 +275,11 @@ class ScaleBunFacade {
     /**
      * Boot the OTA orchestrator when the init config asks for it.
      *
-     * `publicSigningKey` / `publicSigningKeys` are honoured here so signature
-     * enforcement is reachable from configuration alone. The list form exists
-     * for key ROTATION: a build pinning [old, new] keeps verifying while the
-     * server moves to the new key, so replacing a key never needs an emergency
-     * store release. Both fields merge (deduplicated) into one pinned set.
-     *
-     * Verification comes from `ota.verifySignature` when supplied, else the
-     * built-in @noble-based verifier (optional peers). Pinning keys with
-     * NEITHER available is fail-CLOSED by design (signature.ts) — an update
-     * that cannot be verified is not installed. We say that out loud rather
-     * than letting the app discover it as a silent no-update condition.
+     * Signature enforcement is no longer configured from JS. Signed releases are
+     * verified and staged in NATIVE code against RSA keys embedded in the app
+     * package (SB-OTA-RSA-SHA256-V1); unsigned releases keep working on SHA-256
+     * integrity. There are no signing-key or `verifySignature` options to pass
+     * through — the host embeds its trusted keys natively.
      */
     private _maybeStartOta(rawConfig: any): void {
         const ota = rawConfig?.ota;
@@ -295,38 +289,6 @@ class ScaleBunFacade {
             // module (or touch the native spec) at import time.
             // eslint-disable-next-line @typescript-eslint/no-var-requires
             const { otaOrchestrator } = require('../features/ota/OtaOrchestrator');
-            const rawSingle = ota.publicSigningKey;
-            const rawList = ota.publicSigningKeys;
-            const publicKeys = Array.from(
-                new Set(
-                    [
-                        ...(typeof rawSingle === 'string' && rawSingle ? [rawSingle] : []),
-                        ...(Array.isArray(rawList) ? rawList : []),
-                    ].filter((k: unknown): k is string => typeof k === 'string' && k.trim().length > 0),
-                ),
-            );
-            // Signing was REQUESTED if a usable key exists, or the host passed a
-            // keys array at all — an empty one included. `publicSigningKeys: []`
-            // is a broken attempt to enable signing, and it must flow through to
-            // signature.ts's fail-closed handling, not silently disable signing.
-            const signingRequested = publicKeys.length > 0 || Array.isArray(rawList);
-            const verifier = ota.verifySignature;
-            if (signingRequested && typeof verifier !== 'function') {
-                // A host verifier is optional since the built-in one landed — the
-                // old unconditional warning here told every correctly-configured
-                // app that its updates would be rejected. Warn only when neither
-                // verifier can actually be resolved.
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const { getBuiltinVerifier } = require('../features/ota/crypto/builtinVerifier');
-                if (!getBuiltinVerifier()) {
-                    logger.warn(
-                        '[ScaleBun] A signing key is pinned but no signature verifier is available. ' +
-                            'Signature checking is fail-closed: updates will be REJECTED until one exists. ' +
-                            'Install the optional peers `@noble/ed25519` + `@noble/hashes` (no further ' +
-                            'code needed), or supply `ota.verifySignature`.',
-                    );
-                }
-            }
             // `healthyAfterMs` is the field BootGuardConfig actually declares.
             // This passed `healthyTimeoutMs`, which nothing reads, so a host that
             // tuned the boot-guard window silently got the 10s default instead.
@@ -339,16 +301,6 @@ class ScaleBunFacade {
                       : undefined;
 
             otaOrchestrator.init({
-                ...(signingRequested
-                    ? {
-                          signature: {
-                              // Single key stays a plain string — the shape every
-                              // existing consumer and test already handles.
-                              publicKey: publicKeys.length === 1 ? publicKeys[0] : publicKeys,
-                              verifier,
-                          },
-                      }
-                    : {}),
                 ...(healthyAfterMs !== undefined ? { healthyAfterMs } : {}),
             });
             logger.info('[ScaleBun] OTA enabled from init config.');
@@ -417,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 {
@@ -478,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);
         }
@@ -495,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;
             }
@@ -547,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.
             //
@@ -1222,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;
@@ -1533,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,
@@ -1698,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());
         });
@@ -1726,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');
         });
     }
 
@@ -1884,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>) => {
@@ -1947,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. */
@@ -2004,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

@@ -25,6 +25,18 @@ export interface Spec extends TurboModule {
    */
   getActiveBundle(): string | null;
 
+  /**
+   * JSON array (string) of the trusted key IDs embedded in the app package, e.g.
+   * `["production-2026-01"]`. Reported on OTA check-in for SDK trust coverage
+   * (CICDPAGE §12) so the dashboard can measure key-rotation adoption. This is
+   * telemetry ONLY — the server never trusts a key because a device claims it.
+   * Empty array when no keys are embedded.
+   */
+  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,
@@ -87,28 +99,31 @@ export interface Spec extends TurboModule {
   restartApp(): void;
 
   /**
-   * Verify a detached ed25519 signature in NATIVE code.
-   *
-   * Exists because the JS verifier runs inside the very bundle it protects —
-   * an attacker who lands one malicious bundle can neuter a JS check for every
-   * update after it. Platform crypto is outside the bundle's reach, and it also
-   * removes the runtime dependency on the optional @noble peers wherever the OS
-   * provides ed25519 (iOS 13+ CryptoKit everywhere; Android API 33+).
+   * Verify a SB-OTA-RSA-SHA256-V1 release envelope in NATIVE code, with no side
+   * effects. `envelopeJson` is the JSON `{ protocol, keyId, signedPayload,
+   * signature, downloadUrl? }` from the check response. Verification uses the
+   * trusted RSA public keys EMBEDDED in the app package (never a key from JS or
+   * the server) and platform `SHA256withRSA` (present on every supported API
+   * level — no API-33 floor).
    *
-   * All three arguments are lowercase hex, pre-validated by the JS caller:
-   * the 32-byte bundle SHA-256 (the signature is over its RAW BYTES, matching
-   * the CLI's signing contract), the 64-byte signature, the 32-byte public key.
-   *
-   * Resolves a verdict STRING, not a boolean, because "the signature is wrong"
-   * and "this OS cannot check" must never collapse into one value:
-   *   'valid'       — signature verifies under the key
-   *   'invalid'     — it does not; the caller must refuse the bundle
-   *   'unavailable' — this OS level has no ed25519 (Android < 33); the caller
-   *                   falls back to the JS verifier
-   * A rejected promise is machinery failure and the caller treats it as
-   * 'unavailable' — never as 'valid'.
+   * Resolves a verdict JSON string: `{ ok: boolean, code?: string, message?,
+   * keyId?, releaseId?, bundleId?, releaseSequence?, artifactSha256?,
+   * artifactSize?, resultArtifactSha256?, fingerprint? }`. A failed check is
+   * `ok:false` with a stable `code`; a rejected promise is machinery failure and
+   * the caller must treat it as a failure, never as valid.
+   */
+  verifyRelease(envelopeJson: string): Promise<string>;
+
+  /**
+   * Native-ENFORCED install: verify the RSA signature (as `verifyRelease`), then
+   * download the artifact, enforce the SIGNED size + SHA-256, and stage it into
+   * the `next` slot — all natively. JavaScript cannot stage bytes that were not
+   * proven authentic (once trusted keys are embedded, the legacy `stageBundle`
+   * path refuses). Does not activate; call `applyUpdate` to promote per the
+   * install mode. Resolves the same verdict JSON as `verifyRelease` (`ok:true`
+   * once staged).
    */
-  verifyEd25519(messageHex: string, signatureHex: string, publicKeyHex: string): Promise<string>;
+  verifyAndStageRelease(envelopeJson: string): Promise<string>;
 }
 
 /**

package/lib/commonjs/features/ota/crypto/builtinVerifier.js

@@ -1,248 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports._resetBuiltinVerifier = _resetBuiltinVerifier;
-exports.decodeSignature = decodeSignature;
-exports.getBuiltinVerifier = getBuiltinVerifier;
-var _loadEd = require("./loadEd25519");
-var _loadSha = require("./loadSha512");
-var _internalLogger = require("../../../core/logger/internalLogger");
-/**
- * Built-in ed25519 verifier, assembled from OPTIONAL peer dependencies.
- *
- * WHAT THIS REPLACES. Pinning `ota.publicSigningKey` used to require the host
- * app to write its own `verifySignature` — roughly a hundred lines of hex and
- * base64 decoding wrapped around a crypto library. That put the single most
- * security-critical operation in the product, the one deciding whether remote
- * code is authentic before it executes, in code the SDK could neither test nor
- * audit. Three failure modes all landed on the app author:
- *
- *   - A verifier that always returns `true` silently disables the feature, and
- *     nothing can detect it.
- *   - @noble's hash-provider property moved between major versions, so a
- *     routine dependency bump made every update fail closed with no signal
- *     pointing at the cause.
- *   - Hand-written base64 decoders tend to omit base64url, so a signature
- *     containing `-` or `_` is rejected as a forgery.
- *
- * All three are now the SDK's problem, which is where they belong. A host that
- * installs `@noble/ed25519` and `@noble/hashes` gets verification by pinning a
- * key and writing no code at all.
- *
- * WHY OPTIONAL AND NOT A HARD DEPENDENCY. Most apps never adopt bundle
- * signing, and they should not carry curve arithmetic they will not run. The
- * `verifySignature` hook remains supported and still WINS over this, for teams
- * with their own crypto policy or a native implementation to delegate to.
- *
- * WHAT THIS DOES NOT FIX. Verification still happens in JS, inside the very
- * bundle it protects. An attacker who lands one malicious bundle by other means
- * can neuter the check for every update after it. Closing that needs native
- * verification — CryptoKit on iOS (13.4+, already the deployment target) and
- * `Signature.getInstance("Ed25519")` on Android API 33+, with a fallback below.
- */
-
-const ED25519_SIGNATURE_BYTES = 64;
-const ED25519_PUBLIC_KEY_BYTES = 32;
-
-/** Hex → bytes. Returns null rather than throwing; callers treat null as "reject". */
-function hexToBytes(hex) {
-  const clean = hex.trim().toLowerCase().replace(/^0x/, '');
-  if (clean.length === 0 || clean.length % 2 !== 0 || /[^0-9a-f]/.test(clean)) return null;
-  const out = new Uint8Array(clean.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-const B64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-/**
- * Base64 → bytes, accepting base64url as well.
- *
- * The `-`/`_` handling is the point. A verifier that omits it rejects a
- * perfectly valid signature as a forgery the moment the signing side emits
- * base64url, and the resulting symptom — updates silently stop installing —
- * looks nothing like a decoding bug.
- */
-function base64ToBytes(b64) {
-  const s = b64.trim().replace(/-/g, '+').replace(/_/g, '/').replace(/=+$/, '');
-  if (s.length === 0) return null;
-  const out = [];
-  let buffer = 0;
-  let bits = 0;
-  for (const ch of s) {
-    const idx = B64_ALPHABET.indexOf(ch);
-    if (idx === -1) return null;
-    buffer = buffer << 6 | idx;
-    bits += 6;
-    if (bits >= 8) {
-      bits -= 8;
-      out.push(buffer >> bits & 0xff);
-    }
-  }
-  return Uint8Array.from(out);
-}
-
-/**
- * Decode a detached signature that may arrive hex- or base64-encoded.
- *
- * Tries the unambiguous case first: 128 hex characters is exactly 64 bytes and
- * cannot be anything else. Otherwise base64, then hex as a last resort. Only a
- * result of exactly 64 bytes is accepted, so a string that decodes under the
- * wrong scheme is rejected rather than fed to the curve code as garbage.
- */
-function decodeSignature(sig) {
-  const trimmed = sig.trim();
-  if (/^(0x)?[0-9a-fA-F]{128}$/.test(trimmed)) {
-    const hex = hexToBytes(trimmed);
-    if (hex && hex.length === ED25519_SIGNATURE_BYTES) return hex;
-  }
-  const b64 = base64ToBytes(trimmed);
-  if (b64 && b64.length === ED25519_SIGNATURE_BYTES) return b64;
-  const hex = hexToBytes(trimmed);
-  if (hex && hex.length === ED25519_SIGNATURE_BYTES) return hex;
-  return null;
-}
-
-/**
- * Give @noble its SHA-512 provider.
- *
- * The property it reads moved between major versions — v2 wants
- * `etc.sha512Sync`, v3 wants `hashes.sha512` — so both are populated when
- * present. Getting this wrong does not fail loudly: verification simply throws
- * from inside the curve code and the outer catch converts it to "rejected",
- * which is indistinguishable from an actual forgery. That ambiguity is exactly
- * what made this a bad thing to ask app authors to maintain.
- */
-function wireSha512(ed, sha512) {
-  // VARIADIC ON PURPOSE. @noble calls its hash provider with several byte
-  // arrays to be hashed as one concatenated message. A wrapper taking a
-  // single argument hashes only the first, silently produces the wrong
-  // digest, and every genuine signature is then reported as INVALID — no
-  // error, no exception, just an authenticity check that always says no.
-  // Verified against a real CLI-produced signature; the single-argument form
-  // failed every positive case while passing every negative one, which is
-  // the most misleading shape a bug of this kind can take.
-  const concat = parts => {
-    if (parts.length === 1) return parts[0];
-    let total = 0;
-    for (const p of parts) total += p.length;
-    const out = new Uint8Array(total);
-    let off = 0;
-    for (const p of parts) {
-      out.set(p, off);
-      off += p.length;
-    }
-    return out;
-  };
-  const sync = (...msgs) => sha512(concat(msgs));
-  const asyncFn = async (...msgs) => sha512(concat(msgs));
-
-  // EACH BRANCH GETS ITS OWN try. Wrapping both in one is a trap, and it cost
-  // an afternoon: under v3 the `hashes` assignment succeeds and the `etc`
-  // object is FROZEN, so the v2-shaped assignment throws "object is not
-  // extensible" — discarding a verifier that was, by then, already correctly
-  // wired. Only "neither shape took" means unavailable.
-  let wired = false;
-  try {
-    if (ed.hashes && typeof ed.hashes === 'object') {
-      if (typeof ed.hashes.sha512 !== 'function') ed.hashes.sha512 = sync;
-      if (typeof ed.hashes.sha512Async !== 'function') ed.hashes.sha512Async = asyncFn;
-      wired = typeof ed.hashes.sha512 === 'function';
-    }
-  } catch {
-    /* frozen or absent — try the other shape */
-  }
-  try {
-    if (ed.etc && typeof ed.etc === 'object') {
-      if (typeof ed.etc.sha512Sync !== 'function') ed.etc.sha512Sync = sync;
-      if (typeof ed.etc.sha512Async !== 'function') ed.etc.sha512Async = asyncFn;
-      wired = wired || typeof ed.etc.sha512Sync === 'function';
-    }
-  } catch {
-    /* frozen or absent — `wired` already records whether the other shape took */
-  }
-  return wired;
-}
-let resolved;
-
-/**
- * The built-in verifier, or null when the optional deps are not installed.
- * Resolution is cached, including the negative result — a missing dependency
- * does not become present at runtime, and retrying the require on every update
- * check would be pure overhead.
- */
-function getBuiltinVerifier() {
-  if (resolved !== undefined) return resolved;
-  const ed = (0, _loadEd.loadEd25519)();
-  const sha512 = (0, _loadSha.loadSha512)();
-  if (!ed || !sha512) {
-    resolved = null;
-    return null;
-  }
-  if (!wireSha512(ed, sha512)) {
-    // A shape neither branch matched — a @noble major this SDK predates.
-    // Report "no verifier", which is actionable, rather than letting every
-    // update fail deep inside the curve code with an opaque error.
-    _internalLogger.logger.error('[OTA] @noble/ed25519 is installed but its SHA-512 provider could not be ' + 'wired (unrecognised version shape). Supply `ota.verifySignature` ' + 'yourself, or pin a @noble/ed25519 version this SDK supports.');
-    resolved = null;
-    return null;
-  }
-  resolved = async ({
-    messageHex,
-    signature,
-    publicKey
-  }) => {
-    const message = hexToBytes(messageHex);
-    const pub = hexToBytes(publicKey);
-    const sig = decodeSignature(signature);
-    if (!message) {
-      _internalLogger.logger.error('[OTA] Bundle SHA-256 is not valid hex — refusing to stage.');
-      return false;
-    }
-    if (!pub || pub.length !== ED25519_PUBLIC_KEY_BYTES) {
-      // Worth naming precisely: a mistyped or wrongly-encoded key would
-      // otherwise present as "every update is a forgery".
-      _internalLogger.logger.error(`[OTA] ota.publicSigningKey must be ${ED25519_PUBLIC_KEY_BYTES} bytes of hex ` + `(${ED25519_PUBLIC_KEY_BYTES * 2} characters) — got ` + `${pub ? `${pub.length} bytes` : 'a value that is not hex'}.`);
-      return false;
-    }
-    if (!sig) {
-      _internalLogger.logger.error('[OTA] Bundle signature is not a 64-byte hex/base64 value.');
-      return false;
-    }
-
-    // @noble THROWS rather than returning false for bytes that are not a
-    // well-formed point — which is most forgeries, since a tampered
-    // signature usually decodes to garbage rather than to a valid-but-wrong
-    // point. Swallowing that here is deliberate: from the SDK's side a
-    // malformed signature IS a rejection, and letting it escape would
-    // surface as `verifier_threw`, the outcome reserved for a HOST verifier
-    // misbehaving. Conflating "this bundle is forged" with "your verifier
-    // is broken" would point every investigation in the wrong direction.
-    try {
-      // SYNC FIRST, and this is not a style preference. @noble's
-      // `verifyAsync` reaches for `crypto.subtle` — "crypto.subtle must be
-      // defined, consider polyfill" — which React Native does not provide
-      // and neither does a plain Node test environment. The sync `verify`
-      // uses the SHA-512 provider wired above and needs no WebCrypto, so
-      // it is the path that actually works on a phone. Verification is a
-      // few hundred microseconds over a 32-byte digest, once per update
-      // check, so there is nothing to gain from the async form anyway.
-      if (typeof ed.verify === 'function') return ed.verify(sig, message, pub);
-      if (typeof ed.verifyAsync === 'function') return await ed.verifyAsync(sig, message, pub);
-      return false;
-    } catch {
-      return false;
-    }
-  };
-  __DEV__ && _internalLogger.logger.debug('[OTA] Using built-in ed25519 verifier (@noble/ed25519 detected).');
-  return resolved;
-}
-
-/** Test seam — clears the cached resolution. */
-function _resetBuiltinVerifier() {
-  resolved = undefined;
-}
-//# sourceMappingURL=builtinVerifier.js.map

package/lib/commonjs/features/ota/crypto/loadEd25519.js

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.loadEd25519 = loadEd25519;
-/**
- * Isolated lazy loader for the OPTIONAL `@noble/ed25519` dep.
- *
- * WHY ITS OWN FILE: Metro's dependency collector emits a dependency map one
- * entry short for a module containing TWO OR MORE different-string inline
- * `require()` calls, so the require indices desync and `_dependencyMap[N]`
- * reads `undefined` ("Requiring unknown module 'undefined'"). Exactly ONE
- * inline require per module avoids the miscount. `loadSha512` is a sibling file
- * for the same reason — see `push/adapters/loadNotifee.ts`, which hit this first.
- *
- * The string must still be STATICALLY resolvable at bundle time; hosts that do
- * not install it stub it via `withScaleBun`.
- */
-
-/** The subset of the @noble/ed25519 surface this SDK uses. */
-
-function loadEd25519() {
-  try {
-    const mod = require('@noble/ed25519');
-    const ed = mod?.default ?? mod;
-    // Validate the API actually used, not mere truthiness: when the package
-    // is absent `withScaleBun` resolves it to an EMPTY STUB MODULE, which is
-    // a perfectly truthy object. A stub must read as "unavailable", because
-    // treating it as available would make every signed update fail with a
-    // crypto error instead of the actionable "no verifier" message.
-    if (typeof ed?.verifyAsync === 'function' || typeof ed?.verify === 'function') {
-      return ed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-//# sourceMappingURL=loadEd25519.js.map

package/lib/commonjs/features/ota/crypto/loadSha512.js

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.loadSha512 = loadSha512;
-/**
- * Isolated lazy loader for the OPTIONAL `@noble/hashes` SHA-512.
- *
- * Separate file from `loadEd25519` because Metro miscounts a module holding two
- * different-string inline `require()` calls — see the comment there.
- *
- * ed25519 is defined in terms of SHA-512, and React Native has no native
- * SHA-512, so @noble/ed25519 cannot verify anything until a hash provider is
- * wired into it. Which property it expects differs by major version, so the
- * wiring lives in `builtinVerifier`, not here; this module only obtains the
- * function.
- */
-
-function loadSha512() {
-  try {
-    // The `.js` SUFFIX IS REQUIRED, not stylistic. @noble/hashes v2 declares
-    // its exports map with extensions — `"./sha2.js"`, not `"./sha2"` — so
-    // the extensionless form misses the map entirely. Node still resolves it
-    // by falling back to file-based lookup, which is why it passes here,
-    // but Metro prints
-    //   "Attempted to import … not listed in the exports … Falling back to
-    //    file-based resolution"
-    // on every bundle, and that fallback is exactly what a stricter resolver
-    // (or a future Metro) drops. Caught while bundling a real Expo app.
-    const mod = require('@noble/hashes/sha2.js');
-    const sha512 = mod?.sha512 ?? mod?.default?.sha512;
-    // A stubbed module yields undefined here, which correctly reads as
-    // "unavailable" rather than throwing deep inside the curve code later.
-    return typeof sha512 === 'function' ? sha512 : null;
-  } catch {
-    return null;
-  }
-}
-//# sourceMappingURL=loadSha512.js.map