@scalebun/react-native 1.10.5 → 1.10.7

package/ios/Core/DeviceIdentity.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+/**
+ * The ONE place that answers "which iPhone is this?".
+ *
+ * iOS ships no API for the name a person would recognise. `UIDevice.current.model` returns the
+ * FAMILY — the literal string "iPhone" or "iPad" — which is identical on an iPhone 6 and an
+ * iPhone 17 Pro, so a dashboard grouping by it sees one bucket holding every iOS device ever.
+ * `ReplaySdk.getDeviceInfo` sent exactly that, which is why the replay lane could never tell two
+ * iPhones apart.
+ *
+ * The hardware identifier from `uname()` — "iPhone16,2" — is the only thing the OS will tell us,
+ * and it is unique per model. It is not the marketing name and this module does not pretend
+ * otherwise: turning "iPhone16,2" into "iPhone 15 Pro Max" needs a lookup table, and that table
+ * belongs on the server, where a device released after this binary shipped can be named without
+ * waiting for every app to adopt a new SDK and ship to the App Store.
+ *
+ * `ScaleBunProfilerModule` already had this function privately; both lanes now share it so they
+ * cannot drift into reporting two different models for one device.
+ */
+@objc(ScaleBunDeviceIdentity)
+public final class ScaleBunDeviceIdentity: NSObject {
+
+    /**
+     * The hardware identifier, e.g. "iPhone16,2" / "iPad14,3".
+     *
+     * On the simulator `uname` reports the HOST architecture ("x86_64", "arm64"), so the
+     * simulator's own hint is preferred when present — otherwise every developer's simulator
+     * session lands in the dashboard as a device model named after a CPU.
+     */
+    @objc public static func modelIdentifier() -> String {
+        if let simulator = ProcessInfo.processInfo
+            .environment["SIMULATOR_MODEL_IDENTIFIER"], !simulator.isEmpty {
+            return simulator
+        }
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let identifier = withUnsafePointer(to: &systemInfo.machine) {
+            $0.withMemoryRebound(to: CChar.self, capacity: 1) {
+                String(validatingUTF8: $0) ?? ""
+            }
+        }
+        // Empty rather than "Unknown": an absent measurement must not arrive looking like a value.
+        return identifier
+    }
+
+    // No manufacturer constant here on purpose. iOS's manufacturer is answerable without the
+    // bridge — the platform being iOS entails it — so staticDeviceContext() sets it on the FIRST
+    // event rather than waiting for a native round-trip that may never come back.
+}

package/ios/Ota/ScaleBunOtaBridge.mm

@@ -40,6 +40,12 @@ RCT_EXTERN_METHOD(revertToPrevious:(RCTPromiseResolveBlock)resolve
 
 RCT_EXTERN_METHOD(restartApp)
 
+RCT_EXTERN_METHOD(verifyEd25519:(NSString *)messageHex
+                  signatureHex:(NSString *)signatureHex
+                  publicKeyHex:(NSString *)publicKeyHex
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
 @end
 
 // Download-progress event channel. Swift subclass of RCTEventEmitter; only

package/ios/Ota/ScaleBunOtaModule.swift

@@ -1,6 +1,7 @@
 import Foundation
 import React
 import CommonCrypto
+import CryptoKit
 
 /**
  * React Native bridge for OTA bundle management (`ScaleBunOta`) on iOS.
@@ -252,4 +253,70 @@ class ScaleBunOtaModule: NSObject, RCTBridgeModule {
             RCTTriggerReloadCommandListeners("ScaleBun OTA update")
         }
     }
+
+    /**
+     * Verify a detached ed25519 signature with PLATFORM crypto (CryptoKit).
+     *
+     * Why native: the JS verifier lives inside the very bundle it protects —
+     * one malicious bundle can neuter it for every update after. CryptoKit is
+     * outside the bundle's reach, and unlike Android there is no OS floor to
+     * worry about: Curve25519 signing shipped in iOS 13 and the podspec
+     * already requires 13.4.
+     *
+     * Contract (mirrors `src/specs/NativeScaleBunOta.ts`): inputs are
+     * lowercase hex pre-validated by the JS caller; the message is the RAW 32
+     * BYTES of the bundle SHA-256 (the CLI signs digest bytes, not hex text);
+     * resolves 'valid' / 'invalid' / 'unavailable'. A wrong signature is
+     * 'invalid', never a rejection; anything unexpected is 'unavailable' so
+     * machinery failure can never read as a pass.
+     *
+     * ⚪ UNCOMPILED — no macOS toolchain has been available in this workspace
+     * (the standing gap: BsPatch.swift shipped the same way). The algorithm is
+     * pinned by `tools/ed25519-parity` against the live production fixture;
+     * this file still needs one Xcode build before an iOS consumer ships it.
+     */
+    @objc(verifyEd25519:signatureHex:publicKeyHex:resolve:reject:)
+    func verifyEd25519(_ messageHex: NSString,
+                       signatureHex: NSString,
+                       publicKeyHex: NSString,
+                       resolve: @escaping RCTPromiseResolveBlock,
+                       reject: @escaping RCTPromiseRejectBlock) {
+        guard let message = ScaleBunOtaModule.bytesFromHex(messageHex as String),
+              let signature = ScaleBunOtaModule.bytesFromHex(signatureHex as String),
+              let rawKey = ScaleBunOtaModule.bytesFromHex(publicKeyHex as String),
+              rawKey.count == 32 else {
+            // Malformed input from our own caller is not a forgery verdict.
+            resolve("unavailable")
+            return
+        }
+        do {
+            let key = try Curve25519.Signing.PublicKey(rawRepresentation: rawKey)
+            resolve(key.isValidSignature(signature, for: message) ? "valid" : "invalid")
+        } catch {
+            // Bytes that are not a curve point cannot have signed anything.
+            resolve("invalid")
+        }
+    }
+
+    /// Hex → Data; nil for odd length or a non-hex character.
+    private static func bytesFromHex(_ hex: String) -> Data? {
+        let chars = Array(hex.utf8)
+        guard !chars.isEmpty, chars.count % 2 == 0 else { return nil }
+        var out = Data(capacity: chars.count / 2)
+        for i in stride(from: 0, to: chars.count, by: 2) {
+            guard let hi = ScaleBunOtaModule.hexNibble(chars[i]),
+                  let lo = ScaleBunOtaModule.hexNibble(chars[i + 1]) else { return nil }
+            out.append((hi << 4) | lo)
+        }
+        return out
+    }
+
+    private static func hexNibble(_ c: UInt8) -> UInt8? {
+        switch c {
+        case 0x30...0x39: return c - 0x30            // 0-9
+        case 0x61...0x66: return c - 0x61 + 10       // a-f
+        case 0x41...0x46: return c - 0x41 + 10       // A-F
+        default: return nil
+        }
+    }
 }

package/ios/Profiler/ScaleBunProfilerModule.swift

@@ -392,15 +392,9 @@ class ScaleBunProfilerModule: RCTEventEmitter {
         sendEvent(withName: "ScaleBunProfiler_Capabilities", body: buildCapabilities())
     }
 
+    /** Shared with the replay lane so the two cannot report different models for one device. */
     private func deviceModel() -> String {
-        var systemInfo = utsname()
-        uname(&systemInfo)
-        let modelCode = withUnsafePointer(to: &systemInfo.machine) {
-            $0.withMemoryRebound(to: CChar.self, capacity: 1) {
-                String(validatingUTF8: $0) ?? "Unknown"
-            }
-        }
-        return modelCode
+        return ScaleBunDeviceIdentity.modelIdentifier()
     }
 
     private func isDebugBuild() -> Bool {

package/ios/ReplaySdk.swift

@@ -572,7 +572,9 @@ class ReplaySdk: RCTEventEmitter {
         resolve([
             "platform": "ios",
             "osVersion": device.systemVersion,
-            "deviceModel": device.model,
+            // NOT device.model — that is the family ("iPhone"), identical on every iPhone ever
+            // made. ScaleBunDeviceIdentity reports the hardware identifier, which is unique per model.
+            "deviceModel": ScaleBunDeviceIdentity.modelIdentifier(),
             "screenWidth": Int(screen.bounds.width * screen.scale),
             "screenHeight": Int(screen.bounds.height * screen.scale),
             "pixelDensity": screen.scale,

package/lib/commonjs/analytics/EventTracker.js

@@ -341,6 +341,28 @@ class EventTracker {
     this.persistQueue();
   }
 
+  /**
+   * Fold in device facts that were not knowable at init.
+   *
+   * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+   * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+   * async and may not be installed at all. Without this the iOS half of every install reported no
+   * model whatsoever.
+   *
+   * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+   * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+   * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+   * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+   * cannot blank a value the static path already found.
+   */
+  applyDetectedContext(patch) {
+    if (!patch || Object.keys(patch).length === 0) return;
+    this.cfg.context = {
+      ...(this.cfg.context ?? {}),
+      ...patch
+    };
+  }
+
   // ─── internals ─────────────────────────────────────────────────────────────
 
   buildEnvelope(eventName, properties) {

package/lib/commonjs/core/config/schema.js

@@ -295,6 +295,14 @@ const SHAPE = {
         kind: 'str',
         opt: true
       },
+      // Rotation support: several pinned keys, any of which may verify a
+      // bundle. Ship a build pinning [old, new], re-sign server-side with
+      // new, drop old next release — no emergency store submission when a
+      // key must be replaced. Merged with publicSigningKey by the facade.
+      publicSigningKeys: {
+        kind: 'strArr',
+        opt: true
+      },
       mandatoryBlocksUi: bool(false)
     }
   }
@@ -334,7 +342,7 @@ function parseField(field, input, path, issues) {
       present: true
     };
     // Required with no default (matches the base schemas' type errors on undefined).
-    return fail(field.kind === 'bool' ? 'Expected boolean, received undefined' : field.kind === 'num' ? 'Expected number, received undefined' : field.kind === 'str' ? 'Expected string, received undefined' : field.kind === 'enum' ? "Invalid enum value. Expected " + field.values.map(v => `'${v}'`).join(' | ') : 'Expected object, received undefined');
+    return fail(field.kind === 'bool' ? 'Expected boolean, received undefined' : field.kind === 'num' ? 'Expected number, received undefined' : field.kind === 'str' ? 'Expected string, received undefined' : field.kind === 'strArr' ? 'Expected array, received undefined' : field.kind === 'enum' ? "Invalid enum value. Expected " + field.values.map(v => `'${v}'`).join(' | ') : 'Expected object, received undefined');
   }
   switch (field.kind) {
     case 'any':
@@ -360,6 +368,31 @@ function parseField(field, input, path, issues) {
         value: input,
         present: true
       };
+    case 'strArr':
+      {
+        // Mirrors the vendored ArraySchema exactly: element failures are
+        // reported at their index and fail the whole field (no partial
+        // arrays reach the output).
+        if (!Array.isArray(input)) return fail(`Expected array, received ${typeofName(input)}`);
+        let allOk = true;
+        for (let i = 0; i < input.length; i++) {
+          if (typeof input[i] !== 'string') {
+            issues.push({
+              path: [...path, i],
+              message: `Expected string, received ${typeofName(input[i])}`
+            });
+            allOk = false;
+          }
+        }
+        return allOk ? {
+          ok: true,
+          value: [...input],
+          present: true
+        } : {
+          ok: false,
+          present: true
+        };
+      }
     case 'num':
       if (typeof input !== 'number' || Number.isNaN(input)) {
         return fail(`Expected number, received ${typeofName(input)}`);

package/lib/commonjs/core/constants/version.js

@@ -9,5 +9,5 @@ exports.SDK_VERSION = void 0;
  * can attribute telemetry to the SDK build that produced it.
  * Keep in sync with package.json "version".
  */
-const SDK_VERSION = exports.SDK_VERSION = '1.10.5';
+const SDK_VERSION = exports.SDK_VERSION = '1.10.7';
 //# sourceMappingURL=version.js.map

package/lib/commonjs/core/context/device.js

@@ -104,6 +104,10 @@ function staticDeviceContext() {
   if (osVersion) out.os_version = String(osVersion);
   if (c.Model) out.device_model = String(c.Model);
   if (c.Manufacturer) out.manufacturer = String(c.Manufacturer);else if (c.Brand) out.manufacturer = String(c.Brand);
+  // iOS exposes no manufacturer because it does not need to: every device running iOS is Apple's.
+  // A tautology, not a guess — and it means the field is populated on event #1 rather than waiting
+  // for a bridge that may never answer.
+  else if (out.platform_os === 'ios') out.manufacturer = 'Apple';
   return out;
 }
 
@@ -113,6 +117,7 @@ function nativeDeviceContext(info) {
   if (!info) return out;
   if (info.osVersion) out.os_version = info.osVersion;
   if (info.deviceModel) out.device_model = info.deviceModel;
+  if (info.manufacturer) out.manufacturer = info.manufacturer;
   return out;
 }
 

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

@@ -504,9 +504,33 @@ function ScaleBunDebugRoot({
           } = require('../navigation/AutoScreenDetector');
           screen = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
         } catch {/* no-throw */}
+        /**
+         * UI STATE, read HERE and not later.
+         *
+         * A tap belongs to the surface that was on screen when the finger landed: tapping the
+         * filter button while the sheet is DOWN belongs to `closed`, because that is what the
+         * user was looking at when they reached for it. Reading it after the handler has run
+         * moves every "open the thing" tap into the state it created — the one state it
+         * certainly does not belong to.
+         *
+         * Declared-only on this platform (see uiState.ts): absent means not captured, which
+         * the dashboard keeps distinct from "nothing was open".
+         */
+        let ui;
+        try {
+          const {
+            uiStateSignature
+          } = require('./uiState');
+          ui = uiStateSignature();
+        } catch {/* no-throw: a tap must never be lost to state capture */}
         (0, _automaticEvents.emitAutomaticEvent)('element_interacted', {
           gesture_type: gestureType,
           screen_name: screen,
+          /* THIS MAP ENUMERATES. A field added to the payload and forgotten here reaches the
+             backend as undefined with no error anywhere — the recurring defect class in this
+             codebase. `ui` is the key the grid aggregate reads for state, byte-identical to
+             the web SDK's, so one dashboard control queries both platforms. */
+          ui,
           // testID/nativeID is an author-controlled stable identifier.
           // Accessibility labels and rendered text are deliberately omitted.
           target_id: targetInfo?.testId,

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

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearUiState = clearUiState;
+exports.setUiState = setUiState;
+exports.uiStateSignature = uiStateSignature;
+/**
+ * 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.
+ */
+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.
+ */
+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.
+ */
+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. */
+  return [...declared.keys()].sort().map(k => `${k}:${declared.get(k)}`).join(';').slice(0, 96);
+}
+//# sourceMappingURL=uiState.js.map

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

@@ -0,0 +1,248 @@
+"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