@reallyme/crypto 0.1.0

package/dist/ed25519.js

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { ReallyMeCryptoError } from "./errors.js";
+/**
+ * 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 const ED25519_SECRET_KEY_LENGTH = 32;
+export const ED25519_PUBLIC_KEY_LENGTH = 32;
+export const ED25519_SIGNATURE_LENGTH = 64;
+export const ReallyMeEd25519 = {
+    /** Generates a random Ed25519 keypair: 32-byte public key, 32-byte seed. */
+    generateKeyPair() {
+        const secretKey = ed25519.utils.randomSecretKey();
+        return {
+            publicKey: ed25519.getPublicKey(secretKey),
+            secretKey,
+        };
+    },
+    /** Derives the Ed25519 keypair from a 32-byte seed. */
+    deriveKeyPair(secretKey) {
+        return {
+            publicKey: this.derivePublicKey(secretKey),
+            secretKey: secretKey.slice(),
+        };
+    },
+    /** Derives the 32-byte Ed25519 public key from a 32-byte seed. */
+    derivePublicKey(secretKey) {
+        if (secretKey.length !== ED25519_SECRET_KEY_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        try {
+            return ed25519.getPublicKey(secretKey);
+        }
+        catch {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+    },
+    /** Signs the full message using plain deterministic Ed25519. */
+    sign(message, secretKey) {
+        if (secretKey.length !== ED25519_SECRET_KEY_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        try {
+            return ed25519.sign(message, secretKey);
+        }
+        catch {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+    },
+    /**
+     * Verifies a 64-byte Ed25519 signature against a 32-byte public key.
+     *
+     * Throws on malformed input shape, undecodable keys, or invalid signatures.
+     */
+    verify(signature, message, publicKey) {
+        if (signature.length !== ED25519_SIGNATURE_LENGTH ||
+            publicKey.length !== ED25519_PUBLIC_KEY_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        try {
+            ed25519.Point.fromBytes(publicKey, false);
+        }
+        catch {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        if (!ed25519.verify(signature, message, publicKey, { zip215: false })) {
+            throw new ReallyMeCryptoError("invalid-signature");
+        }
+    },
+};

package/dist/encodeEcdsaDer.d.ts

@@ -0,0 +1,2 @@
+export declare const encodeEcdsaDerSignature: (compactSignature: Uint8Array, componentLength: number) => Uint8Array;
+export declare const decodeEcdsaDerSignature: (signature: Uint8Array, componentLength: number, maxDerLength: number) => Uint8Array;

package/dist/encodeEcdsaDer.js

@@ -0,0 +1,141 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCryptoError } from "./errors.js";
+const DER_SEQUENCE_TAG = 0x30;
+const DER_INTEGER_TAG = 0x02;
+const DER_SHORT_FORM_LIMIT = 0x7f;
+const DER_LONG_FORM_ONE_BYTE = 0x81;
+const byteAt = (bytes, index) => {
+    const value = bytes[index];
+    if (value === undefined) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    return value;
+};
+const isAllZero = (bytes) => {
+    for (const byte of bytes) {
+        if (byte !== 0) {
+            return false;
+        }
+    }
+    return true;
+};
+const derIntegerContent = (component) => {
+    let firstNonZero = 0;
+    while (firstNonZero < component.length - 1 &&
+        byteAt(component, firstNonZero) === 0) {
+        firstNonZero += 1;
+    }
+    const stripped = component.slice(firstNonZero);
+    if ((byteAt(stripped, 0) & 0x80) === 0) {
+        return stripped;
+    }
+    const prefixed = new Uint8Array(stripped.length + 1);
+    prefixed.set(stripped, 1);
+    return prefixed;
+};
+const sequenceHeaderLength = (payloadLength) => {
+    if (payloadLength <= DER_SHORT_FORM_LIMIT) {
+        return 2;
+    }
+    if (payloadLength <= 0xff) {
+        return 3;
+    }
+    throw new ReallyMeCryptoError("invalid-input");
+};
+const writeSequenceHeader = (der, payloadLength) => {
+    der[0] = DER_SEQUENCE_TAG;
+    if (payloadLength <= DER_SHORT_FORM_LIMIT) {
+        der[1] = payloadLength;
+        return 2;
+    }
+    der[1] = DER_LONG_FORM_ONE_BYTE;
+    der[2] = payloadLength;
+    return 3;
+};
+const readSequenceHeader = (signature) => {
+    if (byteAt(signature, 0) !== DER_SEQUENCE_TAG) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const firstLengthByte = byteAt(signature, 1);
+    if ((firstLengthByte & 0x80) === 0) {
+        if (firstLengthByte !== signature.length - 2) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        return 2;
+    }
+    if (firstLengthByte !== DER_LONG_FORM_ONE_BYTE ||
+        signature.length < 3 ||
+        byteAt(signature, 2) <= DER_SHORT_FORM_LIMIT ||
+        byteAt(signature, 2) !== signature.length - 3) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    return 3;
+};
+const parseDerInteger = (der, offset, componentLength) => {
+    if (byteAt(der, offset) !== DER_INTEGER_TAG) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const length = byteAt(der, offset + 1);
+    if (length === 0 || length > componentLength + 1) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const start = offset + 2;
+    const end = start + length;
+    if (end > der.length) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const content = der.slice(start, end);
+    const first = byteAt(content, 0);
+    if ((first & 0x80) !== 0) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    if (content.length > 1 && first === 0) {
+        const second = byteAt(content, 1);
+        if ((second & 0x80) === 0) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+    }
+    const normalized = first === 0 ? content.slice(1) : content;
+    if (normalized.length > componentLength || isAllZero(normalized)) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const value = new Uint8Array(componentLength);
+    value.set(normalized, componentLength - normalized.length);
+    return { value, nextOffset: end };
+};
+export const encodeEcdsaDerSignature = (compactSignature, componentLength) => {
+    if (compactSignature.length !== componentLength * 2) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const r = derIntegerContent(compactSignature.slice(0, componentLength));
+    const s = derIntegerContent(compactSignature.slice(componentLength));
+    const payloadLength = 2 + r.length + 2 + s.length;
+    const headerLength = sequenceHeaderLength(payloadLength);
+    const der = new Uint8Array(headerLength + payloadLength);
+    const firstIntegerOffset = writeSequenceHeader(der, payloadLength);
+    der[firstIntegerOffset] = DER_INTEGER_TAG;
+    der[firstIntegerOffset + 1] = r.length;
+    der.set(r, firstIntegerOffset + 2);
+    const secondIntegerOffset = firstIntegerOffset + 2 + r.length;
+    der[secondIntegerOffset] = DER_INTEGER_TAG;
+    der[secondIntegerOffset + 1] = s.length;
+    der.set(s, secondIntegerOffset + 2);
+    return der;
+};
+export const decodeEcdsaDerSignature = (signature, componentLength, maxDerLength) => {
+    if (signature.length < 8 || signature.length > maxDerLength) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const firstIntegerOffset = readSequenceHeader(signature);
+    const r = parseDerInteger(signature, firstIntegerOffset, componentLength);
+    const s = parseDerInteger(signature, r.nextOffset, componentLength);
+    if (s.nextOffset !== signature.length) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+    const compact = new Uint8Array(componentLength * 2);
+    compact.set(r.value, 0);
+    compact.set(s.value, componentLength);
+    return compact;
+};

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Typed SDK error codes. Errors intentionally carry no secret or
+ * user-provided bytes so callers can log them without leaking key material
+ * or PII.
+ */
+export type ReallyMeCryptoErrorCode = "invalid-input" | "invalid-signature" | "provider-failure" | "unsupported-algorithm";
+export declare class ReallyMeCryptoError extends Error {
+    readonly code: ReallyMeCryptoErrorCode;
+    constructor(code: ReallyMeCryptoErrorCode);
+}

package/dist/errors.js

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+export class ReallyMeCryptoError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.name = "ReallyMeCryptoError";
+        this.code = code;
+    }
+}

package/dist/hkdf.d.ts

@@ -0,0 +1,7 @@
+export declare const HKDF_MIN_INPUT_KEY_MATERIAL_LENGTH = 1;
+export declare const HKDF_MAX_INPUT_LENGTH = 4096;
+export declare const HKDF_MIN_OUTPUT_LENGTH = 1;
+export declare const HKDF_MAX_OUTPUT_LENGTH = 4096;
+export declare const ReallyMeHkdf: {
+    readonly deriveSha256: (inputKeyMaterial: Uint8Array, salt: Uint8Array, info: Uint8Array, outputLength: number) => Uint8Array;
+};

package/dist/hkdf.js

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { hkdf } from "@noble/hashes/hkdf.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { ReallyMeCryptoError } from "./errors.js";
+export const HKDF_MIN_INPUT_KEY_MATERIAL_LENGTH = 1;
+export const HKDF_MAX_INPUT_LENGTH = 4096;
+export const HKDF_MIN_OUTPUT_LENGTH = 1;
+export const HKDF_MAX_OUTPUT_LENGTH = 4096;
+export const ReallyMeHkdf = {
+    deriveSha256(inputKeyMaterial, salt, info, outputLength) {
+        validate(inputKeyMaterial, salt, info, outputLength);
+        return hkdf(sha256, inputKeyMaterial, salt, info, outputLength);
+    },
+};
+function validate(inputKeyMaterial, salt, info, outputLength) {
+    if (inputKeyMaterial.length < HKDF_MIN_INPUT_KEY_MATERIAL_LENGTH ||
+        inputKeyMaterial.length > HKDF_MAX_INPUT_LENGTH ||
+        salt.length > HKDF_MAX_INPUT_LENGTH ||
+        info.length > HKDF_MAX_INPUT_LENGTH ||
+        !Number.isInteger(outputLength) ||
+        outputLength < HKDF_MIN_OUTPUT_LENGTH ||
+        outputLength > HKDF_MAX_OUTPUT_LENGTH) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+}

package/dist/hmac.d.ts

@@ -0,0 +1,9 @@
+export declare const HMAC_MAX_KEY_LENGTH = 4096;
+export declare const HMAC_SHA256_TAG_LENGTH = 32;
+export declare const HMAC_SHA512_TAG_LENGTH = 64;
+export declare const ReallyMeHmac: {
+    readonly authenticateSha256: (key: Uint8Array, message: Uint8Array) => Uint8Array;
+    readonly authenticateSha512: (key: Uint8Array, message: Uint8Array) => Uint8Array;
+    readonly verifySha256: (tag: Uint8Array, key: Uint8Array, message: Uint8Array) => boolean;
+    readonly verifySha512: (tag: Uint8Array, key: Uint8Array, message: Uint8Array) => boolean;
+};

package/dist/hmac.js

@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha256, sha512 } from "@noble/hashes/sha2.js";
+import { ReallyMeCryptoError } from "./errors.js";
+export const HMAC_MAX_KEY_LENGTH = 4096;
+export const HMAC_SHA256_TAG_LENGTH = 32;
+export const HMAC_SHA512_TAG_LENGTH = 64;
+export const ReallyMeHmac = {
+    authenticateSha256(key, message) {
+        validateKey(key);
+        return hmac(sha256, key, message);
+    },
+    authenticateSha512(key, message) {
+        validateKey(key);
+        return hmac(sha512, key, message);
+    },
+    verifySha256(tag, key, message) {
+        if (tag.length !== HMAC_SHA256_TAG_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        return constantTimeEquals(tag, ReallyMeHmac.authenticateSha256(key, message));
+    },
+    verifySha512(tag, key, message) {
+        if (tag.length !== HMAC_SHA512_TAG_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        return constantTimeEquals(tag, ReallyMeHmac.authenticateSha512(key, message));
+    },
+};
+function validateKey(key) {
+    if (key.length === 0 || key.length > HMAC_MAX_KEY_LENGTH) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+}
+function constantTimeEquals(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    let difference = 0;
+    for (const [index, leftByte] of left.entries()) {
+        const rightByte = right[index];
+        if (rightByte === undefined) {
+            return false;
+        }
+        difference |= leftByte ^ rightByte;
+    }
+    return difference === 0;
+}

package/dist/hpke.d.ts

@@ -0,0 +1,15 @@
+import type { ReallyMeHpkeSuite } from "./algorithms.js";
+export declare const HPKE_P256_PRIVATE_KEY_LENGTH = 32;
+export declare const HPKE_P256_PUBLIC_KEY_LENGTH = 65;
+export declare const HPKE_X25519_PRIVATE_KEY_LENGTH = 32;
+export declare const HPKE_X25519_PUBLIC_KEY_LENGTH = 32;
+export declare const HPKE_AEAD_TAG_LENGTH = 16;
+export type ReallyMeHpkeSealedMessage = Readonly<{
+    encapsulatedKey: Uint8Array;
+    ciphertext: Uint8Array;
+}>;
+export declare const ReallyMeHpke: {
+    readonly sealBase: (suite: ReallyMeHpkeSuite, recipientPublicKey: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array) => ReallyMeHpkeSealedMessage;
+    readonly openBase: (suite: ReallyMeHpkeSuite, recipientSecretKey: Uint8Array, encapsulatedKey: Uint8Array, info: Uint8Array, aad: Uint8Array, ciphertext: Uint8Array) => Uint8Array;
+};
+export declare const sealHpkeBaseDeterministicallyForTest: (suite: ReallyMeHpkeSuite, recipientPublicKey: Uint8Array, encapsulationRandomness: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array) => ReallyMeHpkeSealedMessage;

package/dist/hpke.js

@@ -0,0 +1,59 @@
+// 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 HPKE_P256_PRIVATE_KEY_LENGTH = 32;
+export const HPKE_P256_PUBLIC_KEY_LENGTH = 65;
+export const HPKE_X25519_PRIVATE_KEY_LENGTH = 32;
+export const HPKE_X25519_PUBLIC_KEY_LENGTH = 32;
+export const HPKE_AEAD_TAG_LENGTH = 16;
+const hpkeSuite = (suite) => {
+    switch (suite) {
+        case "DHKEM-P256-HKDF-SHA256-HKDF-SHA256-AES-256-GCM":
+            return {
+                id: 1,
+                publicKeyLength: HPKE_P256_PUBLIC_KEY_LENGTH,
+                privateKeyLength: HPKE_P256_PRIVATE_KEY_LENGTH,
+            };
+        case "DHKEM-X25519-HKDF-SHA256-HKDF-SHA256-CHACHA20-POLY1305":
+            return {
+                id: 2,
+                publicKeyLength: HPKE_X25519_PUBLIC_KEY_LENGTH,
+                privateKeyLength: HPKE_X25519_PRIVATE_KEY_LENGTH,
+            };
+    }
+};
+const readSealedMessage = (value, suite, plaintextLength) => ({
+    encapsulatedKey: readByteArrayProperty(value, "encapsulatedKey", suite.publicKeyLength),
+    ciphertext: readByteArrayProperty(value, "ciphertext", plaintextLength + HPKE_AEAD_TAG_LENGTH),
+});
+const requirePlaintext = (value) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return value;
+};
+export const ReallyMeHpke = {
+    sealBase(suite, recipientPublicKey, info, aad, plaintext) {
+        const config = hpkeSuite(suite);
+        ensureBytes(recipientPublicKey, config.publicKeyLength);
+        return readSealedMessage(requireReallyMeWasmProvider().hpkeSealBase(config.id, recipientPublicKey, info, aad, plaintext), config, plaintext.length);
+    },
+    openBase(suite, recipientSecretKey, encapsulatedKey, info, aad, ciphertext) {
+        const config = hpkeSuite(suite);
+        ensureBytes(recipientSecretKey, config.privateKeyLength);
+        ensureBytes(encapsulatedKey, config.publicKeyLength);
+        if (ciphertext.length < HPKE_AEAD_TAG_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        return requirePlaintext(requireReallyMeWasmProvider().hpkeOpenBase(config.id, recipientSecretKey, encapsulatedKey, info, aad, ciphertext));
+    },
+};
+export const sealHpkeBaseDeterministicallyForTest = (suite, recipientPublicKey, encapsulationRandomness, info, aad, plaintext) => {
+    const config = hpkeSuite(suite);
+    ensureBytes(recipientPublicKey, config.publicKeyLength);
+    ensureBytes(encapsulationRandomness, config.privateKeyLength);
+    return readSealedMessage(requireReallyMeWasmProvider().hpkeSealBaseDerand(config.id, recipientPublicKey, encapsulationRandomness, info, aad, plaintext), config, plaintext.length);
+};

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+export { ReallyMeCryptoError } from "./errors.js";
+export type { ReallyMeCryptoErrorCode } from "./errors.js";
+export { REALLYME_AEAD_ALGORITHMS, REALLYME_HASH_ALGORITHMS, REALLYME_HPKE_SUITES, REALLYME_KDF_ALGORITHMS, REALLYME_KEM_ALGORITHMS, REALLYME_KEY_AGREEMENT_ALGORITHMS, REALLYME_KEY_WRAP_ALGORITHMS, REALLYME_MAC_ALGORITHMS, REALLYME_SIGNATURE_ALGORITHMS, } from "./algorithms.js";
+export type { ReallyMeAeadAlgorithm, ReallyMeHashAlgorithm, ReallyMeHpkeSuite, ReallyMeKdfAlgorithm, ReallyMeKemAlgorithm, ReallyMeKeyAgreementAlgorithm, ReallyMeKeyWrapAlgorithm, ReallyMeMacAlgorithm, ReallyMeSignatureAlgorithm, } from "./algorithms.js";
+export { AEAD_KEY_LENGTH, AEAD_NONCE_LENGTH, AEAD_TAG_LENGTH, ReallyMeAead, XCHACHA20_POLY1305_NONCE_LENGTH, } from "./aead.js";
+export { AES_256_KW_KEK_LENGTH, AES_KW_BLOCK_LENGTH, AES_KW_INTEGRITY_CHECK_LENGTH, AES_KW_MAX_KEY_DATA_LENGTH, AES_KW_MIN_KEY_DATA_LENGTH, AES_KW_MIN_WRAPPED_KEY_LENGTH, ReallyMeAesKw, } from "./aesKw.js";
+export { ARGON2ID_DERIVED_KEY_LENGTH, ARGON2ID_SALT_MAX_LENGTH, ARGON2ID_SALT_MIN_LENGTH, ARGON2ID_V1, ARGON2ID_V2, ReallyMeArgon2id, } from "./argon2id.js";
+export { BIP340_SCHNORR_AUX_RAND_LENGTH, BIP340_SCHNORR_MESSAGE_LENGTH, BIP340_SCHNORR_PUBLIC_KEY_LENGTH, BIP340_SCHNORR_SECRET_KEY_LENGTH, BIP340_SCHNORR_SIGNATURE_LENGTH, ReallyMeBip340Schnorr, } from "./bip340Schnorr.js";
+export { HPKE_AEAD_TAG_LENGTH, HPKE_P256_PRIVATE_KEY_LENGTH, HPKE_P256_PUBLIC_KEY_LENGTH, HPKE_X25519_PRIVATE_KEY_LENGTH, HPKE_X25519_PUBLIC_KEY_LENGTH, ReallyMeHpke, } from "./hpke.js";
+export type { ReallyMeHpkeSealedMessage as ReallyMeHpkeProviderSealedMessage } from "./hpke.js";
+export { ReallyMeCodecs } from "./codecs.js";
+export type { ReallyMeDagCborCidVerification, ReallyMeKeyMaterialKind, ReallyMeMulticodecMetadata, ReallyMeMulticodecTag, ReallyMeParsedMultikey, } from "./codecs.js";
+export { ReallyMeJwk } from "./jwk.js";
+export type { ReallyMeAkpJwk, ReallyMeEcJwk, ReallyMeJwk as ReallyMeJsonWebKey, ReallyMeJwkAlgorithm, ReallyMeJwkKey, ReallyMeJwks, ReallyMeJwksKeySet, ReallyMeOkpJwk, } from "./jwk.js";
+export { ML_KEM_1024_CIPHERTEXT_LENGTH, ML_KEM_1024_PUBLIC_KEY_LENGTH, ML_KEM_512_CIPHERTEXT_LENGTH, ML_KEM_512_PUBLIC_KEY_LENGTH, ML_KEM_768_CIPHERTEXT_LENGTH, ML_KEM_768_PUBLIC_KEY_LENGTH, ML_KEM_ENCAPSULATION_RANDOMNESS_LENGTH, ML_KEM_SECRET_KEY_LENGTH, ML_KEM_SHARED_SECRET_LENGTH, ReallyMeMlKem, } from "./mlKem.js";
+export type { ReallyMeMlKemEncapsulation, ReallyMeMlKemKeyPair } from "./mlKem.js";
+export { ML_DSA_44_PUBLIC_KEY_LENGTH, ML_DSA_44_SIGNATURE_LENGTH, ML_DSA_65_PUBLIC_KEY_LENGTH, ML_DSA_65_SIGNATURE_LENGTH, ML_DSA_87_PUBLIC_KEY_LENGTH, ML_DSA_87_SIGNATURE_LENGTH, ML_DSA_SECRET_KEY_LENGTH, ReallyMeMlDsa, } from "./mlDsa.js";
+export type { ReallyMeMlDsaKeyPair } from "./mlDsa.js";
+export { ReallyMeSlhDsa, SLH_DSA_SHA2_128S_KEYGEN_SEED_LENGTH, SLH_DSA_SHA2_128S_PUBLIC_KEY_LENGTH, SLH_DSA_SHA2_128S_SECRET_KEY_LENGTH, SLH_DSA_SHA2_128S_SIGNATURE_LENGTH, } from "./slhDsa.js";
+export type { ReallyMeSlhDsaKeyPair } from "./slhDsa.js";
+export { compiledProviders, REALLYME_CRYPTO_PROVIDERS } from "./providerCatalog.js";
+export type { ReallyMeCryptoProvider } from "./providerCatalog.js";
+export { ReallyMeCrypto } from "./cryptoFacade.js";
+export type { ReallyMeHpkeSealedMessage, ReallyMeKeyAgreementKeyPair, ReallyMeKemEncapsulation, ReallyMeKemKeyPair, ReallyMeSignatureKeyPair, } from "./cryptoFacade.js";
+export { ReallyMeDigest } from "./digest.js";
+export { ED25519_PUBLIC_KEY_LENGTH, ED25519_SECRET_KEY_LENGTH, ED25519_SIGNATURE_LENGTH, ReallyMeEd25519, } from "./ed25519.js";
+export { HKDF_MAX_INPUT_LENGTH, HKDF_MAX_OUTPUT_LENGTH, HKDF_MIN_INPUT_KEY_MATERIAL_LENGTH, HKDF_MIN_OUTPUT_LENGTH, ReallyMeHkdf, } from "./hkdf.js";
+export { HMAC_MAX_KEY_LENGTH, HMAC_SHA256_TAG_LENGTH, HMAC_SHA512_TAG_LENGTH, ReallyMeHmac, } from "./hmac.js";
+export { P256_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH, P256_ECDH_SECRET_KEY_LENGTH, P256_ECDH_SHARED_SECRET_LENGTH, ReallyMeP256Ecdh, } from "./p256Ecdh.js";
+export { P256_ECDSA_COMPACT_SIGNATURE_LENGTH, P256_ECDSA_COMPRESSED_PUBLIC_KEY_LENGTH, P256_ECDSA_DER_SIGNATURE_MAX_LENGTH, P256_ECDSA_SECRET_KEY_LENGTH, ReallyMeP256Ecdsa, } from "./p256Ecdsa.js";
+export { P384_ECDSA_COMPACT_SIGNATURE_LENGTH, P384_ECDSA_COMPRESSED_PUBLIC_KEY_LENGTH, P384_ECDSA_DER_SIGNATURE_MAX_LENGTH, P384_ECDSA_SECRET_KEY_LENGTH, ReallyMeP384Ecdsa, } from "./p384Ecdsa.js";
+export { P521_ECDSA_COMPACT_SIGNATURE_LENGTH, P521_ECDSA_COMPRESSED_PUBLIC_KEY_LENGTH, P521_ECDSA_DER_SIGNATURE_MAX_LENGTH, P521_ECDSA_SECRET_KEY_LENGTH, ReallyMeP521Ecdsa, } from "./p521Ecdsa.js";
+export { PBKDF2_MAX_INPUT_LENGTH, PBKDF2_MAX_OUTPUT_LENGTH, PBKDF2_MIN_INPUT_LENGTH, PBKDF2_MIN_ITERATIONS, PBKDF2_MIN_OUTPUT_LENGTH, PBKDF2_RECOMMENDED_MIN_ITERATIONS_SHA256, PBKDF2_RECOMMENDED_MIN_ITERATIONS_SHA512, ReallyMePbkdf2, } from "./pbkdf2.js";
+export { ReallyMeSecp256k1, SECP256K1_COMPRESSED_PUBLIC_KEY_LENGTH, SECP256K1_SECRET_KEY_LENGTH, SECP256K1_SIGNATURE_LENGTH, } from "./secp256k1.js";
+export { ReallyMeRsa, RSA_PUBLIC_KEY_DER_MAX_LENGTH, RSA_SIGNATURE_MAX_LENGTH, } from "./rsa.js";
+export type { ReallyMeRsaPublicKeyDerEncoding } from "./rsa.js";
+export { ReallyMeX25519, X25519_PUBLIC_KEY_LENGTH, X25519_SECRET_KEY_LENGTH, X25519_SHARED_SECRET_LENGTH, } from "./x25519.js";
+export { installReallyMeWasmProvider } from "./wasmProvider.js";
+export type { ReallyMeWasmProvider } from "./wasmProvider.js";
+export { ReallyMeXWing, X_WING_1024_CIPHERTEXT_LENGTH, X_WING_1024_PUBLIC_KEY_LENGTH, X_WING_768_CIPHERTEXT_LENGTH, X_WING_768_PUBLIC_KEY_LENGTH, X_WING_ENCAPSULATION_SEED_LENGTH, X_WING_SECRET_KEY_LENGTH, X_WING_SHARED_SECRET_LENGTH, } from "./xWing.js";
+export type { ReallyMeXWingEncapsulation, ReallyMeXWingKeyPair } from "./xWing.js";

package/dist/index.js

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+export { ReallyMeCryptoError } from "./errors.js";
+export { REALLYME_AEAD_ALGORITHMS, REALLYME_HASH_ALGORITHMS, REALLYME_HPKE_SUITES, REALLYME_KDF_ALGORITHMS, REALLYME_KEM_ALGORITHMS, REALLYME_KEY_AGREEMENT_ALGORITHMS, REALLYME_KEY_WRAP_ALGORITHMS, REALLYME_MAC_ALGORITHMS, REALLYME_SIGNATURE_ALGORITHMS, } from "./algorithms.js";
+export { AEAD_KEY_LENGTH, AEAD_NONCE_LENGTH, AEAD_TAG_LENGTH, ReallyMeAead, XCHACHA20_POLY1305_NONCE_LENGTH, } from "./aead.js";
+export { AES_256_KW_KEK_LENGTH, AES_KW_BLOCK_LENGTH, AES_KW_INTEGRITY_CHECK_LENGTH, AES_KW_MAX_KEY_DATA_LENGTH, AES_KW_MIN_KEY_DATA_LENGTH, AES_KW_MIN_WRAPPED_KEY_LENGTH, ReallyMeAesKw, } from "./aesKw.js";
+export { ARGON2ID_DERIVED_KEY_LENGTH, ARGON2ID_SALT_MAX_LENGTH, ARGON2ID_SALT_MIN_LENGTH, ARGON2ID_V1, ARGON2ID_V2, ReallyMeArgon2id, } from "./argon2id.js";
+export { BIP340_SCHNORR_AUX_RAND_LENGTH, BIP340_SCHNORR_MESSAGE_LENGTH, BIP340_SCHNORR_PUBLIC_KEY_LENGTH, BIP340_SCHNORR_SECRET_KEY_LENGTH, BIP340_SCHNORR_SIGNATURE_LENGTH, ReallyMeBip340Schnorr, } from "./bip340Schnorr.js";
+export { HPKE_AEAD_TAG_LENGTH, HPKE_P256_PRIVATE_KEY_LENGTH, HPKE_P256_PUBLIC_KEY_LENGTH, HPKE_X25519_PRIVATE_KEY_LENGTH, HPKE_X25519_PUBLIC_KEY_LENGTH, ReallyMeHpke, } from "./hpke.js";
+export { ReallyMeCodecs } from "./codecs.js";
+export { ReallyMeJwk } from "./jwk.js";
+export { ML_KEM_1024_CIPHERTEXT_LENGTH, ML_KEM_1024_PUBLIC_KEY_LENGTH, ML_KEM_512_CIPHERTEXT_LENGTH, ML_KEM_512_PUBLIC_KEY_LENGTH, ML_KEM_768_CIPHERTEXT_LENGTH, ML_KEM_768_PUBLIC_KEY_LENGTH, ML_KEM_ENCAPSULATION_RANDOMNESS_LENGTH, ML_KEM_SECRET_KEY_LENGTH, ML_KEM_SHARED_SECRET_LENGTH, ReallyMeMlKem, } from "./mlKem.js";
+export { ML_DSA_44_PUBLIC_KEY_LENGTH, ML_DSA_44_SIGNATURE_LENGTH, ML_DSA_65_PUBLIC_KEY_LENGTH, ML_DSA_65_SIGNATURE_LENGTH, ML_DSA_87_PUBLIC_KEY_LENGTH, ML_DSA_87_SIGNATURE_LENGTH, ML_DSA_SECRET_KEY_LENGTH, ReallyMeMlDsa, } from "./mlDsa.js";
+export { ReallyMeSlhDsa, SLH_DSA_SHA2_128S_KEYGEN_SEED_LENGTH, SLH_DSA_SHA2_128S_PUBLIC_KEY_LENGTH, SLH_DSA_SHA2_128S_SECRET_KEY_LENGTH, SLH_DSA_SHA2_128S_SIGNATURE_LENGTH, } from "./slhDsa.js";
+export { compiledProviders, REALLYME_CRYPTO_PROVIDERS } from "./providerCatalog.js";
+export { ReallyMeCrypto } from "./cryptoFacade.js";
+export { ReallyMeDigest } from "./digest.js";
+export { ED25519_PUBLIC_KEY_LENGTH, ED25519_SECRET_KEY_LENGTH, ED25519_SIGNATURE_LENGTH, ReallyMeEd25519, } from "./ed25519.js";
+export { HKDF_MAX_INPUT_LENGTH, HKDF_MAX_OUTPUT_LENGTH, HKDF_MIN_INPUT_KEY_MATERIAL_LENGTH, HKDF_MIN_OUTPUT_LENGTH, ReallyMeHkdf, } from "./hkdf.js";
+export { HMAC_MAX_KEY_LENGTH, HMAC_SHA256_TAG_LENGTH, HMAC_SHA512_TAG_LENGTH, ReallyMeHmac, } from "./hmac.js";
+export { P256_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH, P256_ECDH_SECRET_KEY_LENGTH, P256_ECDH_SHARED_SECRET_LENGTH, ReallyMeP256Ecdh, } from "./p256Ecdh.js";
+export { P256_ECDSA_COMPACT_SIGNATURE_LENGTH, P256_ECDSA_COMPRESSED_PUBLIC_KEY_LENGTH, P256_ECDSA_DER_SIGNATURE_MAX_LENGTH, P256_ECDSA_SECRET_KEY_LENGTH, ReallyMeP256Ecdsa, } from "./p256Ecdsa.js";
+export { P384_ECDSA_COMPACT_SIGNATURE_LENGTH, P384_ECDSA_COMPRESSED_PUBLIC_KEY_LENGTH, P384_ECDSA_DER_SIGNATURE_MAX_LENGTH, P384_ECDSA_SECRET_KEY_LENGTH, ReallyMeP384Ecdsa, } from "./p384Ecdsa.js";
+export { P521_ECDSA_COMPACT_SIGNATURE_LENGTH, P521_ECDSA_COMPRESSED_PUBLIC_KEY_LENGTH, P521_ECDSA_DER_SIGNATURE_MAX_LENGTH, P521_ECDSA_SECRET_KEY_LENGTH, ReallyMeP521Ecdsa, } from "./p521Ecdsa.js";
+export { PBKDF2_MAX_INPUT_LENGTH, PBKDF2_MAX_OUTPUT_LENGTH, PBKDF2_MIN_INPUT_LENGTH, PBKDF2_MIN_ITERATIONS, PBKDF2_MIN_OUTPUT_LENGTH, PBKDF2_RECOMMENDED_MIN_ITERATIONS_SHA256, PBKDF2_RECOMMENDED_MIN_ITERATIONS_SHA512, ReallyMePbkdf2, } from "./pbkdf2.js";
+export { ReallyMeSecp256k1, SECP256K1_COMPRESSED_PUBLIC_KEY_LENGTH, SECP256K1_SECRET_KEY_LENGTH, SECP256K1_SIGNATURE_LENGTH, } from "./secp256k1.js";
+export { ReallyMeRsa, RSA_PUBLIC_KEY_DER_MAX_LENGTH, RSA_SIGNATURE_MAX_LENGTH, } from "./rsa.js";
+export { ReallyMeX25519, X25519_PUBLIC_KEY_LENGTH, X25519_SECRET_KEY_LENGTH, X25519_SHARED_SECRET_LENGTH, } from "./x25519.js";
+export { installReallyMeWasmProvider } from "./wasmProvider.js";
+export { ReallyMeXWing, X_WING_1024_CIPHERTEXT_LENGTH, X_WING_1024_PUBLIC_KEY_LENGTH, X_WING_768_CIPHERTEXT_LENGTH, X_WING_768_PUBLIC_KEY_LENGTH, X_WING_ENCAPSULATION_SEED_LENGTH, X_WING_SECRET_KEY_LENGTH, X_WING_SHARED_SECRET_LENGTH, } from "./xWing.js";

package/dist/jwk.d.ts

@@ -0,0 +1,42 @@
+export type ReallyMeJwkAlgorithm = "Ed25519" | "X25519" | "P-256" | "secp256k1" | "ML-DSA-44" | "ML-DSA-65" | "ML-DSA-87" | "ML-KEM-512" | "ML-KEM-768" | "ML-KEM-1024" | "SLH-DSA-SHA2-128s" | "X-Wing-768" | "X-Wing-1024";
+export type ReallyMeOkpJwk = Readonly<{
+    alg: string;
+    crv: "Ed25519" | "X25519";
+    kty: "OKP";
+    use: "enc" | "sig";
+    x: string;
+}>;
+export type ReallyMeAkpJwk = Readonly<{
+    alg: string;
+    kty: "AKP";
+    pub: string;
+    use: "enc" | "sig";
+}>;
+export type ReallyMeEcJwk = Readonly<{
+    alg: string;
+    crv: "P-256" | "secp256k1";
+    kty: "EC";
+    use: "sig";
+    x: string;
+    y: string;
+}>;
+export type ReallyMeJwk = ReallyMeOkpJwk | ReallyMeAkpJwk | ReallyMeEcJwk;
+export type ReallyMeJwkKey = Readonly<{
+    algorithm: ReallyMeJwkAlgorithm;
+    publicKey: Uint8Array;
+    jwk: ReallyMeJwk;
+}>;
+export type ReallyMeJwks = Readonly<{
+    keys: ReadonlyArray<ReallyMeJwk>;
+}>;
+export type ReallyMeJwksKeySet = Readonly<{
+    keys: ReadonlyArray<ReallyMeJwkKey>;
+}>;
+export declare const ReallyMeJwk: {
+    readonly toJwk: (algorithm: ReallyMeJwkAlgorithm, publicKey: Uint8Array) => ReallyMeJwk;
+    readonly fromJwk: (value: unknown) => ReallyMeJwkKey;
+    readonly toJwks: (keys: ReadonlyArray<ReallyMeJwk>) => ReallyMeJwks;
+    readonly fromJwks: (value: unknown) => ReallyMeJwksKeySet;
+    readonly publicKeyBytes: (jwk: ReallyMeJwk) => Uint8Array;
+    readonly toJcs: (jwk: ReallyMeJwk) => string;
+};