@symbiote-native/standard-web-crypto 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# @symbiote-native/standard-web-crypto
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-standard-web-crypto`](https://github.com/expo/expo/tree/main/packages/expo-standard-web-crypto)
+— a partial W3C [Web Crypto API](https://www.w3.org/TR/WebCryptoAPI/) polyfill exposing
+`crypto.getRandomValues` — usable from **every** adapter, React, Vue, and Angular, not just React.
+Unlike this repo's other Expo ports, this package needs **no native module of its own** — upstream
+is a ~15-line pure-JS shim that delegates straight to `expo-crypto`'s own `getRandomValues`; this
+port delegates to [`@symbiote-native/crypto`](../crypto)'s `getRandomValues` instead, since this
+repo already ships that native random source as a sibling package. Like `@symbiote-native/crypto`,
+every export here is a plain function/object with no per-instance state or event stream, so there
+is no hook/composable/service to wrap — the React, Vue, and Angular entry points are plain
+re-exports of the same `core`.
+
+## Install
+
+```bash
+npm install @symbiote-native/standard-web-crypto @symbiote-native/crypto
+```
+
+`@symbiote-native/crypto` comes along as a regular dependency and does the actual native random-byte
+generation — see [its README](../crypto/README.md) for `expo-crypto`'s own native autolinking
+requirements (already satisfied in any app that already wires up `@symbiote-native/crypto` or
+`@symbiote-native/device`).
+
+No further native wiring is needed for this package itself — it has no native module of its own.
+
+## Shape
+
+```
+src/core/     web-crypto.ts — the Crypto class + webCrypto singleton (default export) and
+              polyfillWebCrypto(), delegating to @symbiote-native/crypto's getRandomValues.
+src/react/    @symbiote-native/standard-web-crypto/react   — export * from '../core'
+src/vue/      @symbiote-native/standard-web-crypto/vue     — export * from '../core'
+src/angular/  @symbiote-native/standard-web-crypto/angular — export * from '../core'
+```
+
+No per-adapter lifecycle wrapper exists because there's nothing to subscribe to or clean up —
+each adapter entry is a single-file re-export.
+
+## Use it
+
+```ts
+import webCrypto, { polyfillWebCrypto } from '@symbiote-native/standard-web-crypto';
+
+// Reach the polyfill (or a real globalThis.crypto, if one already exists) directly:
+const bytes = new Uint8Array(16);
+webCrypto.getRandomValues(bytes);
+
+// Or install it as globalThis.crypto for any library that expects the Web Crypto API to
+// already be present — a no-op if globalThis.crypto is already defined:
+polyfillWebCrypto();
+crypto.getRandomValues(bytes);
+```
+
+The React/Vue/Angular entry points re-export the identical surface:
+
+```ts
+import webCrypto, { polyfillWebCrypto } from '@symbiote-native/standard-web-crypto/react';
+import webCrypto, { polyfillWebCrypto } from '@symbiote-native/standard-web-crypto/vue';
+import webCrypto, { polyfillWebCrypto } from '@symbiote-native/standard-web-crypto/angular';
+```
+
+## API
+
+```ts
+const webCrypto: {
+  getRandomValues<TArray extends ArrayBufferView>(values: TArray): TArray;
+};
+export default webCrypto;
+
+function polyfillWebCrypto(): void;
+```
+
+Plus the `IWebCrypto` type describing the shape above.
+
+## Notes
+
+- **`webCrypto` is resolved once, at module-load time**: if `globalThis.crypto` already exists
+  (a real Web Crypto implementation), `webCrypto` *is* that object; otherwise it's this package's
+  own `Crypto` class instance backed by `@symbiote-native/crypto`. React Native has no reliable
+  `window` global, so this port checks/defines `globalThis.crypto` rather than upstream's `window`.
+- **`getRandomValues` only accepts the integer TypedArrays `@symbiote-native/crypto` can hand to
+  its native module** (`Int8Array`/`Uint8Array`/`Int16Array`/`Uint16Array`/`Int32Array`/
+  `Uint32Array`) — passing any other `ArrayBufferView` (a `DataView`, `Uint8ClampedArray`, a
+  `Float32Array`, …) throws a `TypeError`, the same way upstream's own `getRandomValues` rejects an
+  unsupported view.
+- `polyfillWebCrypto()` is a no-op when `globalThis.crypto` is already defined — it never
+  overwrites an existing implementation.
+
+## Test it
+
+Every export here is a pure function/object surface, never a view or per-instance state — no
+Fabric/Descriptor angle at all. Tests mock `@symbiote-native/crypto`'s `getRandomValues` directly
+(`src/core/web-crypto.test.ts`, `vitest`) — no `installFabric()`, no ViewConfig.

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { default as webCrypto } from '../core';

package/build/angular/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/standard-web-crypto/angular: the Angular entry over the framework-agnostic
+// core. Same reasoning as the React/Vue entries — no per-instance state or event stream to wrap in
+// a service, so this is a plain re-export. `export *` never forwards a default export (ES module
+// semantics), so `webCrypto` needs its own explicit named re-export alongside it.
+export * from '../core';
+export { default as webCrypto } from '../core';

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { default, polyfillWebCrypto } from './web-crypto';
+export type { IWebCrypto } from './web-crypto';

package/build/core/index.js

@@ -0,0 +1 @@
+export { default, polyfillWebCrypto } from './web-crypto';

package/build/core/web-crypto.d.ts

@@ -0,0 +1,6 @@
+export type IWebCrypto = {
+    getRandomValues<TArray extends ArrayBufferView>(values: TArray): TArray;
+};
+declare const webCrypto: IWebCrypto;
+export default webCrypto;
+export declare function polyfillWebCrypto(): void;

package/build/core/web-crypto.js

@@ -0,0 +1,53 @@
+// Ported from expo-standard-web-crypto (upstream: packages/expo-standard-web-crypto/src/index.ts,
+// verified identical on origin/main and origin/sdk-57) — a partial W3C Web Crypto API polyfill
+// exposing `crypto.getRandomValues`. Upstream delegates to expo-crypto's own getRandomValues; this
+// port delegates to @symbiote-native/crypto's getRandomValues instead, which already wraps the
+// same native random source, so there is no native call left to re-wrap here. React Native has no
+// reliable `window` global, so `globalThis` replaces every `window`/bare `crypto` reference
+// upstream used.
+import { getRandomValues as getNativeRandomValues } from '@symbiote-native/crypto';
+// @symbiote-native/crypto's getRandomValues only accepts the integer TypedArrays it can hand to
+// the native module (ITypedArray) — narrower than the W3C spec's ArrayBufferView. This guard
+// narrows the incoming view at the one call site that needs it, so the class below can still
+// expose the full ArrayBufferView-typed method the upstream Crypto class does.
+function isSupportedTypedArray(value) {
+    return (value instanceof Int8Array ||
+        value instanceof Uint8Array ||
+        value instanceof Int16Array ||
+        value instanceof Uint16Array ||
+        value instanceof Int32Array ||
+        value instanceof Uint32Array);
+}
+class Crypto {
+    getRandomValues(values) {
+        if (!isSupportedTypedArray(values)) {
+            throw new TypeError('The provided ArrayBuffer view is not a supported integer-typed array');
+        }
+        return getNativeRandomValues(values);
+    }
+}
+function isWebCrypto(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return 'getRandomValues' in value && typeof value.getRandomValues === 'function';
+}
+// No ambient `declare global { var crypto }` here on purpose — it would collide with lib.dom.d.ts's
+// own `crypto` global the moment any consumer's tsconfig pulls in the DOM lib (as this package's
+// own Angular build does), producing a duplicate-declaration error. Reflect.get sidesteps that:
+// it reads an untyped global property without asserting one into existence.
+function readGlobalCrypto() {
+    const value = Reflect.get(globalThis, 'crypto');
+    return isWebCrypto(value) ? value : undefined;
+}
+const webCrypto = readGlobalCrypto() ?? new Crypto();
+export default webCrypto;
+export function polyfillWebCrypto() {
+    if (readGlobalCrypto() === undefined) {
+        Object.defineProperty(globalThis, 'crypto', {
+            configurable: true,
+            enumerable: true,
+            get: () => webCrypto,
+        });
+    }
+}

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { default as webCrypto } from '../core';

package/build/react/index.js

@@ -0,0 +1,7 @@
+// @symbiote-native/standard-web-crypto/react: the React entry over the framework-agnostic core.
+// The polyfill has no per-instance state or event stream — nothing for a hook to wrap — so this
+// is a plain re-export, mirroring @symbiote-native/device's and @symbiote-native/crypto's React
+// entries. `export *` never forwards a default export (ES module semantics), so `webCrypto` needs
+// its own explicit named re-export alongside it.
+export * from '../core';
+export { default as webCrypto } from '../core';

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { default as webCrypto } from '../core';

package/build/vue/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/standard-web-crypto/vue: the Vue entry over the framework-agnostic core. Same
+// reasoning as the React entry — no per-instance state or event stream to wire onto Vue's
+// reactivity, so this is a plain re-export. `export *` never forwards a default export (ES module
+// semantics), so `webCrypto` needs its own explicit named re-export alongside it.
+export * from '../core';
+export { default as webCrypto } from '../core';

package/build-ngc/angular/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { default as webCrypto } from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,7 @@
+// @symbiote-native/standard-web-crypto/angular: the Angular entry over the framework-agnostic
+// core. Same reasoning as the React/Vue entries — no per-instance state or event stream to wrap in
+// a service, so this is a plain re-export. `export *` never forwards a default export (ES module
+// semantics), so `webCrypto` needs its own explicit named re-export alongside it.
+export * from '../core';
+export { default as webCrypto } from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,mGAAmG;AACnG,iGAAiG;AACjG,kFAAkF;AAClF,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,SAAS,CAAC"}

package/build-ngc/core/index.d.ts

@@ -0,0 +1,2 @@
+export { default, polyfillWebCrypto } from './web-crypto';
+export type { IWebCrypto } from './web-crypto';

package/build-ngc/core/index.js

@@ -0,0 +1,2 @@
+export { default, polyfillWebCrypto } from './web-crypto';
+//# sourceMappingURL=index.js.map

package/build-ngc/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC"}

package/build-ngc/core/web-crypto.d.ts

@@ -0,0 +1,6 @@
+export type IWebCrypto = {
+    getRandomValues<TArray extends ArrayBufferView>(values: TArray): TArray;
+};
+declare const webCrypto: IWebCrypto;
+export default webCrypto;
+export declare function polyfillWebCrypto(): void;

package/build-ngc/core/web-crypto.js

@@ -0,0 +1,54 @@
+// Ported from expo-standard-web-crypto (upstream: packages/expo-standard-web-crypto/src/index.ts,
+// verified identical on origin/main and origin/sdk-57) — a partial W3C Web Crypto API polyfill
+// exposing `crypto.getRandomValues`. Upstream delegates to expo-crypto's own getRandomValues; this
+// port delegates to @symbiote-native/crypto's getRandomValues instead, which already wraps the
+// same native random source, so there is no native call left to re-wrap here. React Native has no
+// reliable `window` global, so `globalThis` replaces every `window`/bare `crypto` reference
+// upstream used.
+import { getRandomValues as getNativeRandomValues } from '@symbiote-native/crypto';
+// @symbiote-native/crypto's getRandomValues only accepts the integer TypedArrays it can hand to
+// the native module (ITypedArray) — narrower than the W3C spec's ArrayBufferView. This guard
+// narrows the incoming view at the one call site that needs it, so the class below can still
+// expose the full ArrayBufferView-typed method the upstream Crypto class does.
+function isSupportedTypedArray(value) {
+    return (value instanceof Int8Array ||
+        value instanceof Uint8Array ||
+        value instanceof Int16Array ||
+        value instanceof Uint16Array ||
+        value instanceof Int32Array ||
+        value instanceof Uint32Array);
+}
+class Crypto {
+    getRandomValues(values) {
+        if (!isSupportedTypedArray(values)) {
+            throw new TypeError('The provided ArrayBuffer view is not a supported integer-typed array');
+        }
+        return getNativeRandomValues(values);
+    }
+}
+function isWebCrypto(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return 'getRandomValues' in value && typeof value.getRandomValues === 'function';
+}
+// No ambient `declare global { var crypto }` here on purpose — it would collide with lib.dom.d.ts's
+// own `crypto` global the moment any consumer's tsconfig pulls in the DOM lib (as this package's
+// own Angular build does), producing a duplicate-declaration error. Reflect.get sidesteps that:
+// it reads an untyped global property without asserting one into existence.
+function readGlobalCrypto() {
+    const value = Reflect.get(globalThis, 'crypto');
+    return isWebCrypto(value) ? value : undefined;
+}
+const webCrypto = readGlobalCrypto() ?? new Crypto();
+export default webCrypto;
+export function polyfillWebCrypto() {
+    if (readGlobalCrypto() === undefined) {
+        Object.defineProperty(globalThis, 'crypto', {
+            configurable: true,
+            enumerable: true,
+            get: () => webCrypto,
+        });
+    }
+}
+//# sourceMappingURL=web-crypto.js.map

package/build-ngc/core/web-crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-crypto.js","sourceRoot":"","sources":["../../src/core/web-crypto.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,+FAA+F;AAC/F,mGAAmG;AACnG,+FAA+F;AAC/F,kGAAkG;AAClG,4FAA4F;AAC5F,iBAAiB;AACjB,OAAO,EAAE,eAAe,IAAI,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAOnF,gGAAgG;AAChG,6FAA6F;AAC7F,6FAA6F;AAC7F,+EAA+E;AAC/E,SAAS,qBAAqB,CAAC,KAAsB;IACnD,OAAO,CACL,KAAK,YAAY,SAAS;QAC1B,KAAK,YAAY,UAAU;QAC3B,KAAK,YAAY,UAAU;QAC3B,KAAK,YAAY,WAAW;QAC5B,KAAK,YAAY,UAAU;QAC3B,KAAK,YAAY,WAAW,CAC7B,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;IACV,eAAe,CAAiC,MAAc;QAC5D,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,SAAS,CAAC,sEAAsE,CAAC,CAAC;QAC9F,CAAC;QACD,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;CACF;AAED,SAAS,WAAW,CAAC,KAAc;IACjC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,iBAAiB,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,eAAe,KAAK,UAAU,CAAC;AACnF,CAAC;AAED,oGAAoG;AACpG,iGAAiG;AACjG,gGAAgG;AAChG,4EAA4E;AAC5E,SAAS,gBAAgB;IACvB,MAAM,KAAK,GAAY,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACzD,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AAChD,CAAC;AAED,MAAM,SAAS,GAAe,gBAAgB,EAAE,IAAI,IAAI,MAAM,EAAE,CAAC;AAEjE,eAAe,SAAS,CAAC;AAEzB,MAAM,UAAU,iBAAiB;IAC/B,IAAI,gBAAgB,EAAE,KAAK,SAAS,EAAE,CAAC;QACrC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,QAAQ,EAAE;YAC1C,YAAY,EAAE,IAAI;YAClB,UAAU,EAAE,IAAI;YAChB,GAAG,EAAE,GAAG,EAAE,CAAC,SAAS;SACrB,CAAC,CAAC;IACL,CAAC;AACH,CAAC"}

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@symbiote-native/standard-web-crypto",
+  "version": "0.0.1",
+  "description": "expo-standard-web-crypto ported for SymbioteNative — a Web Crypto API getRandomValues polyfill built on @symbiote-native/crypto's native random source.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/standard-web-crypto"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/standard-web-crypto#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@symbiote-native/crypto": "0.0.1"
+  },
+  "peerDependencies": {
+    "@symbiote-native/engine": ">=0.1.7",
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "vue": ">=3.5.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22",
+    "@angular/compiler-cli": "^22",
+    "@angular/core": "^22",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "typescript": "~6.0.0",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/engine": "0.1.7",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/standard-web-crypto/angular: the Angular entry over the framework-agnostic
+// core. Same reasoning as the React/Vue entries — no per-instance state or event stream to wrap in
+// a service, so this is a plain re-export. `export *` never forwards a default export (ES module
+// semantics), so `webCrypto` needs its own explicit named re-export alongside it.
+export * from '../core';
+export { default as webCrypto } from '../core';

package/src/core/index.ts

@@ -0,0 +1,2 @@
+export { default, polyfillWebCrypto } from './web-crypto';
+export type { IWebCrypto } from './web-crypto';

package/src/core/web-crypto.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const getRandomValues = vi.fn((typedArray: Uint8Array) => {
+  typedArray.fill(7);
+  return typedArray;
+});
+
+// @symbiote-native/crypto resolves the real native module via requireNativeModule() at import
+// time, which would throw in this headless test run — faked here in place of the sibling
+// package, the same pattern packages/crypto/src/core/crypto.test.ts uses for expo-modules-core.
+vi.mock('@symbiote-native/crypto', () => ({
+  getRandomValues,
+}));
+
+// Node (unlike React Native) ships its own native `globalThis.crypto` — deleted before every test
+// so `web-crypto.ts`'s module-load-time feature detection sees the same "no crypto global" state
+// it would on-device, not Node's own WebCrypto implementation.
+beforeEach(() => {
+  Reflect.deleteProperty(globalThis, 'crypto');
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+  Reflect.deleteProperty(globalThis, 'crypto');
+  vi.resetModules();
+});
+
+describe('webCrypto.getRandomValues', () => {
+  it('delegates a supported typed array to @symbiote-native/crypto', async () => {
+    const { default: webCrypto } = await import('./web-crypto');
+    const typedArray = new Uint8Array(4);
+
+    const result = webCrypto.getRandomValues(typedArray);
+
+    expect(result).toBe(typedArray);
+    expect(getRandomValues).toHaveBeenCalledWith(typedArray);
+    expect(Array.from(typedArray)).toEqual([7, 7, 7, 7]);
+  });
+
+  it('throws a TypeError for a view outside the supported integer TypedArrays', async () => {
+    const { default: webCrypto } = await import('./web-crypto');
+
+    expect(() => webCrypto.getRandomValues(new DataView(new ArrayBuffer(4)))).toThrow(TypeError);
+    expect(getRandomValues).not.toHaveBeenCalled();
+  });
+});
+
+describe('webCrypto singleton', () => {
+  it('is the polyfill instance when globalThis.crypto is absent', async () => {
+    const { default: webCrypto } = await import('./web-crypto');
+
+    expect(typeof webCrypto.getRandomValues).toBe('function');
+  });
+
+  it('reuses an existing globalThis.crypto instead of the polyfill', async () => {
+    const existingCrypto = { getRandomValues: vi.fn() };
+    Object.defineProperty(globalThis, 'crypto', {
+      configurable: true,
+      value: existingCrypto,
+    });
+
+    const { default: webCrypto } = await import('./web-crypto');
+
+    expect(webCrypto).toBe(existingCrypto);
+  });
+});
+
+describe('polyfillWebCrypto', () => {
+  it('defines globalThis.crypto when it is absent', async () => {
+    const { default: webCrypto, polyfillWebCrypto } = await import('./web-crypto');
+
+    expect(Reflect.get(globalThis, 'crypto')).toBeUndefined();
+
+    polyfillWebCrypto();
+
+    expect(Reflect.get(globalThis, 'crypto')).toBe(webCrypto);
+  });
+
+  it('does not overwrite an existing globalThis.crypto', async () => {
+    const existingCrypto = { getRandomValues: vi.fn() };
+    Object.defineProperty(globalThis, 'crypto', {
+      configurable: true,
+      value: existingCrypto,
+    });
+
+    const { polyfillWebCrypto } = await import('./web-crypto');
+    polyfillWebCrypto();
+
+    expect(Reflect.get(globalThis, 'crypto')).toBe(existingCrypto);
+  });
+});

package/src/core/web-crypto.ts

@@ -0,0 +1,67 @@
+// Ported from expo-standard-web-crypto (upstream: packages/expo-standard-web-crypto/src/index.ts,
+// verified identical on origin/main and origin/sdk-57) — a partial W3C Web Crypto API polyfill
+// exposing `crypto.getRandomValues`. Upstream delegates to expo-crypto's own getRandomValues; this
+// port delegates to @symbiote-native/crypto's getRandomValues instead, which already wraps the
+// same native random source, so there is no native call left to re-wrap here. React Native has no
+// reliable `window` global, so `globalThis` replaces every `window`/bare `crypto` reference
+// upstream used.
+import { getRandomValues as getNativeRandomValues } from '@symbiote-native/crypto';
+import type { ITypedArray } from '@symbiote-native/crypto';
+
+export type IWebCrypto = {
+  getRandomValues<TArray extends ArrayBufferView>(values: TArray): TArray;
+};
+
+// @symbiote-native/crypto's getRandomValues only accepts the integer TypedArrays it can hand to
+// the native module (ITypedArray) — narrower than the W3C spec's ArrayBufferView. This guard
+// narrows the incoming view at the one call site that needs it, so the class below can still
+// expose the full ArrayBufferView-typed method the upstream Crypto class does.
+function isSupportedTypedArray(value: ArrayBufferView): value is ITypedArray {
+  return (
+    value instanceof Int8Array ||
+    value instanceof Uint8Array ||
+    value instanceof Int16Array ||
+    value instanceof Uint16Array ||
+    value instanceof Int32Array ||
+    value instanceof Uint32Array
+  );
+}
+
+class Crypto implements IWebCrypto {
+  getRandomValues<TArray extends ArrayBufferView>(values: TArray): TArray {
+    if (!isSupportedTypedArray(values)) {
+      throw new TypeError('The provided ArrayBuffer view is not a supported integer-typed array');
+    }
+    return getNativeRandomValues(values);
+  }
+}
+
+function isWebCrypto(value: unknown): value is IWebCrypto {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  return 'getRandomValues' in value && typeof value.getRandomValues === 'function';
+}
+
+// No ambient `declare global { var crypto }` here on purpose — it would collide with lib.dom.d.ts's
+// own `crypto` global the moment any consumer's tsconfig pulls in the DOM lib (as this package's
+// own Angular build does), producing a duplicate-declaration error. Reflect.get sidesteps that:
+// it reads an untyped global property without asserting one into existence.
+function readGlobalCrypto(): IWebCrypto | undefined {
+  const value: unknown = Reflect.get(globalThis, 'crypto');
+  return isWebCrypto(value) ? value : undefined;
+}
+
+const webCrypto: IWebCrypto = readGlobalCrypto() ?? new Crypto();
+
+export default webCrypto;
+
+export function polyfillWebCrypto(): void {
+  if (readGlobalCrypto() === undefined) {
+    Object.defineProperty(globalThis, 'crypto', {
+      configurable: true,
+      enumerable: true,
+      get: () => webCrypto,
+    });
+  }
+}

package/src/react/index.ts

@@ -0,0 +1,7 @@
+// @symbiote-native/standard-web-crypto/react: the React entry over the framework-agnostic core.
+// The polyfill has no per-instance state or event stream — nothing for a hook to wrap — so this
+// is a plain re-export, mirroring @symbiote-native/device's and @symbiote-native/crypto's React
+// entries. `export *` never forwards a default export (ES module semantics), so `webCrypto` needs
+// its own explicit named re-export alongside it.
+export * from '../core';
+export { default as webCrypto } from '../core';

package/src/vue/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/standard-web-crypto/vue: the Vue entry over the framework-agnostic core. Same
+// reasoning as the React entry — no per-instance state or event stream to wire onto Vue's
+// reactivity, so this is a plain re-export. `export *` never forwards a default export (ES module
+// semantics), so `webCrypto` needs its own explicit named re-export alongside it.
+export * from '../core';
+export { default as webCrypto } from '../core';