@oxyhq/core 4.0.1 → 5.0.0

package/dist/types/utils/platformCrypto.d.ts

@@ -1,87 +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.
- */
-export declare function loadNodeCrypto(): Promise<typeof import('crypto')>;
-export declare function loadExpoCrypto(): Promise<typeof import('expo-crypto')>;
-export declare function loadSecureStore(): Promise<typeof import('expo-secure-store')>;
-export declare function loadAsyncStorage(): Promise<{
-    default: {
-        getItem: (key: string) => Promise<string | null>;
-        setItem: (key: string, value: string) => Promise<void>;
-        removeItem: (key: string) => Promise<void>;
-    };
-}>;
-/**
- * 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 declare function getRandomBytesRN(_byteCount: number): Uint8Array;

package/dist/types/utils/platformCrypto.native.d.ts

@@ -1,54 +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.
- */
-export declare function loadNodeCrypto(): Promise<typeof import('crypto')>;
-export declare function loadExpoCrypto(): Promise<typeof import('expo-crypto')>;
-export declare function loadSecureStore(): Promise<typeof import('expo-secure-store')>;
-type AsyncStorageLike = {
-    getItem: (key: string) => Promise<string | null>;
-    setItem: (key: string, value: string) => Promise<void>;
-    removeItem: (key: string) => Promise<void>;
-};
-export declare function loadAsyncStorage(): Promise<{
-    default: AsyncStorageLike;
-}>;
-/**
- * Synchronous random-bytes via `expo-crypto.getRandomBytes`. Available
- * synchronously because `expo-crypto` is statically imported by this file
- * — no async initialization race.
- */
-export declare function getRandomBytesRN(byteCount: number): Uint8Array;
-export {};

package/src/crypto/__tests__/canonicalJson.test.ts

@@ -1,116 +0,0 @@
-/**
- * Canonical JSON tests.
- *
- * The whole point of `canonicalize` is that two structurally-equal values
- * produce identical strings regardless of how their keys were ordered, so a
- * client which signs and a server which verifies agree on the signing input.
- * These tests pin that determinism, the array-order guarantee, the nesting
- * behaviour, and the JSON value/omit semantics.
- */
-
-import { canonicalize } from '../canonicalJson';
-
-describe('canonicalize', () => {
-  describe('object key ordering', () => {
-    it('produces identical output regardless of insertion order', () => {
-      const a = canonicalize({ b: 1, a: 2, c: 3 });
-      const b = canonicalize({ c: 3, a: 2, b: 1 });
-      const c = canonicalize({ a: 2, b: 1, c: 3 });
-      expect(a).toBe(b);
-      expect(b).toBe(c);
-      expect(a).toBe('{"a":2,"b":1,"c":3}');
-    });
-
-    it('sorts keys recursively at every level', () => {
-      const value = {
-        z: { y: 1, x: 2 },
-        a: { c: 3, b: { e: 5, d: 4 } },
-      };
-      expect(canonicalize(value)).toBe(
-        '{"a":{"b":{"d":4,"e":5},"c":3},"z":{"x":2,"y":1}}',
-      );
-    });
-
-    it('is order-insensitive across deep nesting', () => {
-      const first = canonicalize({
-        outer: { inner: { p: 1, q: 2 }, lead: 'x' },
-        meta: { issuedAt: 10, version: 1 },
-      });
-      const second = canonicalize({
-        meta: { version: 1, issuedAt: 10 },
-        outer: { lead: 'x', inner: { q: 2, p: 1 } },
-      });
-      expect(first).toBe(second);
-    });
-  });
-
-  describe('array ordering', () => {
-    it('preserves array element order (never sorts arrays)', () => {
-      expect(canonicalize([3, 1, 2])).toBe('[3,1,2]');
-      expect(canonicalize(['b', 'a', 'c'])).toBe('["b","a","c"]');
-    });
-
-    it('distinguishes arrays that differ only in order', () => {
-      expect(canonicalize([1, 2])).not.toBe(canonicalize([2, 1]));
-    });
-
-    it('canonicalizes objects inside arrays without reordering the array', () => {
-      const value = [
-        { b: 1, a: 2 },
-        { d: 3, c: 4 },
-      ];
-      expect(canonicalize(value)).toBe('[{"a":2,"b":1},{"c":4,"d":3}]');
-    });
-  });
-
-  describe('primitives', () => {
-    it('serializes null, booleans, strings and numbers as JSON', () => {
-      expect(canonicalize(null)).toBe('null');
-      expect(canonicalize(true)).toBe('true');
-      expect(canonicalize(false)).toBe('false');
-      expect(canonicalize('hi')).toBe('"hi"');
-      expect(canonicalize(42)).toBe('42');
-      expect(canonicalize(-1.5)).toBe('-1.5');
-      expect(canonicalize(0)).toBe('0');
-    });
-
-    it('escapes strings the same way JSON does', () => {
-      expect(canonicalize('a"b\\c\n')).toBe(JSON.stringify('a"b\\c\n'));
-    });
-  });
-
-  describe('JSON value/omit semantics', () => {
-    it('omits object properties whose value is undefined', () => {
-      expect(canonicalize({ a: 1, b: undefined, c: 3 })).toBe('{"a":1,"c":3}');
-    });
-
-    it('renders undefined array elements as null (preserving length)', () => {
-      expect(canonicalize([1, undefined, 3])).toBe('[1,null,3]');
-    });
-
-    it('respects toJSON (Date and its ISO string canonicalize identically)', () => {
-      const date = new Date('2026-06-26T00:00:00.000Z');
-      expect(canonicalize(date)).toBe(JSON.stringify(date.toISOString()));
-      expect(canonicalize({ at: date })).toBe(
-        canonicalize({ at: '2026-06-26T00:00:00.000Z' }),
-      );
-    });
-  });
-
-  describe('rejects values outside the JSON data model', () => {
-    it('throws on non-finite numbers', () => {
-      expect(() => canonicalize(NaN)).toThrow();
-      expect(() => canonicalize(Infinity)).toThrow();
-      expect(() => canonicalize({ x: Infinity })).toThrow();
-    });
-
-    it('throws on bigint', () => {
-      expect(() => canonicalize(BigInt(1))).toThrow();
-    });
-
-    it('throws on a bare undefined / function at the top level', () => {
-      expect(() => canonicalize(undefined)).toThrow();
-      expect(() => canonicalize(() => 1)).toThrow();
-    });
-  });
-});

package/src/crypto/canonicalJson.ts

@@ -1,120 +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.
- */
-
-/** Object exposing a `toJSON()` serialization hook (e.g. `Date`). */
-interface ToJsonable {
-  toJSON: () => unknown;
-}
-
-function hasToJSON(value: object): value is ToJsonable {
-  return typeof (value as { toJSON?: unknown }).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: unknown): string {
-  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 as object;
-    if (hasToJSON(obj)) {
-      return serialize(obj.toJSON());
-    }
-
-    const record = obj as Record<string, unknown>;
-    const parts: string[] = [];
-    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: unknown): string {
-  return serialize(value);
-}

package/src/utils/platformCrypto.native.ts

@@ -1,101 +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(): Promise<typeof import('crypto')> {
-  // 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(): Promise<typeof import('expo-crypto')> {
-  return ExpoCrypto;
-}
-
-// ---------------------------------------------------------------------------
-// expo-secure-store — RN keychain / keystore.
-// ---------------------------------------------------------------------------
-
-export async function loadSecureStore(): Promise<typeof import('expo-secure-store')> {
-  return SecureStore;
-}
-
-// ---------------------------------------------------------------------------
-// @react-native-async-storage/async-storage — RN persistent KV storage.
-// ---------------------------------------------------------------------------
-
-type AsyncStorageLike = {
-  getItem: (key: string) => Promise<string | null>;
-  setItem: (key: string, value: string) => Promise<void>;
-  removeItem: (key: string) => Promise<void>;
-};
-
-export async function loadAsyncStorage(): Promise<{ default: AsyncStorageLike }> {
-  // 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 as unknown as AsyncStorageLike;
-  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: number): Uint8Array {
-  return ExpoCrypto.getRandomBytes(byteCount);
-}

package/src/utils/platformCrypto.ts

@@ -1,145 +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';
-
-// ---------------------------------------------------------------------------
-// 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: typeof import('crypto') | null = null;
-
-export async function loadNodeCrypto(): Promise<typeof import('crypto')> {
-  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: string): Error {
-  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(): Promise<typeof import('expo-crypto')> {
-  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(): Promise<typeof import('expo-secure-store')> {
-  throw notReactNativeError('expo-secure-store');
-}
-
-export async function loadAsyncStorage(): Promise<{
-  default: {
-    getItem: (key: string) => Promise<string | null>;
-    setItem: (key: string, value: string) => Promise<void>;
-    removeItem: (key: string) => Promise<void>;
-  };
-}> {
-  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: number): Uint8Array {
-  throw notReactNativeError('expo-crypto.getRandomBytes (sync)');
-}