@scalebun/react-native 1.10.6 → 1.11.0

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

@@ -22,9 +22,9 @@
 
 import React, { useEffect, useRef, createContext, useContext } from 'react';
 import { View, NativeEventEmitter, NativeModules } from 'react-native';
-import { emitAutomaticEvent } from '../../analytics/automaticEvents';
 import { resolveTouchTarget, describeTouchTarget } from './touchTarget';
 import { resolvePlatformOS } from '../../core/context/device';
+import { INTERACTION_PROTOCOL_VERSION, generateInteractionId, nearestInteractionStart } from './interactionProtocol';
 
 // ─── Lazy imports to avoid native module cascade at load time ────────────────
 // We only import TYPE references at the top level; actual modules are require()'d
@@ -256,7 +256,9 @@ export function ScaleBunDebugRoot({
   // and forwards them to SessionManager as USER_ACTION events.
   const lastNativeTouchTsRef = useRef(0);
   const nativeTrackingConfirmedRef = useRef(false);
-  const pendingJsEmitRef = useRef(null);
+  const touchStartRef = useRef(null);
+  const interactionStartsRef = useRef([]);
+  const pendingJsEmitsRef = useRef(new Map());
   useEffect(() => {
     let subscription = null;
     try {
@@ -268,11 +270,15 @@ export function ScaleBunDebugRoot({
           // Record timestamp to suppress duplicate JS touch events
           lastNativeTouchTsRef.current = Date.now();
           nativeTrackingConfirmedRef.current = true;
-
-          // Cancel any pending JS emission — native event wins
-          if (pendingJsEmitRef.current !== null) {
-            clearTimeout(pendingJsEmitRef.current);
-            pendingJsEmitRef.current = null;
+          const nativeOccurredAt = typeof event.occurredAt === 'number' ? event.occurredAt : (typeof event.timestamp === 'number' ? event.timestamp : Date.now()) - (typeof event.durationMs === 'number' ? event.durationMs : 0);
+          const start = nearestInteractionStart(interactionStartsRef.current, nativeOccurredAt);
+
+          // Cancel only this physical touch's fallback. A single timer used to cancel a
+          // previous rapid tap and silently lose it on devices without native tracking.
+          if (start) {
+            const pending = pendingJsEmitsRef.current.get(start.interactionId);
+            if (pending !== undefined) clearTimeout(pending);
+            pendingJsEmitsRef.current.delete(start.interactionId);
           }
           const {
             SessionManager
@@ -294,6 +300,15 @@ export function ScaleBunDebugRoot({
             _diagWinH = _d.height;
           } catch {/* no-throw */}
           sm.onGestureDetected(event.gestureType || 'tap', {
+            interactionId: event.interactionId || start?.interactionId || generateInteractionId(),
+            interactionProtocol: event.interactionProtocol || INTERACTION_PROTOCOL_VERSION,
+            occurredAt: nativeOccurredAt,
+            ui: start?.ui,
+            stateStatus: start?.stateStatus ?? 'not_captured',
+            target: start?.target,
+            targetId: start?.targetId,
+            screenName: start?.screenName,
+            emitAutomaticAnalytics: start?.emitAutomaticAnalytics ?? captureAutomaticInteractions,
             x: event.rawX,
             y: event.rawY,
             // Use the actual native end coords when present, not the down
@@ -323,11 +338,12 @@ export function ScaleBunDebugRoot({
       try {
         subscription?.remove();
       } catch {/* no-throw */}
+      for (const timer of pendingJsEmitsRef.current.values()) clearTimeout(timer);
+      pendingJsEmitsRef.current.clear();
     };
-  }, []);
+  }, [captureAutomaticInteractions]);
 
   // ─── Touch Tracking State ───────────────────────────────────────────
-  const touchStartRef = useRef(null);
 
   // On-screen rect of the root view — the EXACT view the native screenshot
   // captures. Normalizing pageX/pageY against this rect makes JS-fallback taps
@@ -371,11 +387,37 @@ export function ScaleBunDebugRoot({
   const handleTouchStart = e => {
     try {
       const touch = e.nativeEvent;
-      touchStartRef.current = {
+      const target = resolveTouchTarget(e);
+      let ui;
+      let screenName;
+      try {
+        const {
+          uiStateSignature
+        } = require('./uiState');
+        ui = uiStateSignature();
+      } catch {/* no-throw */}
+      try {
+        const {
+          AutoScreenDetector
+        } = require('../navigation/AutoScreenDetector');
+        screenName = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
+      } catch {/* no-throw */}
+      const start = {
+        interactionId: generateInteractionId(),
+        occurredAt: Date.now(),
         x: touch.pageX,
         y: touch.pageY,
-        ts: Date.now()
+        locationX: touch.locationX,
+        locationY: touch.locationY,
+        target: describeTouchTarget(target),
+        targetId: target?.testID,
+        screenName,
+        ui,
+        stateStatus: ui ? 'captured_nonempty' : 'not_instrumented',
+        emitAutomaticAnalytics: captureAutomaticInteractions
       };
+      touchStartRef.current = start;
+      interactionStartsRef.current = interactionStartsRef.current.filter(candidate => start.occurredAt - candidate.occurredAt < 5000).concat(start).slice(-8);
     } catch {/* no-throw */}
   };
   const handleTouchEnd = e => {
@@ -414,15 +456,23 @@ export function ScaleBunDebugRoot({
       // WHAT was tapped, resolved from the React fiber on the touch event. Without this the tap
       // carries only coordinates, so every tap in the app groups into one row per gesture type.
       // Defensive by construction — returns undefined rather than throwing (see touchTarget.ts).
-      const tapped = describeTouchTarget(resolveTouchTarget(e));
+      const tapped = start?.target ?? describeTouchTarget(resolveTouchTarget(e));
       const gestureDetails = {
         target: tapped,
-        x: touch.pageX,
-        y: touch.pageY,
-        pageX: touch.pageX,
-        pageY: touch.pageY,
-        locationX: touch.locationX,
-        locationY: touch.locationY,
+        interactionId: start?.interactionId ?? generateInteractionId(),
+        interactionProtocol: INTERACTION_PROTOCOL_VERSION,
+        occurredAt: start?.occurredAt ?? Date.now(),
+        ui: start?.ui,
+        stateStatus: start?.stateStatus ?? 'not_captured',
+        targetId: start?.targetId,
+        screenName: start?.screenName,
+        emitAutomaticAnalytics: start?.emitAutomaticAnalytics ?? captureAutomaticInteractions,
+        x: start?.x ?? touch.pageX,
+        y: start?.y ?? touch.pageY,
+        pageX: start?.x ?? touch.pageX,
+        pageY: start?.y ?? touch.pageY,
+        locationX: start?.locationX ?? touch.locationX,
+        locationY: start?.locationY ?? touch.locationY,
         viewportWidth: vpW > 0 ? vpW : undefined,
         viewportHeight: vpH > 0 ? vpH : undefined
       };
@@ -434,8 +484,8 @@ export function ScaleBunDebugRoot({
       // measureInWindow returns rootRect.y = statusBarHeight, so subtracting it
       // double-counts the status bar and pushes every marker upward.
       if (rootRect && rootRect.w > 0 && rootRect.h > 0) {
-        const nx = Math.max(0, Math.min(1, touch.pageX / rootRect.w));
-        const ny = Math.max(0, Math.min(1, touch.pageY / rootRect.h));
+        const nx = Math.max(0, Math.min(1, (start?.x ?? touch.pageX) / rootRect.w));
+        const ny = Math.max(0, Math.min(1, (start?.y ?? touch.pageY) / rootRect.h));
         gestureDetails.normalizedX = nx;
         gestureDetails.normalizedY = ny;
         gestureDetails.normalizedPrecomputed = true;
@@ -467,7 +517,7 @@ export function ScaleBunDebugRoot({
         const dx = touch.pageX - start.x;
         const dy = touch.pageY - start.y;
         const dist = Math.sqrt(dx * dx + dy * dy);
-        const duration = Date.now() - start.ts;
+        const duration = Date.now() - start.occurredAt;
         gestureDetails.duration = duration;
         if (dist >= 15) {
           // Movement gesture: swipe or scroll
@@ -486,28 +536,6 @@ export function ScaleBunDebugRoot({
           gestureType = 'long_press';
         }
       }
-      const targetInfo = _extractTarget(e);
-      gestureDetails.target = targetInfo?.testId || targetInfo?.accessibilityLabel;
-      if (captureAutomaticInteractions) {
-        let screen;
-        try {
-          const {
-            AutoScreenDetector
-          } = require('../navigation/AutoScreenDetector');
-          screen = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
-        } catch {/* no-throw */}
-        emitAutomaticEvent('element_interacted', {
-          gesture_type: gestureType,
-          screen_name: screen,
-          // testID/nativeID is an author-controlled stable identifier.
-          // Accessibility labels and rendered text are deliberately omitted.
-          target_id: targetInfo?.testId,
-          normalized_x: gestureDetails.normalizedX,
-          normalized_y: gestureDetails.normalizedY,
-          direction: gestureDetails.direction,
-          duration_ms: gestureDetails.duration
-        });
-      }
 
       // Feed the Engage gesture detector (rage_tap / dead_tap) — only committed
       // taps, not swipes/scrolls/long-presses. Pure JS, cross-platform; emits the
@@ -517,18 +545,11 @@ export function ScaleBunDebugRoot({
           const {
             gestureTriggerDetector
           } = require('../engage/gestureTriggerDetector');
-          let screen;
-          try {
-            const {
-              AutoScreenDetector
-            } = require('../navigation/AutoScreenDetector');
-            screen = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
-          } catch {/* no-throw */}
           gestureTriggerDetector.recordTap({
-            x: touch.pageX,
-            y: touch.pageY,
-            hasTarget: !!(targetInfo?.testId || targetInfo?.accessibilityLabel),
-            screen
+            x: start?.x ?? touch.pageX,
+            y: start?.y ?? touch.pageY,
+            hasTarget: !!(start?.targetId || start?.target),
+            screen: start?.screenName
           });
         } catch {/* no-throw */}
       }
@@ -543,7 +564,7 @@ export function ScaleBunDebugRoot({
       // screenshot capture view). Three-tier suppression:
       //   1. Native confirmed active → skip JS entirely (native handles all touches)
       //   2. Native event within 300ms → skip (existing dedup)
-      //   3. First touch (native not yet confirmed) → defer 200ms to let native arrive
+      //   3. First touch (native not yet confirmed) → defer 600ms to let native arrive
       const sinceNative = Date.now() - lastNativeTouchTsRef.current;
       if (nativeTrackingConfirmedRef.current) {
         // Native tracker is active — skip JS path entirely
@@ -556,11 +577,9 @@ export function ScaleBunDebugRoot({
         const capturedDetails = {
           ...gestureDetails
         };
-        if (pendingJsEmitRef.current !== null) {
-          clearTimeout(pendingJsEmitRef.current);
-        }
-        pendingJsEmitRef.current = setTimeout(() => {
-          pendingJsEmitRef.current = null;
+        const interactionId = capturedDetails.interactionId;
+        const timer = setTimeout(() => {
+          pendingJsEmitsRef.current.delete(interactionId);
           if (nativeTrackingConfirmedRef.current) return;
           try {
             const {
@@ -584,6 +603,7 @@ export function ScaleBunDebugRoot({
           // devices with no native tracker at all it merely delays a background emission,
           // which nothing user-visible waits on.
         }, 600);
+        pendingJsEmitsRef.current.set(interactionId, timer);
       }
       touchStartRef.current = null;
     } catch {/* no-throw */}
@@ -698,25 +718,6 @@ export function useScaleBunScreen(name) {
   }, [name, manager]);
 }
 
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-function _extractTarget(e) {
-  try {
-    const target = e?.target;
-    if (!target) return undefined;
-
-    // React Native nativeEvent target properties
-    const props = target._internalFiberInstanceHandleDEV?.memoizedProps ?? {};
-    return {
-      testId: props.testID || props.nativeID || undefined,
-      accessibilityLabel: props.accessibilityLabel || undefined,
-      text: undefined
-    };
-  } catch {
-    return undefined;
-  }
-}
-
 // ─── Styles ─────────────────────────────────────────────────────────────────
 // IMPORTANT: Do NOT use StyleSheet.create() here.
 // In RN 0.84 bridgeless mode, StyleSheet.create() calls

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

@@ -0,0 +1,38 @@
+/** One physical interaction, shared by replay and analytics projections. */
+export const INTERACTION_PROTOCOL_VERSION = 1;
+export function generateInteractionId() {
+  return `ixj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/** Match a native bridge event to the JS evidence sampled at the same finger-down. */
+export function nearestInteractionStart(starts, occurredAt, toleranceMs = 1500) {
+  let best;
+  let bestDelta = toleranceMs + 1;
+  for (const start of starts) {
+    const delta = Math.abs(start.occurredAt - occurredAt);
+    if (delta < bestDelta) {
+      best = start;
+      bestDelta = delta;
+    }
+  }
+  return bestDelta <= toleranceMs ? best : undefined;
+}
+
+/** Analytics is a projection of the same evidence; no second click is invented. */
+export function automaticInteractionProperties(payload, screenName, canonicalMirror) {
+  return {
+    gesture_type: payload.gestureType,
+    screen_name: screenName,
+    interaction_id: payload.interaction_id,
+    interaction_protocol: payload.interaction_protocol,
+    state_status: payload.state_status,
+    ui: payload.ui,
+    target_id: payload.target_id,
+    normalized_x: payload.normalizedX,
+    normalized_y: payload.normalizedY,
+    direction: payload.direction,
+    duration_ms: payload.durationMs,
+    canonical_mirror: canonicalMirror || undefined
+  };
+}
+//# sourceMappingURL=interactionProtocol.js.map

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

@@ -0,0 +1,86 @@
+/**
+ * UI STATE AT INTERACTION TIME — React Native.
+ *
+ * A screen is not just `Cart`. It is `Cart` with the filter sheet down, or up; with the address form
+ * expanded, or collapsed. Those are different interaction surfaces and a tap on one must never be
+ * counted on another — heat from the open sheet painted over the closed layout is a picture of
+ * something that never existed.
+ *
+ * HOW THIS DIFFERS FROM THE WEB, and the difference is not an omission:
+ *
+ *   The web SDK ALSO detects state automatically, by reading `aria-expanded` and open `<dialog>`
+ *   elements out of the live DOM. Those are platform-defined, so reading them is a measurement.
+ *
+ *   React Native has no equivalent. There is no queryable tree of accessibility state that says a
+ *   bottom sheet is up; a sheet is a component with a boolean in someone's store, and the only place
+ *   that boolean exists is the host's own code. Guessing at it — from a modal's presence in the tree, or
+ *   from a component name — would produce a state key that is right on some apps and silently wrong on
+ *   others, and a wrong state key partitions taps into buckets corresponding to nothing.
+ *
+ * So on RN, state is DECLARED and never inferred. `ScaleBun.setUiState('filter-sheet', 'open')` is the
+ * whole mechanism, and its absence means "not captured" rather than "nothing was open". That
+ * distinction is carried all the way to the dashboard: a tap with no declared state is NULL, not '',
+ * and cannot be selected as a state or counted as one. Reporting it as "nothing was open" would be
+ * asserting a measurement nobody took.
+ *
+ * PAIRED WITH: whatzbug-web-sdk/packages/web/src/features/journey/uiState.ts — same wire format
+ * (`name:value` pairs, sorted, `;`-joined, <= 96 chars), same separator stripping, same explicit-wins
+ * precedence, so one dashboard control queries both platforms.
+ */
+
+/** Host-declared state dimensions. The only source on this platform. */
+const declared = new Map();
+
+/**
+ * `;` and `:` are the wire separators and cannot appear inside a name or value; the length is bounded.
+ *
+ * Names and values are IDENTIFIERS, not content. They become aggregation keys in the dashboard, so a
+ * value carrying a person's name or a cart total would put user data into a query key — and into every
+ * chart legend built from it.
+ */
+const clean = s => typeof s === 'string' ? s.replace(/[;:|]/g, '').trim().slice(0, 32) : '';
+
+/**
+ * Declare the state of one UI dimension.
+ *
+ * Call it when the state CHANGES, not on every render: the value is read at interaction time, so it
+ * only has to be correct by the time the next tap lands.
+ */
+export function setUiState(name, value) {
+  const n = clean(name);
+  const v = clean(value);
+  if (n && v) declared.set(n, v);
+}
+
+/**
+ * Stop reporting a dimension — or, with no name, all of them.
+ *
+ * Later taps carry no value for it, which is not the same as carrying a value. Clearing all is what a
+ * screen unmount wants: declarations from the previous screen would otherwise follow the user onto a
+ * surface where they mean nothing, and every tap there would be filed under a state that was not on
+ * screen.
+ */
+export function clearUiState(name) {
+  if (name === undefined) declared.clear();else declared.delete(clean(name));
+}
+
+/**
+ * The signature for the interaction happening RIGHT NOW, or undefined when nothing is declared.
+ *
+ * undefined rather than '' deliberately — see the header. '' is the web's "we looked and nothing was
+ * open"; on RN there is nothing to look at, so the honest answer is silence.
+ */
+export function uiStateSignature() {
+  if (!declared.size) return undefined;
+  /* SORTED, or the same surface produces different signatures depending on the order the host happened
+     to declare things in, and every count fragments into several that mean nothing. */
+  const pairs = [...declared.keys()].sort().map(k => `${k}:${declared.get(k)}`);
+  let signature = '';
+  for (const pair of pairs) {
+    const next = signature ? `${signature};${pair}` : pair;
+    if (next.length > 96) break;
+    signature = next;
+  }
+  return signature || undefined;
+}
+//# sourceMappingURL=uiState.js.map

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

@@ -0,0 +1,240 @@
+/**
+ * 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.
+ */
+
+import { loadEd25519 } from './loadEd25519';
+import { loadSha512 } from './loadSha512';
+import { logger } from '../../../core/logger/internalLogger';
+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.
+ */
+export 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.
+ */
+export function getBuiltinVerifier() {
+  if (resolved !== undefined) return resolved;
+  const ed = loadEd25519();
+  const sha512 = 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.
+    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) {
+      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".
+      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) {
+      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__ && logger.debug('[OTA] Using built-in ed25519 verifier (@noble/ed25519 detected).');
+  return resolved;
+}
+
+/** Test seam — clears the cached resolution. */
+export function _resetBuiltinVerifier() {
+  resolved = undefined;
+}
+//# sourceMappingURL=builtinVerifier.js.map

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

@@ -0,0 +1,34 @@
+/**
+ * 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. */
+
+export 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