@reallyme/crypto 0.1.0

package/dist/codecs.js

@@ -0,0 +1,216 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCryptoError } from "./errors.js";
+import { requireReallyMeWasmProvider } from "./wasmProvider.js";
+const validTags = new Set([
+    "encryption",
+    "hash",
+    "key",
+    "multihash",
+    "multikey",
+]);
+const validKeyMaterialKinds = new Set([
+    "not-key",
+    "public-key",
+    "private-key",
+    "symmetric-key",
+]);
+const ensureStringInput = (value) => {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const ensureBytesInput = (value) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const requireObjectOutput = (value) => {
+    if (typeof value !== "object" || value === null) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return value;
+};
+const readStringOutput = (value) => {
+    if (typeof value !== "string") {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return value;
+};
+const readBytesOutput = (value) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return value;
+};
+const readStringProperty = (object, propertyName) => {
+    const property = Reflect.get(object, propertyName);
+    if (typeof property !== "string" || property.length === 0) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return property;
+};
+const readBooleanProperty = (object, propertyName) => {
+    const property = Reflect.get(object, propertyName);
+    if (typeof property !== "boolean") {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return property;
+};
+const readBytesProperty = (object, propertyName) => {
+    const property = Reflect.get(object, propertyName);
+    if (!(property instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return property;
+};
+const readOptionalLengthProperty = (object, propertyName) => {
+    const property = Reflect.get(object, propertyName);
+    if (property === undefined) {
+        return undefined;
+    }
+    if (typeof property !== "number" || !Number.isSafeInteger(property) || property < 0) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return property;
+};
+const readTagProperty = (object) => {
+    const tag = readStringProperty(object, "tag");
+    if (!validTags.has(tag)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    switch (tag) {
+        case "encryption":
+        case "hash":
+        case "key":
+        case "multihash":
+        case "multikey":
+            return tag;
+        default:
+            throw new ReallyMeCryptoError("provider-failure");
+    }
+};
+const readKeyMaterialProperty = (object) => {
+    const keyMaterial = readStringProperty(object, "keyMaterial");
+    if (!validKeyMaterialKinds.has(keyMaterial)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    switch (keyMaterial) {
+        case "not-key":
+        case "public-key":
+        case "private-key":
+        case "symmetric-key":
+            return keyMaterial;
+        default:
+            throw new ReallyMeCryptoError("provider-failure");
+    }
+};
+const readMulticodecMetadata = (value) => {
+    const object = requireObjectOutput(value);
+    const expectedKeyLength = readOptionalLengthProperty(object, "expectedKeyLength");
+    if (expectedKeyLength === undefined) {
+        return {
+            name: readStringProperty(object, "name"),
+            alg: readStringProperty(object, "alg"),
+            tag: readTagProperty(object),
+            keyMaterial: readKeyMaterialProperty(object),
+            prefix: readBytesProperty(object, "prefix"),
+        };
+    }
+    return {
+        name: readStringProperty(object, "name"),
+        alg: readStringProperty(object, "alg"),
+        tag: readTagProperty(object),
+        keyMaterial: readKeyMaterialProperty(object),
+        prefix: readBytesProperty(object, "prefix"),
+        expectedKeyLength,
+    };
+};
+const readParsedMultikey = (value) => {
+    const object = requireObjectOutput(value);
+    const expectedPublicKeyLength = readOptionalLengthProperty(object, "expectedPublicKeyLength");
+    if (expectedPublicKeyLength === undefined) {
+        return {
+            codecName: readStringProperty(object, "codecName"),
+            algorithmName: readStringProperty(object, "algorithmName"),
+            publicKey: readBytesProperty(object, "publicKey"),
+        };
+    }
+    return {
+        codecName: readStringProperty(object, "codecName"),
+        algorithmName: readStringProperty(object, "algorithmName"),
+        publicKey: readBytesProperty(object, "publicKey"),
+        expectedPublicKeyLength,
+    };
+};
+const readCidVerification = (value) => {
+    const object = requireObjectOutput(value);
+    return {
+        valid: readBooleanProperty(object, "valid"),
+        expectedCid: readStringProperty(object, "expectedCid"),
+        actualCid: readStringProperty(object, "actualCid"),
+    };
+};
+const asciiBytesToString = (bytes) => {
+    let value = "";
+    for (const byte of bytes) {
+        if (byte > 0x7f) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        value += String.fromCharCode(byte);
+    }
+    return value;
+};
+export const ReallyMeCodecs = {
+    base64urlEncode(bytes) {
+        ensureBytesInput(bytes);
+        return readStringOutput(requireReallyMeWasmProvider().base64urlEncode(bytes));
+    },
+    base64urlDecode(encoded) {
+        ensureStringInput(encoded);
+        return readBytesOutput(requireReallyMeWasmProvider().base64urlDecode(encoded));
+    },
+    base64urlDecodeBytes(encoded) {
+        ensureBytesInput(encoded);
+        return readBytesOutput(requireReallyMeWasmProvider().base64urlDecode(asciiBytesToString(encoded)));
+    },
+    multibaseBase64urlEncode(bytes) {
+        ensureBytesInput(bytes);
+        return readStringOutput(requireReallyMeWasmProvider().multibaseBase64urlEncode(bytes));
+    },
+    multibaseBase58btcEncode(bytes) {
+        ensureBytesInput(bytes);
+        return readStringOutput(requireReallyMeWasmProvider().multibaseBase58btcEncode(bytes));
+    },
+    multibaseDecode(encoded) {
+        ensureStringInput(encoded);
+        return readBytesOutput(requireReallyMeWasmProvider().multibaseDecode(encoded));
+    },
+    multicodecPrefixForName(codecName) {
+        ensureStringInput(codecName);
+        return readMulticodecMetadata(requireReallyMeWasmProvider().multicodecPrefixForName(codecName));
+    },
+    multicodecLookupPrefix(bytes) {
+        ensureBytesInput(bytes);
+        return readMulticodecMetadata(requireReallyMeWasmProvider().multicodecLookupPrefix(bytes));
+    },
+    multikeyEncode(codecName, publicKey) {
+        ensureStringInput(codecName);
+        ensureBytesInput(publicKey);
+        return readStringOutput(requireReallyMeWasmProvider().multikeyEncode(codecName, publicKey));
+    },
+    multikeyParse(multikey) {
+        ensureStringInput(multikey);
+        return readParsedMultikey(requireReallyMeWasmProvider().multikeyParse(multikey));
+    },
+    dagCborComputeCid(bytes) {
+        ensureBytesInput(bytes);
+        return readStringOutput(requireReallyMeWasmProvider().dagCborComputeCid(bytes));
+    },
+    dagCborVerifyCid(cid, bytes) {
+        ensureStringInput(cid);
+        ensureBytesInput(bytes);
+        return readCidVerification(requireReallyMeWasmProvider().dagCborVerifyCid(cid, bytes));
+    },
+};

package/dist/cryptoFacade.d.ts

@@ -0,0 +1,51 @@
+import type { ReallyMeAeadAlgorithm, ReallyMeHashAlgorithm, ReallyMeHpkeSuite, ReallyMeKdfAlgorithm, ReallyMeKemAlgorithm, ReallyMeKeyAgreementAlgorithm, ReallyMeKeyWrapAlgorithm, ReallyMeMacAlgorithm, ReallyMeSignatureAlgorithm } from "./algorithms.js";
+import type { ReallyMeRsaPublicKeyDerEncoding } from "./rsa.js";
+export type ReallyMeSignatureKeyPair = Readonly<{
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}>;
+export type ReallyMeKemKeyPair = Readonly<{
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}>;
+export type ReallyMeKeyAgreementKeyPair = Readonly<{
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}>;
+export type ReallyMeKemEncapsulation = Readonly<{
+    sharedSecret: Uint8Array;
+    ciphertext: Uint8Array;
+}>;
+export type ReallyMeHpkeSealedMessage = Readonly<{
+    encapsulatedKey: Uint8Array;
+    ciphertext: Uint8Array;
+}>;
+/**
+ * Generic package facade. Algorithm-specific objects remain available for
+ * callers that want direct provider access; this facade gives consumers a
+ * stable typed route that fails closed for not-yet-exposed algorithms.
+ */
+export declare const ReallyMeCrypto: {
+    readonly hash: (algorithm: ReallyMeHashAlgorithm, bytes: Uint8Array) => Uint8Array;
+    readonly seal: (algorithm: ReallyMeAeadAlgorithm, key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array) => Uint8Array;
+    readonly open: (algorithm: ReallyMeAeadAlgorithm, key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, ciphertextWithTag: Uint8Array) => Uint8Array;
+    readonly authenticate: (algorithm: ReallyMeMacAlgorithm, key: Uint8Array, message: Uint8Array) => Uint8Array;
+    readonly verifyMac: (algorithm: ReallyMeMacAlgorithm, tag: Uint8Array, key: Uint8Array, message: Uint8Array) => boolean;
+    readonly deriveKey: (algorithm: ReallyMeKdfAlgorithm, password: Uint8Array, salt: Uint8Array, iterations: number, outputLength: number) => Uint8Array;
+    readonly deriveHkdf: (algorithm: ReallyMeKdfAlgorithm, inputKeyMaterial: Uint8Array, salt: Uint8Array, info: Uint8Array, outputLength: number) => Uint8Array;
+    readonly wrapKey: (algorithm: ReallyMeKeyWrapAlgorithm, wrappingKey: Uint8Array, keyToWrap: Uint8Array) => Uint8Array;
+    readonly unwrapKey: (algorithm: ReallyMeKeyWrapAlgorithm, wrappingKey: Uint8Array, wrappedKey: Uint8Array) => Uint8Array;
+    readonly generateKeyPair: (algorithm: ReallyMeSignatureAlgorithm) => ReallyMeSignatureKeyPair;
+    readonly deriveKeyPair: (algorithm: ReallyMeSignatureAlgorithm, secretKey: Uint8Array) => ReallyMeSignatureKeyPair;
+    readonly sign: (algorithm: ReallyMeSignatureAlgorithm, message: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+    readonly signBip340Schnorr: (message32: Uint8Array, secretKey: Uint8Array, auxRand32: Uint8Array) => Uint8Array;
+    readonly verify: (algorithm: ReallyMeSignatureAlgorithm, signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array) => void;
+    readonly verifyRsa: (algorithm: ReallyMeSignatureAlgorithm, signature: Uint8Array, message: Uint8Array, publicKeyDer: Uint8Array, publicKeyEncoding: ReallyMeRsaPublicKeyDerEncoding) => void;
+    readonly deriveSharedSecret: (algorithm: ReallyMeKeyAgreementAlgorithm, publicKey: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+    readonly deriveKeyAgreementKeyPair: (algorithm: ReallyMeKeyAgreementAlgorithm, secretKey: Uint8Array) => ReallyMeKeyAgreementKeyPair;
+    readonly generateKemKeyPair: (algorithm: ReallyMeKemAlgorithm) => ReallyMeKemKeyPair;
+    readonly encapsulate: (algorithm: ReallyMeKemAlgorithm, publicKey: Uint8Array) => ReallyMeKemEncapsulation;
+    readonly decapsulate: (algorithm: ReallyMeKemAlgorithm, ciphertext: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+    readonly sealHpke: (suite: ReallyMeHpkeSuite, recipientPublicKey: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array) => ReallyMeHpkeSealedMessage;
+    readonly openHpke: (suite: ReallyMeHpkeSuite, recipientSecretKey: Uint8Array, encapsulatedKey: Uint8Array, info: Uint8Array, aad: Uint8Array, ciphertext: Uint8Array) => Uint8Array;
+};

package/dist/cryptoFacade.js

@@ -0,0 +1,329 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeAead } from "./aead.js";
+import { ReallyMeAesKw } from "./aesKw.js";
+import { ReallyMeArgon2id } from "./argon2id.js";
+import { ReallyMeBip340Schnorr } from "./bip340Schnorr.js";
+import { ReallyMeDigest } from "./digest.js";
+import { ReallyMeEd25519 } from "./ed25519.js";
+import { ReallyMeCryptoError } from "./errors.js";
+import { ReallyMeHkdf } from "./hkdf.js";
+import { ReallyMeHmac } from "./hmac.js";
+import { ReallyMeHpke } from "./hpke.js";
+import { ReallyMeMlDsa } from "./mlDsa.js";
+import { ReallyMeMlKem } from "./mlKem.js";
+import { ReallyMeP256Ecdsa } from "./p256Ecdsa.js";
+import { ReallyMeP256Ecdh } from "./p256Ecdh.js";
+import { ReallyMeP384Ecdsa } from "./p384Ecdsa.js";
+import { ReallyMeP521Ecdsa } from "./p521Ecdsa.js";
+import { ReallyMePbkdf2 } from "./pbkdf2.js";
+import { ReallyMeRsa } from "./rsa.js";
+import { ReallyMeSecp256k1 } from "./secp256k1.js";
+import { ReallyMeSlhDsa } from "./slhDsa.js";
+import { ReallyMeX25519 } from "./x25519.js";
+import { ReallyMeXWing } from "./xWing.js";
+const SECP256K1_ECDSA = "ECDSA-secp256k1-SHA256";
+const P256_ECDSA = "ECDSA-P256-SHA256";
+const P384_ECDSA = "ECDSA-P384-SHA384";
+const P521_ECDSA = "ECDSA-P521-SHA512";
+const BIP340_SCHNORR = "BIP340-Schnorr-secp256k1-SHA256";
+const ED25519 = "Ed25519";
+/**
+ * Generic package facade. Algorithm-specific objects remain available for
+ * callers that want direct provider access; this facade gives consumers a
+ * stable typed route that fails closed for not-yet-exposed algorithms.
+ */
+export const ReallyMeCrypto = {
+    hash(algorithm, bytes) {
+        switch (algorithm) {
+            case "SHA2-256":
+                return ReallyMeDigest.sha256(bytes);
+            case "SHA2-384":
+                return ReallyMeDigest.sha384(bytes);
+            case "SHA2-512":
+                return ReallyMeDigest.sha512(bytes);
+            case "SHA3-224":
+                return ReallyMeDigest.sha3_224(bytes);
+            case "SHA3-256":
+                return ReallyMeDigest.sha3_256(bytes);
+            case "SHA3-384":
+                return ReallyMeDigest.sha3_384(bytes);
+            case "SHA3-512":
+                return ReallyMeDigest.sha3_512(bytes);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    seal(algorithm, key, nonce, aad, plaintext) {
+        switch (algorithm) {
+            case "AES-256-GCM":
+            case "AES-256-GCM-SIV":
+            case "ChaCha20-Poly1305":
+            case "XChaCha20-Poly1305":
+                return ReallyMeAead.seal(algorithm, key, nonce, aad, plaintext);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    open(algorithm, key, nonce, aad, ciphertextWithTag) {
+        switch (algorithm) {
+            case "AES-256-GCM":
+            case "AES-256-GCM-SIV":
+            case "ChaCha20-Poly1305":
+            case "XChaCha20-Poly1305":
+                return ReallyMeAead.open(algorithm, key, nonce, aad, ciphertextWithTag);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    authenticate(algorithm, key, message) {
+        switch (algorithm) {
+            case "HMAC-SHA-256":
+                return ReallyMeHmac.authenticateSha256(key, message);
+            case "HMAC-SHA-512":
+                return ReallyMeHmac.authenticateSha512(key, message);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    verifyMac(algorithm, tag, key, message) {
+        switch (algorithm) {
+            case "HMAC-SHA-256":
+                return ReallyMeHmac.verifySha256(tag, key, message);
+            case "HMAC-SHA-512":
+                return ReallyMeHmac.verifySha512(tag, key, message);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    deriveKey(algorithm, password, salt, iterations, outputLength) {
+        switch (algorithm) {
+            case "Argon2id":
+                return ReallyMeArgon2id.deriveKey(iterations, password, salt);
+            case "PBKDF2-HMAC-SHA-256":
+                return ReallyMePbkdf2.deriveHmacSha256(password, salt, iterations, outputLength);
+            case "PBKDF2-HMAC-SHA-512":
+                return ReallyMePbkdf2.deriveHmacSha512(password, salt, iterations, outputLength);
+            case "HKDF-SHA256":
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    deriveHkdf(algorithm, inputKeyMaterial, salt, info, outputLength) {
+        switch (algorithm) {
+            case "HKDF-SHA256":
+                return ReallyMeHkdf.deriveSha256(inputKeyMaterial, salt, info, outputLength);
+            case "Argon2id":
+            case "PBKDF2-HMAC-SHA-256":
+            case "PBKDF2-HMAC-SHA-512":
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    wrapKey(algorithm, wrappingKey, keyToWrap) {
+        switch (algorithm) {
+            case "AES-256-KW":
+                return ReallyMeAesKw.wrapKey(wrappingKey, keyToWrap);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    unwrapKey(algorithm, wrappingKey, wrappedKey) {
+        switch (algorithm) {
+            case "AES-256-KW":
+                return ReallyMeAesKw.unwrapKey(wrappingKey, wrappedKey);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    generateKeyPair(algorithm) {
+        if (algorithm === ED25519) {
+            return ReallyMeEd25519.generateKeyPair();
+        }
+        switch (algorithm) {
+            case P256_ECDSA:
+                return ReallyMeP256Ecdsa.generateKeyPair();
+            case P384_ECDSA:
+                return ReallyMeP384Ecdsa.generateKeyPair();
+            case P521_ECDSA:
+                return ReallyMeP521Ecdsa.generateKeyPair();
+            case SECP256K1_ECDSA:
+                return ReallyMeSecp256k1.generateKeyPair();
+            case BIP340_SCHNORR:
+                return ReallyMeBip340Schnorr.generateKeyPair();
+            case "ML-DSA-44":
+            case "ML-DSA-65":
+            case "ML-DSA-87":
+                return ReallyMeMlDsa.generateKeyPair(algorithm);
+            case "SLH-DSA-SHA2-128s":
+                return ReallyMeSlhDsa.generateKeyPair(algorithm);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    deriveKeyPair(algorithm, secretKey) {
+        if (algorithm === ED25519) {
+            return ReallyMeEd25519.deriveKeyPair(secretKey);
+        }
+        switch (algorithm) {
+            case P256_ECDSA:
+                return ReallyMeP256Ecdsa.deriveKeyPair(secretKey);
+            case P384_ECDSA:
+                return ReallyMeP384Ecdsa.deriveKeyPair(secretKey);
+            case P521_ECDSA:
+                return ReallyMeP521Ecdsa.deriveKeyPair(secretKey);
+            case SECP256K1_ECDSA:
+                return ReallyMeSecp256k1.deriveKeyPair(secretKey);
+            case BIP340_SCHNORR:
+                return ReallyMeBip340Schnorr.deriveKeyPair(secretKey);
+            case "ML-DSA-44":
+            case "ML-DSA-65":
+            case "ML-DSA-87":
+                return ReallyMeMlDsa.deriveKeyPair(algorithm, secretKey);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    sign(algorithm, message, secretKey) {
+        if (algorithm === ED25519) {
+            return ReallyMeEd25519.sign(message, secretKey);
+        }
+        switch (algorithm) {
+            case P256_ECDSA:
+                return ReallyMeP256Ecdsa.sign(message, secretKey);
+            case P384_ECDSA:
+                return ReallyMeP384Ecdsa.sign(message, secretKey);
+            case P521_ECDSA:
+                return ReallyMeP521Ecdsa.sign(message, secretKey);
+            case SECP256K1_ECDSA:
+                return ReallyMeSecp256k1.sign(message, secretKey);
+            case "ML-DSA-44":
+            case "ML-DSA-65":
+            case "ML-DSA-87":
+                return ReallyMeMlDsa.sign(algorithm, message, secretKey);
+            case "SLH-DSA-SHA2-128s":
+                return ReallyMeSlhDsa.sign(algorithm, message, secretKey);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    signBip340Schnorr(message32, secretKey, auxRand32) {
+        return ReallyMeBip340Schnorr.sign(message32, secretKey, auxRand32);
+    },
+    verify(algorithm, signature, message, publicKey) {
+        if (algorithm === ED25519) {
+            ReallyMeEd25519.verify(signature, message, publicKey);
+            return;
+        }
+        switch (algorithm) {
+            case P256_ECDSA:
+                ReallyMeP256Ecdsa.verify(signature, message, publicKey);
+                return;
+            case P384_ECDSA:
+                ReallyMeP384Ecdsa.verify(signature, message, publicKey);
+                return;
+            case P521_ECDSA:
+                ReallyMeP521Ecdsa.verify(signature, message, publicKey);
+                return;
+            case SECP256K1_ECDSA:
+                ReallyMeSecp256k1.verify(signature, message, publicKey);
+                return;
+            case BIP340_SCHNORR:
+                ReallyMeBip340Schnorr.verify(signature, message, publicKey);
+                return;
+            case "ML-DSA-44":
+            case "ML-DSA-65":
+            case "ML-DSA-87":
+                ReallyMeMlDsa.verify(algorithm, signature, message, publicKey);
+                return;
+            case "SLH-DSA-SHA2-128s":
+                ReallyMeSlhDsa.verify(algorithm, signature, message, publicKey);
+                return;
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    verifyRsa(algorithm, signature, message, publicKeyDer, publicKeyEncoding) {
+        ReallyMeRsa.verify(algorithm, signature, message, publicKeyDer, publicKeyEncoding);
+    },
+    deriveSharedSecret(algorithm, publicKey, secretKey) {
+        switch (algorithm) {
+            case "X25519":
+                return ReallyMeX25519.deriveSharedSecret(publicKey, secretKey);
+            case "P-256-ECDH":
+                return ReallyMeP256Ecdh.deriveSharedSecret(publicKey, secretKey);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    deriveKeyAgreementKeyPair(algorithm, secretKey) {
+        switch (algorithm) {
+            case "X25519":
+                return ReallyMeX25519.deriveKeyPair(secretKey);
+            case "P-256-ECDH":
+                return ReallyMeP256Ecdh.deriveKeyPair(secretKey);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    generateKemKeyPair(algorithm) {
+        switch (algorithm) {
+            case "X-Wing-768":
+            case "X-Wing-1024":
+                return ReallyMeXWing.generateKeyPair(algorithm);
+            case "ML-KEM-512":
+            case "ML-KEM-768":
+            case "ML-KEM-1024":
+                return ReallyMeMlKem.generateKeyPair(algorithm);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    encapsulate(algorithm, publicKey) {
+        switch (algorithm) {
+            case "X-Wing-768":
+            case "X-Wing-1024":
+                return ReallyMeXWing.encapsulate(algorithm, publicKey);
+            case "ML-KEM-512":
+            case "ML-KEM-768":
+            case "ML-KEM-1024":
+                return ReallyMeMlKem.encapsulate(algorithm, publicKey);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    decapsulate(algorithm, ciphertext, secretKey) {
+        switch (algorithm) {
+            case "X-Wing-768":
+            case "X-Wing-1024":
+                return ReallyMeXWing.decapsulate(algorithm, ciphertext, secretKey);
+            case "ML-KEM-512":
+            case "ML-KEM-768":
+            case "ML-KEM-1024":
+                return ReallyMeMlKem.decapsulate(algorithm, ciphertext, secretKey);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    sealHpke(suite, recipientPublicKey, info, aad, plaintext) {
+        switch (suite) {
+            case "DHKEM-P256-HKDF-SHA256-HKDF-SHA256-AES-256-GCM":
+            case "DHKEM-X25519-HKDF-SHA256-HKDF-SHA256-CHACHA20-POLY1305":
+                return ReallyMeHpke.sealBase(suite, recipientPublicKey, info, aad, plaintext);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    openHpke(suite, recipientSecretKey, encapsulatedKey, info, aad, ciphertext) {
+        switch (suite) {
+            case "DHKEM-P256-HKDF-SHA256-HKDF-SHA256-AES-256-GCM":
+            case "DHKEM-X25519-HKDF-SHA256-HKDF-SHA256-CHACHA20-POLY1305":
+                return ReallyMeHpke.openBase(suite, recipientSecretKey, encapsulatedKey, info, aad, ciphertext);
+            default:
+                throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+};

package/dist/digest.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Small digest surface used by package tests and as the first package API
+ * slice while algorithm wrappers are added one at a time. Mirrors the Swift
+ * package's `ReallyMeDigest` and the Kotlin package's `ReallyMeDigest`.
+ */
+export declare const ReallyMeDigest: {
+    readonly sha256: (bytes: Uint8Array) => Uint8Array;
+    readonly sha384: (bytes: Uint8Array) => Uint8Array;
+    readonly sha512: (bytes: Uint8Array) => Uint8Array;
+    readonly sha3_224: (bytes: Uint8Array) => Uint8Array;
+    readonly sha3_256: (bytes: Uint8Array) => Uint8Array;
+    readonly sha3_384: (bytes: Uint8Array) => Uint8Array;
+    readonly sha3_512: (bytes: Uint8Array) => Uint8Array;
+};

package/dist/digest.js

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { sha256 as nobleSha256, sha384 as nobleSha384, sha512 as nobleSha512 } from "@noble/hashes/sha2.js";
+import { sha3_224 as nobleSha3_224, sha3_256 as nobleSha3_256, sha3_384 as nobleSha3_384, sha3_512 as nobleSha3_512, } from "@noble/hashes/sha3.js";
+/**
+ * Small digest surface used by package tests and as the first package API
+ * slice while algorithm wrappers are added one at a time. Mirrors the Swift
+ * package's `ReallyMeDigest` and the Kotlin package's `ReallyMeDigest`.
+ */
+export const ReallyMeDigest = {
+    sha256(bytes) {
+        return nobleSha256(bytes);
+    },
+    sha384(bytes) {
+        return nobleSha384(bytes);
+    },
+    sha512(bytes) {
+        return nobleSha512(bytes);
+    },
+    sha3_224(bytes) {
+        return nobleSha3_224(bytes);
+    },
+    sha3_256(bytes) {
+        return nobleSha3_256(bytes);
+    },
+    sha3_384(bytes) {
+        return nobleSha3_384(bytes);
+    },
+    sha3_512(bytes) {
+        return nobleSha3_512(bytes);
+    },
+};

package/dist/ed25519.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Ed25519 signatures backed by @noble/curves — the same pinned implementation
+ * the TypeScript conformance lane proves vectors against.
+ *
+ * The workspace contract uses the plain Ed25519 variant: callers pass the full
+ * message, the provider signs that message directly, and signatures are the
+ * 64-byte RFC 8032 encoding. Ed25519 is deterministic, so the same key and
+ * message must produce the same bytes in every platform lane.
+ */
+export declare const ED25519_SECRET_KEY_LENGTH = 32;
+export declare const ED25519_PUBLIC_KEY_LENGTH = 32;
+export declare const ED25519_SIGNATURE_LENGTH = 64;
+export declare const ReallyMeEd25519: {
+    /** Generates a random Ed25519 keypair: 32-byte public key, 32-byte seed. */
+    readonly generateKeyPair: () => {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    /** Derives the Ed25519 keypair from a 32-byte seed. */
+    readonly deriveKeyPair: (secretKey: Uint8Array) => {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    /** Derives the 32-byte Ed25519 public key from a 32-byte seed. */
+    readonly derivePublicKey: (secretKey: Uint8Array) => Uint8Array;
+    /** Signs the full message using plain deterministic Ed25519. */
+    readonly sign: (message: Uint8Array, secretKey: Uint8Array) => Uint8Array;
+    /**
+     * Verifies a 64-byte Ed25519 signature against a 32-byte public key.
+     *
+     * Throws on malformed input shape, undecodable keys, or invalid signatures.
+     */
+    readonly verify: (signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array) => void;
+};