@reallyme/crypto 0.1.0

package/dist/jwk.js

@@ -0,0 +1,289 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { p256 } from "@noble/curves/nist.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { ReallyMeCryptoError } from "./errors.js";
+const BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const DECODE_TABLE = new Map([...BASE64URL_ALPHABET].map((char, index) => [char, index]));
+const jwkSpec = (algorithm) => {
+    switch (algorithm) {
+        case "Ed25519":
+            return { alg: "EdDSA", crv: "Ed25519", kty: "OKP", publicKeyLength: 32, use: "sig" };
+        case "X25519":
+            return { alg: "ECDH-ES", crv: "X25519", kty: "OKP", publicKeyLength: 32, use: "enc" };
+        case "P-256":
+            return { alg: "ES256", crv: "P-256", kty: "EC", publicKeyLength: 33, use: "sig" };
+        case "secp256k1":
+            return { alg: "ES256K", crv: "secp256k1", kty: "EC", publicKeyLength: 33, use: "sig" };
+        case "ML-DSA-44":
+            return { alg: "ML-DSA-44", kty: "AKP", publicKeyLength: 1_312, use: "sig" };
+        case "ML-DSA-65":
+            return { alg: "ML-DSA-65", kty: "AKP", publicKeyLength: 1_952, use: "sig" };
+        case "ML-DSA-87":
+            return { alg: "ML-DSA-87", kty: "AKP", publicKeyLength: 2_592, use: "sig" };
+        case "ML-KEM-512":
+            return { alg: "ML-KEM-512", kty: "AKP", publicKeyLength: 800, use: "enc" };
+        case "ML-KEM-768":
+            return { alg: "ML-KEM-768", kty: "AKP", publicKeyLength: 1_184, use: "enc" };
+        case "ML-KEM-1024":
+            return { alg: "ML-KEM-1024", kty: "AKP", publicKeyLength: 1_568, use: "enc" };
+        case "SLH-DSA-SHA2-128s":
+            return { alg: "SLH-DSA-SHA2-128s", kty: "AKP", publicKeyLength: 32, use: "sig" };
+        case "X-Wing-768":
+            return { alg: "X-Wing-768", kty: "AKP", publicKeyLength: 1_216, use: "enc" };
+        case "X-Wing-1024":
+            return { alg: "X-Wing-1024", kty: "AKP", publicKeyLength: 1_600, use: "enc" };
+    }
+};
+const ensureLength = (bytes, expectedLength) => {
+    if (bytes.length !== expectedLength) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const byteAt = (bytes, index) => {
+    const value = bytes[index];
+    if (value === undefined) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    return value;
+};
+const base64urlEncode = (bytes) => {
+    let encoded = "";
+    let index = 0;
+    while (index < bytes.length) {
+        const first = byteAt(bytes, index);
+        const second = index + 1 < bytes.length ? byteAt(bytes, index + 1) : 0;
+        const third = index + 2 < bytes.length ? byteAt(bytes, index + 2) : 0;
+        const triple = (first << 16) | (second << 8) | third;
+        encoded += BASE64URL_ALPHABET[(triple >> 18) & 0x3f];
+        encoded += BASE64URL_ALPHABET[(triple >> 12) & 0x3f];
+        if (index + 1 < bytes.length) {
+            encoded += BASE64URL_ALPHABET[(triple >> 6) & 0x3f];
+        }
+        if (index + 2 < bytes.length) {
+            encoded += BASE64URL_ALPHABET[triple & 0x3f];
+        }
+        index += 3;
+    }
+    return encoded;
+};
+const decodeChar = (char) => {
+    const value = DECODE_TABLE.get(char);
+    if (value === undefined) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    return value;
+};
+const base64urlDecode = (encoded) => {
+    if (encoded.length % 4 === 1) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const outputLength = Math.floor((encoded.length * 6) / 8);
+    const output = new Uint8Array(outputLength);
+    let buffer = 0;
+    let bits = 0;
+    let offset = 0;
+    for (const char of encoded) {
+        buffer = (buffer << 6) | decodeChar(char);
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            output[offset] = (buffer >> bits) & 0xff;
+            offset += 1;
+        }
+    }
+    if (offset !== output.length) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    return output;
+};
+const readString = (value, name) => {
+    if (typeof value !== "object" || value === null) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const property = Reflect.get(value, name);
+    if (typeof property !== "string") {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    return property;
+};
+const optionalStringMatches = (value, name, expected) => {
+    if (typeof value !== "object" || value === null) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const property = Reflect.get(value, name);
+    if (property !== undefined && property !== expected) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const specFromCurve = (curve) => {
+    switch (curve) {
+        case "Ed25519":
+        case "X25519":
+        case "P-256":
+        case "secp256k1":
+            return jwkSpec(curve);
+        default:
+            throw new ReallyMeCryptoError("unsupported-algorithm");
+    }
+};
+const specFromAlgorithm = (algorithm) => {
+    switch (algorithm) {
+        case "ML-DSA-44":
+        case "ML-DSA-65":
+        case "ML-DSA-87":
+        case "ML-KEM-512":
+        case "ML-KEM-768":
+        case "ML-KEM-1024":
+        case "SLH-DSA-SHA2-128s":
+        case "X-Wing-768":
+        case "X-Wing-1024":
+            return jwkSpec(algorithm);
+        default:
+            throw new ReallyMeCryptoError("unsupported-algorithm");
+    }
+};
+const decompressEc = (algorithm, publicKey) => {
+    try {
+        const point = algorithm === "P-256"
+            ? p256.Point.fromBytes(publicKey)
+            : secp256k1.Point.fromBytes(publicKey);
+        return point.toBytes(false);
+    }
+    catch {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const compressEc = (algorithm, x, y) => {
+    ensureLength(x, 32);
+    ensureLength(y, 32);
+    const uncompressed = new Uint8Array(65);
+    uncompressed[0] = 0x04;
+    uncompressed.set(x, 1);
+    uncompressed.set(y, 33);
+    try {
+        const point = algorithm === "P-256"
+            ? p256.Point.fromBytes(uncompressed)
+            : secp256k1.Point.fromBytes(uncompressed);
+        return point.toBytes(true);
+    }
+    catch {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const toJcs = (jwk) => {
+    if (jwk.kty === "EC") {
+        return `{"alg":${JSON.stringify(jwk.alg)},"crv":${JSON.stringify(jwk.crv)},"kty":"EC","use":"sig","x":${JSON.stringify(jwk.x)},"y":${JSON.stringify(jwk.y)}}`;
+    }
+    if (jwk.kty === "AKP") {
+        return `{"alg":${JSON.stringify(jwk.alg)},"kty":"AKP","pub":${JSON.stringify(jwk.pub)},"use":${JSON.stringify(jwk.use)}}`;
+    }
+    return `{"alg":${JSON.stringify(jwk.alg)},"crv":${JSON.stringify(jwk.crv)},"kty":"OKP","use":${JSON.stringify(jwk.use)},"x":${JSON.stringify(jwk.x)}}`;
+};
+export const ReallyMeJwk = {
+    toJwk(algorithm, publicKey) {
+        const spec = jwkSpec(algorithm);
+        ensureLength(publicKey, spec.publicKeyLength);
+        if (spec.kty === "EC") {
+            const ecAlgorithm = spec.crv === "P-256" ? "P-256" : "secp256k1";
+            const uncompressed = decompressEc(ecAlgorithm, publicKey);
+            return {
+                alg: spec.alg,
+                crv: ecAlgorithm,
+                kty: "EC",
+                use: "sig",
+                x: base64urlEncode(uncompressed.slice(1, 33)),
+                y: base64urlEncode(uncompressed.slice(33, 65)),
+            };
+        }
+        if (spec.kty === "AKP") {
+            return {
+                alg: spec.alg,
+                kty: "AKP",
+                pub: base64urlEncode(publicKey),
+                use: spec.use,
+            };
+        }
+        const crv = spec.crv;
+        if (crv !== "Ed25519" && crv !== "X25519") {
+            throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+        return {
+            alg: spec.alg,
+            crv,
+            kty: "OKP",
+            use: spec.use,
+            x: base64urlEncode(publicKey),
+        };
+    },
+    fromJwk(value) {
+        const kty = readString(value, "kty");
+        const spec = kty === "AKP"
+            ? specFromAlgorithm(readString(value, "alg"))
+            : specFromCurve(readString(value, "crv"));
+        if (kty !== spec.kty) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        optionalStringMatches(value, "alg", spec.alg);
+        optionalStringMatches(value, "use", spec.use);
+        if (spec.kty === "EC") {
+            const ecAlgorithm = spec.crv === "P-256" ? "P-256" : "secp256k1";
+            const x = base64urlDecode(readString(value, "x"));
+            const y = base64urlDecode(readString(value, "y"));
+            const publicKey = compressEc(ecAlgorithm, x, y);
+            ensureLength(publicKey, spec.publicKeyLength);
+            const jwk = ReallyMeJwk.toJwk(ecAlgorithm, publicKey);
+            return { algorithm: ecAlgorithm, publicKey, jwk };
+        }
+        if (spec.kty === "OKP") {
+            const crv = spec.crv;
+            if (crv !== "Ed25519" && crv !== "X25519") {
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+            }
+            const publicKey = base64urlDecode(readString(value, "x"));
+            ensureLength(publicKey, spec.publicKeyLength);
+            const jwk = ReallyMeJwk.toJwk(crv, publicKey);
+            return { algorithm: crv, publicKey, jwk };
+        }
+        const algorithm = readString(value, "alg");
+        const akpSpec = specFromAlgorithm(algorithm);
+        const publicKey = base64urlDecode(readString(value, "pub"));
+        ensureLength(publicKey, akpSpec.publicKeyLength);
+        switch (algorithm) {
+            case "ML-DSA-44":
+            case "ML-DSA-65":
+            case "ML-DSA-87":
+            case "ML-KEM-512":
+            case "ML-KEM-768":
+            case "ML-KEM-1024":
+            case "SLH-DSA-SHA2-128s":
+            case "X-Wing-768":
+            case "X-Wing-1024": {
+                const jwk = ReallyMeJwk.toJwk(algorithm, publicKey);
+                return { algorithm, publicKey, jwk };
+            }
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    toJwks(keys) {
+        return { keys: [...keys] };
+    },
+    fromJwks(value) {
+        if (typeof value !== "object" || value === null) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        const keys = Reflect.get(value, "keys");
+        if (!Array.isArray(keys)) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        return { keys: keys.map((key) => ReallyMeJwk.fromJwk(key)) };
+    },
+    publicKeyBytes(jwk) {
+        return ReallyMeJwk.fromJwk(jwk).publicKey;
+    },
+    toJcs(jwk) {
+        return toJcs(jwk);
+    },
+};

package/dist/mlDsa.d.ts

@@ -0,0 +1,18 @@
+import type { ReallyMeSignatureAlgorithm } from "./algorithms.js";
+export declare const ML_DSA_44_PUBLIC_KEY_LENGTH = 1312;
+export declare const ML_DSA_44_SIGNATURE_LENGTH = 2420;
+export declare const ML_DSA_65_PUBLIC_KEY_LENGTH = 1952;
+export declare const ML_DSA_65_SIGNATURE_LENGTH = 3309;
+export declare const ML_DSA_87_PUBLIC_KEY_LENGTH = 2592;
+export declare const ML_DSA_87_SIGNATURE_LENGTH = 4627;
+export declare const ML_DSA_SECRET_KEY_LENGTH = 32;
+export type ReallyMeMlDsaKeyPair = Readonly<{
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}>;
+export declare const ReallyMeMlDsa: {
+    readonly generateKeyPair: (algorithm: ReallyMeSignatureAlgorithm) => ReallyMeMlDsaKeyPair;
+    readonly deriveKeyPair: (algorithm: ReallyMeSignatureAlgorithm, secretKey: Uint8Array) => ReallyMeMlDsaKeyPair;
+    readonly sign: (algorithm: ReallyMeSignatureAlgorithm, message: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+    readonly verify: (algorithm: ReallyMeSignatureAlgorithm, signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array) => void;
+};

package/dist/mlDsa.js

@@ -0,0 +1,85 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCryptoError } from "./errors.js";
+import { ensureBytes, readByteArrayProperty } from "./validateBytes.js";
+import { requireReallyMeWasmProvider } from "./wasmProvider.js";
+export const ML_DSA_44_PUBLIC_KEY_LENGTH = 1_312;
+export const ML_DSA_44_SIGNATURE_LENGTH = 2_420;
+export const ML_DSA_65_PUBLIC_KEY_LENGTH = 1_952;
+export const ML_DSA_65_SIGNATURE_LENGTH = 3_309;
+export const ML_DSA_87_PUBLIC_KEY_LENGTH = 2_592;
+export const ML_DSA_87_SIGNATURE_LENGTH = 4_627;
+export const ML_DSA_SECRET_KEY_LENGTH = 32;
+const mlDsaSuite = (algorithm) => {
+    const provider = requireReallyMeWasmProvider();
+    switch (algorithm) {
+        case "ML-DSA-44":
+            return {
+                publicKeyLength: ML_DSA_44_PUBLIC_KEY_LENGTH,
+                signatureLength: ML_DSA_44_SIGNATURE_LENGTH,
+                generateKeyPair: provider.mlDsa44GenerateKeypair,
+                deriveKeyPair: provider.mlDsa44DeriveKeypair,
+                sign: provider.mlDsa44Sign,
+                verify: provider.mlDsa44Verify,
+            };
+        case "ML-DSA-65":
+            return {
+                publicKeyLength: ML_DSA_65_PUBLIC_KEY_LENGTH,
+                signatureLength: ML_DSA_65_SIGNATURE_LENGTH,
+                generateKeyPair: provider.mlDsa65GenerateKeypair,
+                deriveKeyPair: provider.mlDsa65DeriveKeypair,
+                sign: provider.mlDsa65Sign,
+                verify: provider.mlDsa65Verify,
+            };
+        case "ML-DSA-87":
+            return {
+                publicKeyLength: ML_DSA_87_PUBLIC_KEY_LENGTH,
+                signatureLength: ML_DSA_87_SIGNATURE_LENGTH,
+                generateKeyPair: provider.mlDsa87GenerateKeypair,
+                deriveKeyPair: provider.mlDsa87DeriveKeypair,
+                sign: provider.mlDsa87Sign,
+                verify: provider.mlDsa87Verify,
+            };
+        default:
+            throw new ReallyMeCryptoError("unsupported-algorithm");
+    }
+};
+const readKeyPair = (value, suite) => ({
+    publicKey: readByteArrayProperty(value, "publicKey", suite.publicKeyLength),
+    secretKey: readByteArrayProperty(value, "secretKey", ML_DSA_SECRET_KEY_LENGTH),
+});
+const readSignature = (value, suite) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    ensureBytes(value, suite.signatureLength);
+    return value;
+};
+const readVoid = (value) => {
+    if (value !== undefined) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+};
+export const ReallyMeMlDsa = {
+    generateKeyPair(algorithm) {
+        const suite = mlDsaSuite(algorithm);
+        return readKeyPair(suite.generateKeyPair(), suite);
+    },
+    deriveKeyPair(algorithm, secretKey) {
+        const suite = mlDsaSuite(algorithm);
+        ensureBytes(secretKey, ML_DSA_SECRET_KEY_LENGTH);
+        return readKeyPair(suite.deriveKeyPair(secretKey), suite);
+    },
+    sign(algorithm, message, secretKey) {
+        const suite = mlDsaSuite(algorithm);
+        ensureBytes(secretKey, ML_DSA_SECRET_KEY_LENGTH);
+        return readSignature(suite.sign(secretKey, message), suite);
+    },
+    verify(algorithm, signature, message, publicKey) {
+        const suite = mlDsaSuite(algorithm);
+        ensureBytes(publicKey, suite.publicKeyLength);
+        ensureBytes(signature, suite.signatureLength);
+        readVoid(suite.verify(publicKey, message, signature));
+    },
+};

package/dist/mlKem.d.ts

@@ -0,0 +1,25 @@
+import type { ReallyMeKemAlgorithm } from "./algorithms.js";
+export declare const ML_KEM_512_PUBLIC_KEY_LENGTH = 800;
+export declare const ML_KEM_512_CIPHERTEXT_LENGTH = 768;
+export declare const ML_KEM_768_PUBLIC_KEY_LENGTH = 1184;
+export declare const ML_KEM_768_CIPHERTEXT_LENGTH = 1088;
+export declare const ML_KEM_1024_PUBLIC_KEY_LENGTH = 1568;
+export declare const ML_KEM_1024_CIPHERTEXT_LENGTH = 1568;
+export declare const ML_KEM_SECRET_KEY_LENGTH = 64;
+export declare const ML_KEM_ENCAPSULATION_RANDOMNESS_LENGTH = 32;
+export declare const ML_KEM_SHARED_SECRET_LENGTH = 32;
+export type ReallyMeMlKemKeyPair = Readonly<{
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}>;
+export type ReallyMeMlKemEncapsulation = Readonly<{
+    ciphertext: Uint8Array;
+    sharedSecret: Uint8Array;
+}>;
+export declare const ReallyMeMlKem: {
+    readonly generateKeyPair: (algorithm: ReallyMeKemAlgorithm) => ReallyMeMlKemKeyPair;
+    readonly deriveKeyPair: (algorithm: ReallyMeKemAlgorithm, secretKey: Uint8Array) => ReallyMeMlKemKeyPair;
+    readonly encapsulate: (algorithm: ReallyMeKemAlgorithm, publicKey: Uint8Array) => ReallyMeMlKemEncapsulation;
+    readonly encapsulateDeterministicallyForTest: (algorithm: ReallyMeKemAlgorithm, publicKey: Uint8Array, randomness: Uint8Array) => ReallyMeMlKemEncapsulation;
+    readonly decapsulate: (algorithm: ReallyMeKemAlgorithm, ciphertext: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+};

package/dist/mlKem.js

@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCryptoError } from "./errors.js";
+import { ensureBytes, readByteArrayProperty } from "./validateBytes.js";
+import { requireReallyMeWasmProvider } from "./wasmProvider.js";
+export const ML_KEM_512_PUBLIC_KEY_LENGTH = 800;
+export const ML_KEM_512_CIPHERTEXT_LENGTH = 768;
+export const ML_KEM_768_PUBLIC_KEY_LENGTH = 1_184;
+export const ML_KEM_768_CIPHERTEXT_LENGTH = 1_088;
+export const ML_KEM_1024_PUBLIC_KEY_LENGTH = 1_568;
+export const ML_KEM_1024_CIPHERTEXT_LENGTH = 1_568;
+export const ML_KEM_SECRET_KEY_LENGTH = 64;
+export const ML_KEM_ENCAPSULATION_RANDOMNESS_LENGTH = 32;
+export const ML_KEM_SHARED_SECRET_LENGTH = 32;
+const mlKemSuite = (algorithm) => {
+    const provider = requireReallyMeWasmProvider();
+    switch (algorithm) {
+        case "ML-KEM-512":
+            return {
+                publicKeyLength: ML_KEM_512_PUBLIC_KEY_LENGTH,
+                ciphertextLength: ML_KEM_512_CIPHERTEXT_LENGTH,
+                generateKeyPair: provider.mlKem512GenerateKeypair,
+                deriveKeyPair: provider.mlKem512DeriveKeypair,
+                encapsulate: provider.mlKem512Encapsulate,
+                encapsulateDerand: provider.mlKem512EncapsulateDerand,
+                decapsulate: provider.mlKem512Decapsulate,
+            };
+        case "ML-KEM-768":
+            return {
+                publicKeyLength: ML_KEM_768_PUBLIC_KEY_LENGTH,
+                ciphertextLength: ML_KEM_768_CIPHERTEXT_LENGTH,
+                generateKeyPair: provider.mlKem768GenerateKeypair,
+                deriveKeyPair: provider.mlKem768DeriveKeypair,
+                encapsulate: provider.mlKem768Encapsulate,
+                encapsulateDerand: provider.mlKem768EncapsulateDerand,
+                decapsulate: provider.mlKem768Decapsulate,
+            };
+        case "ML-KEM-1024":
+            return {
+                publicKeyLength: ML_KEM_1024_PUBLIC_KEY_LENGTH,
+                ciphertextLength: ML_KEM_1024_CIPHERTEXT_LENGTH,
+                generateKeyPair: provider.mlKem1024GenerateKeypair,
+                deriveKeyPair: provider.mlKem1024DeriveKeypair,
+                encapsulate: provider.mlKem1024Encapsulate,
+                encapsulateDerand: provider.mlKem1024EncapsulateDerand,
+                decapsulate: provider.mlKem1024Decapsulate,
+            };
+        default:
+            throw new ReallyMeCryptoError("unsupported-algorithm");
+    }
+};
+const readKeyPair = (value, suite) => ({
+    publicKey: readByteArrayProperty(value, "publicKey", suite.publicKeyLength),
+    secretKey: readByteArrayProperty(value, "secretKey", ML_KEM_SECRET_KEY_LENGTH),
+});
+const readEncapsulation = (value, suite) => ({
+    ciphertext: readByteArrayProperty(value, "ciphertext", suite.ciphertextLength),
+    sharedSecret: readByteArrayProperty(value, "sharedSecret", ML_KEM_SHARED_SECRET_LENGTH),
+});
+const readSharedSecret = (value) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    ensureBytes(value, ML_KEM_SHARED_SECRET_LENGTH);
+    return value;
+};
+export const ReallyMeMlKem = {
+    generateKeyPair(algorithm) {
+        const suite = mlKemSuite(algorithm);
+        return readKeyPair(suite.generateKeyPair(), suite);
+    },
+    deriveKeyPair(algorithm, secretKey) {
+        const suite = mlKemSuite(algorithm);
+        ensureBytes(secretKey, ML_KEM_SECRET_KEY_LENGTH);
+        return readKeyPair(suite.deriveKeyPair(secretKey), suite);
+    },
+    encapsulate(algorithm, publicKey) {
+        const suite = mlKemSuite(algorithm);
+        ensureBytes(publicKey, suite.publicKeyLength);
+        return readEncapsulation(suite.encapsulate(publicKey), suite);
+    },
+    encapsulateDeterministicallyForTest(algorithm, publicKey, randomness) {
+        const suite = mlKemSuite(algorithm);
+        ensureBytes(publicKey, suite.publicKeyLength);
+        ensureBytes(randomness, ML_KEM_ENCAPSULATION_RANDOMNESS_LENGTH);
+        return readEncapsulation(suite.encapsulateDerand(publicKey, randomness), suite);
+    },
+    decapsulate(algorithm, ciphertext, secretKey) {
+        const suite = mlKemSuite(algorithm);
+        ensureBytes(ciphertext, suite.ciphertextLength);
+        ensureBytes(secretKey, ML_KEM_SECRET_KEY_LENGTH);
+        return readSharedSecret(suite.decapsulate(ciphertext, secretKey));
+    },
+};

package/dist/p256Ecdh.d.ts

@@ -0,0 +1,22 @@
+/**
+ * P-256 ECDH backed by @noble/curves.
+ *
+ * Public keys at the SDK boundary are compressed SEC1. The primitive returns
+ * the raw 32-byte ECDH x-coordinate; protocols must apply their own labelled
+ * KDF rather than relying on this low-level helper to choose one.
+ */
+export declare const P256_ECDH_SECRET_KEY_LENGTH = 32;
+export declare const P256_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH = 33;
+export declare const P256_ECDH_SHARED_SECRET_LENGTH = 32;
+export declare const ReallyMeP256Ecdh: {
+    readonly generateKeyPair: () => {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    readonly deriveKeyPair: (secretKey: Uint8Array) => {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    readonly derivePublicKey: (secretKey: Uint8Array) => Uint8Array;
+    readonly deriveSharedSecret: (publicKey: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+};

package/dist/p256Ecdh.js

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { p256 } from "@noble/curves/nist.js";
+import { ReallyMeCryptoError } from "./errors.js";
+/**
+ * P-256 ECDH backed by @noble/curves.
+ *
+ * Public keys at the SDK boundary are compressed SEC1. The primitive returns
+ * the raw 32-byte ECDH x-coordinate; protocols must apply their own labelled
+ * KDF rather than relying on this low-level helper to choose one.
+ */
+export const P256_ECDH_SECRET_KEY_LENGTH = 32;
+export const P256_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH = 33;
+export const P256_ECDH_SHARED_SECRET_LENGTH = 32;
+export const ReallyMeP256Ecdh = {
+    generateKeyPair() {
+        const secretKey = p256.utils.randomSecretKey();
+        return {
+            publicKey: p256.getPublicKey(secretKey, true),
+            secretKey,
+        };
+    },
+    deriveKeyPair(secretKey) {
+        return {
+            publicKey: this.derivePublicKey(secretKey),
+            secretKey: secretKey.slice(),
+        };
+    },
+    derivePublicKey(secretKey) {
+        if (secretKey.length !== P256_ECDH_SECRET_KEY_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        try {
+            return p256.getPublicKey(secretKey, true);
+        }
+        catch {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+    },
+    deriveSharedSecret(publicKey, secretKey) {
+        if (publicKey.length !== P256_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH ||
+            secretKey.length !== P256_ECDH_SECRET_KEY_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        try {
+            return p256.getSharedSecret(secretKey, publicKey, false).slice(1, 33);
+        }
+        catch {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+    },
+};

package/dist/p256Ecdsa.d.ts

@@ -0,0 +1,25 @@
+export declare const P256_ECDSA_SECRET_KEY_LENGTH = 32;
+export declare const P256_ECDSA_COMPRESSED_PUBLIC_KEY_LENGTH = 33;
+export declare const P256_ECDSA_COMPACT_SIGNATURE_LENGTH = 64;
+export declare const P256_ECDSA_DER_SIGNATURE_MAX_LENGTH = 72;
+/**
+ * P-256 ECDSA backed by @noble/curves.
+ *
+ * The workspace contract signs SHA-256(message) exactly once and uses DER
+ * encoding for signatures because that is what X.509, JOSE, and the Rust
+ * P-256 lane expose. We intentionally preserve the Rust vector bytes instead
+ * of applying a TypeScript-only low-S normalization policy.
+ */
+export declare const ReallyMeP256Ecdsa: {
+    readonly generateKeyPair: () => {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    readonly deriveKeyPair: (secretKey: Uint8Array) => {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    readonly derivePublicKey: (secretKey: Uint8Array) => Uint8Array;
+    readonly sign: (message: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+    readonly verify: (signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array) => void;
+};