@oxyhq/core 4.0.1 → 5.0.0

package/dist/cjs/utils/platformCrypto.js

@@ -1,165 +0,0 @@
-"use strict";
-/**
- * Platform Crypto / Storage — Default Variant (Node.js, Browser, generic bundlers)
- *
- * Provides lazy access to platform-specific crypto and storage modules.
- *
- * # Variants
- *
- * This module ships in two physical variants on disk, selected per consumer
- * by the bundler / runtime:
- *
- * - `platformCrypto.js`           — this file. Used by Node.js, Vite, webpack,
- *                                   Rollup, esbuild, and anything that does
- *                                   not match Metro's `*.native.js`
- *                                   source-extension preference.
- * - `platformCrypto.native.js`    — sibling file. Picked up automatically by
- *                                   Metro's resolver (which prefers
- *                                   `*.<platform>.js` and `*.native.js` over
- *                                   plain `*.js` when `preferNativePlatform`
- *                                   is true — Expo sets this for all non-web
- *                                   builds).
- *
- * The `package.json#exports` map also declares a `"react-native"` condition
- * pointing at the same `dist/esm/index.js` entry — that entry transitively
- * imports `./platformCrypto`, and Metro's per-file source-extension lookup
- * substitutes the `.native.js` sibling automatically inside `dist/`. This
- * means consumers never have to add resolver shims; Metro Just Works.
- *
- * Both variants expose the EXACT same public API; importers don't need to know
- * which one they got. The variant difference is purely about which underlying
- * native modules each one references:
- *
- *   ┌──────────────────┬───────────────────────┬───────────────────────────────┐
- *   │ Function         │ Default variant       │ React Native variant          │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ loadNodeCrypto   │ `await import('crypto')` (Node built-in)              │
- *   │                  │                       │ throws — Node crypto is not   │
- *   │                  │                       │ available on Hermes/RN        │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ loadExpoCrypto   │ throws — expo-crypto  │ static `import 'expo-crypto'` │
- *   │                  │ is not part of a      │                               │
- *   │                  │ Node/Vite bundle      │                               │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ loadSecureStore  │ throws (web/Node have │ static `import 'expo-secure-` │
- *   │                  │ their own storage)    │ store'                        │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ loadAsyncStorage │ throws (web/Node have │ static `import '@react-       │
- *   │                  │ their own storage)    │ native-async-storage/...'     │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ getRandomBytesRN │ throws (RN-only)      │ direct call into expo-crypto  │
- *   └──────────────────┴───────────────────────┴───────────────────────────────┘
- *
- * Crucially, the default variant references ONLY Node's `'crypto'`. It never
- * mentions `expo-*` or `@react-native-async-storage/*` — so Vite, webpack,
- * esbuild, Rollup, and Node itself can bundle / require it without ever
- * attempting to resolve those RN-only packages.
- *
- * The React Native variant references ONLY the RN packages. It never
- * mentions `'crypto'` — so Metro and Hermes have nothing to choke on.
- *
- * # Why not a single file with dynamic import?
- *
- * A previous iteration used a "bundler-opaque" `new Function('s', 'return
- * import(s)')` trick so a single file could service every platform. It
- * bundled cleanly on Metro but Hermes refused to PARSE the resulting
- * `import()` expression inside a Function-constructor body
- * (`SyntaxError: Invalid expression encountered` at the `(` of `import(`).
- * The platform-extension split is the only approach that lets each runtime
- * see a file containing only specifiers it can understand — no tricks, no
- * runtime parsing risks.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadNodeCrypto = loadNodeCrypto;
-exports.loadExpoCrypto = loadExpoCrypto;
-exports.loadSecureStore = loadSecureStore;
-exports.loadAsyncStorage = loadAsyncStorage;
-exports.getRandomBytesRN = getRandomBytesRN;
-const platform_1 = require("./platform");
-// ---------------------------------------------------------------------------
-// Node `crypto` — Node built-in
-//
-// `await import('crypto')` here is a real, static-from-tsc's-perspective
-// dynamic import. Node ESM, Vite, webpack, and esbuild all resolve it fine.
-// Metro never sees this file because the `.react-native.js` sibling shadows
-// it, so Metro never tries to resolve `'crypto'`.
-// ---------------------------------------------------------------------------
-let cachedNodeCrypto = null;
-async function loadNodeCrypto() {
-    if (cachedNodeCrypto) {
-        return cachedNodeCrypto;
-    }
-    cachedNodeCrypto = await Promise.resolve().then(() => __importStar(require('node:crypto')));
-    return cachedNodeCrypto;
-}
-// ---------------------------------------------------------------------------
-// RN-only modules — never called from this variant.
-//
-// These throw a clear error if anything ever reaches them outside RN. In
-// practice every caller gates with `isReactNative()` before calling, so
-// these are belt-and-braces.
-// ---------------------------------------------------------------------------
-function notReactNativeError(module) {
-    return new Error(`[oxy.platformCrypto] Tried to load '${module}' outside React Native. This module is only available in a React Native runtime; bundling routed this consumer to the default (Node/web) variant. This indicates a missing platform gate (\`isReactNative()\`) in the calling code.`);
-}
-async function loadExpoCrypto() {
-    if ((0, platform_1.isReactNative)()) {
-        // Should be unreachable: when running on RN, Metro / the `react-native`
-        // exports condition serves the sibling variant. If we got here, the
-        // package-exports map is misconfigured for this host. Throw with a
-        // helpful diagnostic rather than fall back to a broken dynamic import.
-        throw new Error('[oxy.platformCrypto] React Native runtime resolved the default ' +
-            '(non-RN) variant of @oxyhq/core/utils/platformCrypto. Check the ' +
-            "consumer's bundler resolution — Metro should pick the sibling " +
-            '.react-native.js file via package exports.');
-    }
-    throw notReactNativeError('expo-crypto');
-}
-async function loadSecureStore() {
-    throw notReactNativeError('expo-secure-store');
-}
-async function loadAsyncStorage() {
-    throw notReactNativeError('@react-native-async-storage/async-storage');
-}
-/**
- * Synchronous random-bytes via `expo-crypto.getRandomBytes`. Only available
- * in the React Native variant. The default variant throws because Node and
- * browsers have their own native CSPRNGs (`crypto.randomBytes` and
- * `crypto.getRandomValues` respectively) — callers should use those.
- */
-function getRandomBytesRN(_byteCount) {
-    throw notReactNativeError('expo-crypto.getRandomBytes (sync)');
-}

package/dist/cjs/utils/platformCrypto.native.js

@@ -1,123 +0,0 @@
-"use strict";
-/**
- * Platform Crypto / Storage — React Native Variant
- *
- * Companion to `./platformCrypto.ts`. See the doc-comment at the top of that
- * file for the full design.
- *
- * Metro auto-selects this file in any non-web build (`preferNativePlatform`
- * is `true` for iOS / Android, so `*.native.js` shadows `*.js` during
- * source-extension resolution inside `node_modules/@oxyhq/core/dist/`). On
- * iOS / Android `<base>.ios.js` / `<base>.android.js` would shadow this file
- * if they existed, but they don't — `.native.js` is the shared RN variant.
- *
- *   - The default variant references Node's `'crypto'` and would crash Metro
- *     if bundled into an RN app.
- *   - This variant references the RN-only modules (`expo-crypto`,
- *     `expo-secure-store`, `@react-native-async-storage/async-storage`)
- *     as static imports, so Metro and Hermes both resolve and parse them
- *     cleanly.
- *
- * Both variants expose the same surface; importers don't care which one
- * they got.
- *
- * # Why static imports?
- *
- * Every RN consumer of `@oxyhq/core` already lists or transitively pulls
- * in `expo-crypto`, `expo-secure-store`, and
- * `@react-native-async-storage/async-storage` (they're stable Expo modules
- * present in `services`, `accounts`, `inbox`, and `test-app`). A static
- * import is what Metro wants to see anyway, and Hermes parses it like any
- * other ES module — no `Function`-constructor parser exotic-mode involved.
- *
- * This is also clearer to debug: Metro fails up-front with a normal
- * unresolved-module error if a consumer is missing a peer dep, instead of
- * a confusing runtime throw the first time a code path that needs the
- * module is exercised.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadNodeCrypto = loadNodeCrypto;
-exports.loadExpoCrypto = loadExpoCrypto;
-exports.loadSecureStore = loadSecureStore;
-exports.loadAsyncStorage = loadAsyncStorage;
-exports.getRandomBytesRN = getRandomBytesRN;
-const ExpoCrypto = __importStar(require("expo-crypto"));
-const SecureStore = __importStar(require("expo-secure-store"));
-const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
-// ---------------------------------------------------------------------------
-// Node `crypto` — never available in RN.
-// ---------------------------------------------------------------------------
-async function loadNodeCrypto() {
-    // Unreachable in practice: every caller gates with `isNodeJS()` before
-    // invoking this. If it somehow does fire, throw immediately with a clear
-    // diagnostic rather than letting Metro / Hermes attempt to find a
-    // non-existent module at runtime.
-    throw new Error("[oxy.platformCrypto] Node's built-in 'crypto' module is not available " +
-        'in a React Native runtime. Use the RN-specific helpers ' +
-        '(loadExpoCrypto, getRandomBytesRN) or the Web Crypto API (`globalThis.crypto`).');
-}
-// ---------------------------------------------------------------------------
-// expo-crypto — RN cryptographic primitives.
-// ---------------------------------------------------------------------------
-async function loadExpoCrypto() {
-    return ExpoCrypto;
-}
-// ---------------------------------------------------------------------------
-// expo-secure-store — RN keychain / keystore.
-// ---------------------------------------------------------------------------
-async function loadSecureStore() {
-    return SecureStore;
-}
-async function loadAsyncStorage() {
-    // Mirror the shape callers historically used (`module.default.<method>`)
-    // so the call sites don't have to know whether the underlying module
-    // ships ESM or CJS-with-default.
-    const storage = async_storage_1.default;
-    return {
-        default: storage,
-    };
-}
-/**
- * Synchronous random-bytes via `expo-crypto.getRandomBytes`. Available
- * synchronously because `expo-crypto` is statically imported by this file
- * — no async initialization race.
- */
-function getRandomBytesRN(byteCount) {
-    return ExpoCrypto.getRandomBytes(byteCount);
-}

package/dist/esm/crypto/canonicalJson.js

@@ -1,104 +0,0 @@
-/**
- * Canonical JSON (RFC 8785 / JCS-style) serialization.
- *
- * `canonicalize(value)` produces a deterministic string for any JSON-compatible
- * value so that a client which SIGNS a record and a server which VERIFIES it
- * agree byte-for-byte on the signing input — regardless of the order in which
- * object keys happen to be written, how the value was deserialized, or which
- * runtime built it.
- *
- * This is the load-bearing primitive for the self-sovereign identity layer's
- * signed records (`SignatureService.signRecord` + the API's record-verify path):
- * both sides import THIS function from `@oxyhq/core`, so cross-implementation
- * number/string formatting differences cannot cause a verify mismatch.
- *
- * Rules (the JSON Canonicalization Scheme subset we need):
- *  - Objects: keys are sorted (ascending, by UTF-16 code unit — the default
- *    `Array.prototype.sort` order) and serialized recursively. Properties whose
- *    value is `undefined`, a function, or a symbol are OMITTED (matching
- *    `JSON.stringify` object semantics).
- *  - Arrays: element order is PRESERVED; `undefined`/function/symbol elements
- *    serialize to `null` (matching `JSON.stringify` array semantics).
- *  - `null`, booleans, strings, and finite numbers serialize via the standard
- *    JSON representation.
- *  - Values exposing a `toJSON()` method (e.g. `Date`) are replaced by its
- *    result first, then serialized — so a `Date` and its ISO-string equivalent
- *    canonicalize identically (the wire always carries the string form).
- *  - Non-finite numbers (`NaN`, `Infinity`) and `bigint` are not part of the
- *    JSON data model and throw, rather than silently producing `null`.
- *
- * Platform-agnostic — zero dependencies, no `require()`, no react/react-native/
- * expo. Safe in the dual CJS + ESM build.
- */
-function hasToJSON(value) {
-    return typeof value.toJSON === 'function';
-}
-/**
- * Serialize a single value into its canonical JSON fragment. Recursive; called
- * on each nested member. Object keys are sorted at every level.
- */
-function serialize(value) {
-    if (value === null) {
-        return 'null';
-    }
-    const valueType = typeof value;
-    if (valueType === 'number') {
-        if (!Number.isFinite(value)) {
-            throw new Error('canonicalize: non-finite numbers cannot be serialized');
-        }
-        return JSON.stringify(value);
-    }
-    if (valueType === 'string' || valueType === 'boolean') {
-        return JSON.stringify(value);
-    }
-    if (valueType === 'bigint') {
-        throw new Error('canonicalize: bigint values cannot be serialized');
-    }
-    if (Array.isArray(value)) {
-        const items = value.map((item) => {
-            const itemType = typeof item;
-            // JSON array semantics: undefined / function / symbol become null so the
-            // element positions (and therefore the array length) are preserved.
-            if (item === undefined || itemType === 'function' || itemType === 'symbol') {
-                return 'null';
-            }
-            return serialize(item);
-        });
-        return `[${items.join(',')}]`;
-    }
-    if (valueType === 'object') {
-        const obj = value;
-        if (hasToJSON(obj)) {
-            return serialize(obj.toJSON());
-        }
-        const record = obj;
-        const parts = [];
-        for (const key of Object.keys(record).sort()) {
-            const member = record[key];
-            const memberType = typeof member;
-            // JSON object semantics: properties with undefined / function / symbol
-            // values are omitted entirely.
-            if (member === undefined || memberType === 'function' || memberType === 'symbol') {
-                continue;
-            }
-            parts.push(`${JSON.stringify(key)}:${serialize(member)}`);
-        }
-        return `{${parts.join(',')}}`;
-    }
-    // undefined / function / symbol at the top level have no JSON representation.
-    throw new Error(`canonicalize: cannot serialize a value of type ${valueType}`);
-}
-/**
- * Produce the canonical JSON string for `value`.
- *
- * Deterministic: two structurally-equal values yield identical strings even if
- * their object keys were written in different orders. Use this — never an
- * ad-hoc `JSON.stringify` of a hand-sorted object — as the signing input for
- * signed records, so client signing and server verification cannot drift.
- *
- * @throws if `value` (or any nested member used as the top-level/primitive)
- *   contains a non-finite number or a `bigint`, which have no JSON form.
- */
-export function canonicalize(value) {
-    return serialize(value);
-}

package/dist/esm/utils/platformCrypto.js

@@ -1,125 +0,0 @@
-/**
- * Platform Crypto / Storage — Default Variant (Node.js, Browser, generic bundlers)
- *
- * Provides lazy access to platform-specific crypto and storage modules.
- *
- * # Variants
- *
- * This module ships in two physical variants on disk, selected per consumer
- * by the bundler / runtime:
- *
- * - `platformCrypto.js`           — this file. Used by Node.js, Vite, webpack,
- *                                   Rollup, esbuild, and anything that does
- *                                   not match Metro's `*.native.js`
- *                                   source-extension preference.
- * - `platformCrypto.native.js`    — sibling file. Picked up automatically by
- *                                   Metro's resolver (which prefers
- *                                   `*.<platform>.js` and `*.native.js` over
- *                                   plain `*.js` when `preferNativePlatform`
- *                                   is true — Expo sets this for all non-web
- *                                   builds).
- *
- * The `package.json#exports` map also declares a `"react-native"` condition
- * pointing at the same `dist/esm/index.js` entry — that entry transitively
- * imports `./platformCrypto`, and Metro's per-file source-extension lookup
- * substitutes the `.native.js` sibling automatically inside `dist/`. This
- * means consumers never have to add resolver shims; Metro Just Works.
- *
- * Both variants expose the EXACT same public API; importers don't need to know
- * which one they got. The variant difference is purely about which underlying
- * native modules each one references:
- *
- *   ┌──────────────────┬───────────────────────┬───────────────────────────────┐
- *   │ Function         │ Default variant       │ React Native variant          │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ loadNodeCrypto   │ `await import('crypto')` (Node built-in)              │
- *   │                  │                       │ throws — Node crypto is not   │
- *   │                  │                       │ available on Hermes/RN        │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ loadExpoCrypto   │ throws — expo-crypto  │ static `import 'expo-crypto'` │
- *   │                  │ is not part of a      │                               │
- *   │                  │ Node/Vite bundle      │                               │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ loadSecureStore  │ throws (web/Node have │ static `import 'expo-secure-` │
- *   │                  │ their own storage)    │ store'                        │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ loadAsyncStorage │ throws (web/Node have │ static `import '@react-       │
- *   │                  │ their own storage)    │ native-async-storage/...'     │
- *   ├──────────────────┼───────────────────────┼───────────────────────────────┤
- *   │ getRandomBytesRN │ throws (RN-only)      │ direct call into expo-crypto  │
- *   └──────────────────┴───────────────────────┴───────────────────────────────┘
- *
- * Crucially, the default variant references ONLY Node's `'crypto'`. It never
- * mentions `expo-*` or `@react-native-async-storage/*` — so Vite, webpack,
- * esbuild, Rollup, and Node itself can bundle / require it without ever
- * attempting to resolve those RN-only packages.
- *
- * The React Native variant references ONLY the RN packages. It never
- * mentions `'crypto'` — so Metro and Hermes have nothing to choke on.
- *
- * # Why not a single file with dynamic import?
- *
- * A previous iteration used a "bundler-opaque" `new Function('s', 'return
- * import(s)')` trick so a single file could service every platform. It
- * bundled cleanly on Metro but Hermes refused to PARSE the resulting
- * `import()` expression inside a Function-constructor body
- * (`SyntaxError: Invalid expression encountered` at the `(` of `import(`).
- * The platform-extension split is the only approach that lets each runtime
- * see a file containing only specifiers it can understand — no tricks, no
- * runtime parsing risks.
- */
-import { isReactNative } from './platform.js';
-// ---------------------------------------------------------------------------
-// Node `crypto` — Node built-in
-//
-// `await import('crypto')` here is a real, static-from-tsc's-perspective
-// dynamic import. Node ESM, Vite, webpack, and esbuild all resolve it fine.
-// Metro never sees this file because the `.react-native.js` sibling shadows
-// it, so Metro never tries to resolve `'crypto'`.
-// ---------------------------------------------------------------------------
-let cachedNodeCrypto = null;
-export async function loadNodeCrypto() {
-    if (cachedNodeCrypto) {
-        return cachedNodeCrypto;
-    }
-    cachedNodeCrypto = await import('node:crypto');
-    return cachedNodeCrypto;
-}
-// ---------------------------------------------------------------------------
-// RN-only modules — never called from this variant.
-//
-// These throw a clear error if anything ever reaches them outside RN. In
-// practice every caller gates with `isReactNative()` before calling, so
-// these are belt-and-braces.
-// ---------------------------------------------------------------------------
-function notReactNativeError(module) {
-    return new Error(`[oxy.platformCrypto] Tried to load '${module}' outside React Native. This module is only available in a React Native runtime; bundling routed this consumer to the default (Node/web) variant. This indicates a missing platform gate (\`isReactNative()\`) in the calling code.`);
-}
-export async function loadExpoCrypto() {
-    if (isReactNative()) {
-        // Should be unreachable: when running on RN, Metro / the `react-native`
-        // exports condition serves the sibling variant. If we got here, the
-        // package-exports map is misconfigured for this host. Throw with a
-        // helpful diagnostic rather than fall back to a broken dynamic import.
-        throw new Error('[oxy.platformCrypto] React Native runtime resolved the default ' +
-            '(non-RN) variant of @oxyhq/core/utils/platformCrypto. Check the ' +
-            "consumer's bundler resolution — Metro should pick the sibling " +
-            '.react-native.js file via package exports.');
-    }
-    throw notReactNativeError('expo-crypto');
-}
-export async function loadSecureStore() {
-    throw notReactNativeError('expo-secure-store');
-}
-export async function loadAsyncStorage() {
-    throw notReactNativeError('@react-native-async-storage/async-storage');
-}
-/**
- * Synchronous random-bytes via `expo-crypto.getRandomBytes`. Only available
- * in the React Native variant. The default variant throws because Node and
- * browsers have their own native CSPRNGs (`crypto.randomBytes` and
- * `crypto.getRandomValues` respectively) — callers should use those.
- */
-export function getRandomBytesRN(_byteCount) {
-    throw notReactNativeError('expo-crypto.getRandomBytes (sync)');
-}

package/dist/esm/utils/platformCrypto.native.js

@@ -1,80 +0,0 @@
-/**
- * Platform Crypto / Storage — React Native Variant
- *
- * Companion to `./platformCrypto.ts`. See the doc-comment at the top of that
- * file for the full design.
- *
- * Metro auto-selects this file in any non-web build (`preferNativePlatform`
- * is `true` for iOS / Android, so `*.native.js` shadows `*.js` during
- * source-extension resolution inside `node_modules/@oxyhq/core/dist/`). On
- * iOS / Android `<base>.ios.js` / `<base>.android.js` would shadow this file
- * if they existed, but they don't — `.native.js` is the shared RN variant.
- *
- *   - The default variant references Node's `'crypto'` and would crash Metro
- *     if bundled into an RN app.
- *   - This variant references the RN-only modules (`expo-crypto`,
- *     `expo-secure-store`, `@react-native-async-storage/async-storage`)
- *     as static imports, so Metro and Hermes both resolve and parse them
- *     cleanly.
- *
- * Both variants expose the same surface; importers don't care which one
- * they got.
- *
- * # Why static imports?
- *
- * Every RN consumer of `@oxyhq/core` already lists or transitively pulls
- * in `expo-crypto`, `expo-secure-store`, and
- * `@react-native-async-storage/async-storage` (they're stable Expo modules
- * present in `services`, `accounts`, `inbox`, and `test-app`). A static
- * import is what Metro wants to see anyway, and Hermes parses it like any
- * other ES module — no `Function`-constructor parser exotic-mode involved.
- *
- * This is also clearer to debug: Metro fails up-front with a normal
- * unresolved-module error if a consumer is missing a peer dep, instead of
- * a confusing runtime throw the first time a code path that needs the
- * module is exercised.
- */
-import * as ExpoCrypto from 'expo-crypto';
-import * as SecureStore from 'expo-secure-store';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-// ---------------------------------------------------------------------------
-// Node `crypto` — never available in RN.
-// ---------------------------------------------------------------------------
-export async function loadNodeCrypto() {
-    // Unreachable in practice: every caller gates with `isNodeJS()` before
-    // invoking this. If it somehow does fire, throw immediately with a clear
-    // diagnostic rather than letting Metro / Hermes attempt to find a
-    // non-existent module at runtime.
-    throw new Error("[oxy.platformCrypto] Node's built-in 'crypto' module is not available " +
-        'in a React Native runtime. Use the RN-specific helpers ' +
-        '(loadExpoCrypto, getRandomBytesRN) or the Web Crypto API (`globalThis.crypto`).');
-}
-// ---------------------------------------------------------------------------
-// expo-crypto — RN cryptographic primitives.
-// ---------------------------------------------------------------------------
-export async function loadExpoCrypto() {
-    return ExpoCrypto;
-}
-// ---------------------------------------------------------------------------
-// expo-secure-store — RN keychain / keystore.
-// ---------------------------------------------------------------------------
-export async function loadSecureStore() {
-    return SecureStore;
-}
-export async function loadAsyncStorage() {
-    // Mirror the shape callers historically used (`module.default.<method>`)
-    // so the call sites don't have to know whether the underlying module
-    // ships ESM or CJS-with-default.
-    const storage = AsyncStorage;
-    return {
-        default: storage,
-    };
-}
-/**
- * Synchronous random-bytes via `expo-crypto.getRandomBytes`. Available
- * synchronously because `expo-crypto` is statically imported by this file
- * — no async initialization race.
- */
-export function getRandomBytesRN(byteCount) {
-    return ExpoCrypto.getRandomBytes(byteCount);
-}

package/dist/types/crypto/canonicalJson.d.ts

@@ -1,44 +0,0 @@
-/**
- * Canonical JSON (RFC 8785 / JCS-style) serialization.
- *
- * `canonicalize(value)` produces a deterministic string for any JSON-compatible
- * value so that a client which SIGNS a record and a server which VERIFIES it
- * agree byte-for-byte on the signing input — regardless of the order in which
- * object keys happen to be written, how the value was deserialized, or which
- * runtime built it.
- *
- * This is the load-bearing primitive for the self-sovereign identity layer's
- * signed records (`SignatureService.signRecord` + the API's record-verify path):
- * both sides import THIS function from `@oxyhq/core`, so cross-implementation
- * number/string formatting differences cannot cause a verify mismatch.
- *
- * Rules (the JSON Canonicalization Scheme subset we need):
- *  - Objects: keys are sorted (ascending, by UTF-16 code unit — the default
- *    `Array.prototype.sort` order) and serialized recursively. Properties whose
- *    value is `undefined`, a function, or a symbol are OMITTED (matching
- *    `JSON.stringify` object semantics).
- *  - Arrays: element order is PRESERVED; `undefined`/function/symbol elements
- *    serialize to `null` (matching `JSON.stringify` array semantics).
- *  - `null`, booleans, strings, and finite numbers serialize via the standard
- *    JSON representation.
- *  - Values exposing a `toJSON()` method (e.g. `Date`) are replaced by its
- *    result first, then serialized — so a `Date` and its ISO-string equivalent
- *    canonicalize identically (the wire always carries the string form).
- *  - Non-finite numbers (`NaN`, `Infinity`) and `bigint` are not part of the
- *    JSON data model and throw, rather than silently producing `null`.
- *
- * Platform-agnostic — zero dependencies, no `require()`, no react/react-native/
- * expo. Safe in the dual CJS + ESM build.
- */
-/**
- * Produce the canonical JSON string for `value`.
- *
- * Deterministic: two structurally-equal values yield identical strings even if
- * their object keys were written in different orders. Use this — never an
- * ad-hoc `JSON.stringify` of a hand-sorted object — as the signing input for
- * signed records, so client signing and server verification cannot drift.
- *
- * @throws if `value` (or any nested member used as the top-level/primitive)
- *   contains a non-finite number or a `bigint`, which have no JSON form.
- */
-export declare function canonicalize(value: unknown): string;