@reallyme/crypto 0.2.0 → 0.3.1

package/dist/cryptoFacade.js

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { ReallyMeAead } from "./aead.js";
 import { ReallyMeAesKw } from "./aesKw.js";
-import { ARGON2ID_DERIVED_KEY_LENGTH, ReallyMeArgon2id } from "./argon2id.js";
+import { ReallyMeArgon2id } from "./argon2id.js";
 import { ReallyMeBip340Schnorr } from "./bip340Schnorr.js";
 import { ReallyMeDigest } from "./digest.js";
 import { ReallyMeEd25519 } from "./ed25519.js";
@@ -12,6 +12,7 @@ import { ReallyMeHkdf } from "./hkdf.js";
 import { ReallyMeHmac } from "./hmac.js";
 import { ReallyMeHpke } from "./hpke.js";
 import { ReallyMeJwaConcatKdf } from "./jwaConcatKdf.js";
+import { ReallyMeKmac } from "./kmac.js";
 import { ReallyMeMlDsa } from "./mlDsa.js";
 import { ReallyMeMlKem } from "./mlKem.js";
 import { ReallyMeP256Ecdsa } from "./p256Ecdsa.js";
@@ -25,6 +26,8 @@ import { ReallyMeRsa } from "./rsa.js";
 import { ReallyMeSecp256k1 } from "./secp256k1.js";
 import { ReallyMeSlhDsa } from "./slhDsa.js";
 import { requireReallyMeWasmProvider } from "./wasmProvider.js";
+import { processOperationResponseJsonWithProvider, processOperationResponseWithProvider, } from "./operationResponse.js";
+import { ensureByteArray } from "./validateBytes.js";
 import { ReallyMeX25519 } from "./x25519.js";
 import { ReallyMeXWing } from "./xWing.js";
 const SECP256K1_ECDSA = "ECDSA-secp256k1-SHA256";
@@ -36,9 +39,27 @@ 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.
+ * stable typed route and rejects algorithm/operation combinations that the
+ * selected method does not define.
  */
 const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
+    /**
+     * Executes a generated binary request and returns a binary
+     * `CryptoOperationResponse`.
+     */
+    processOperationResponse(request) {
+        ensureByteArray(request);
+        return processOperationResponseWithProvider(resolveWasmProvider(), request);
+    },
+    /**
+     * Executes a permitted non-secret generated ProtoJSON request and returns
+     * the same binary `CryptoOperationResponse`. Secret-bearing selectors fail
+     * before JSON value deserialization.
+     */
+    processOperationResponseJson(requestJson) {
+        ensureByteArray(requestJson);
+        return processOperationResponseJsonWithProvider(resolveWasmProvider(), requestJson);
+    },
     hash(algorithm, bytes) {
         switch (algorithm) {
             case "SHA2-256":
@@ -89,6 +110,8 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
         switch (algorithm) {
             case "HMAC-SHA-256":
                 return ReallyMeHmac.authenticateSha256(key, message);
+            case "HMAC-SHA-384":
+                return ReallyMeHmac.authenticateSha384(key, message);
             case "HMAC-SHA-512":
                 return ReallyMeHmac.authenticateSha512(key, message);
             default:
@@ -99,6 +122,8 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
         switch (algorithm) {
             case "HMAC-SHA-256":
                 return ReallyMeHmac.verifySha256(tag, key, message);
+            case "HMAC-SHA-384":
+                return ReallyMeHmac.verifySha384(tag, key, message);
             case "HMAC-SHA-512":
                 return ReallyMeHmac.verifySha512(tag, key, message);
             default:
@@ -110,22 +135,10 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
     },
     deriveKey(algorithm, password, salt, iterations, outputLength) {
         switch (algorithm) {
-            case "Argon2id":
-                if (outputLength !== ARGON2ID_DERIVED_KEY_LENGTH) {
-                    throw new ReallyMeCryptoError("invalid-input");
-                }
-                // Argon2id is governed by fixed ReallyMe profile versions, not by
-                // caller-selected iteration counts. This legacy generic KDF shape
-                // preserves the existing facade contract; new code should call
-                // deriveArgon2id(kdfVersion, secret, salt) so the profile selector is
-                // explicit at the API boundary.
-                return ReallyMeArgon2id.deriveKeyWithProvider(resolveWasmProvider(), 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");
         }
@@ -134,11 +147,8 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
         switch (algorithm) {
             case "HKDF-SHA256":
                 return ReallyMeHkdf.deriveSha256(inputKeyMaterial, salt, info, outputLength);
-            case "Argon2id":
-            case "PBKDF2-HMAC-SHA-256":
-            case "PBKDF2-HMAC-SHA-512":
-            case "JWA-CONCAT-KDF-SHA256":
-                throw new ReallyMeCryptoError("unsupported-algorithm");
+            case "HKDF-SHA384":
+                return ReallyMeHkdf.deriveSha384(inputKeyMaterial, salt, info, outputLength);
             default:
                 throw new ReallyMeCryptoError("unsupported-algorithm");
         }
@@ -147,27 +157,34 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
         switch (algorithm) {
             case "JWA-CONCAT-KDF-SHA256":
                 return ReallyMeJwaConcatKdf.deriveSha256(sharedSecret, algorithmId, partyUInfo, partyVInfo, outputLength);
-            case "Argon2id":
-            case "HKDF-SHA256":
-            case "PBKDF2-HMAC-SHA-256":
-            case "PBKDF2-HMAC-SHA-512":
+            default:
                 throw new ReallyMeCryptoError("unsupported-algorithm");
+        }
+    },
+    deriveKmac256(algorithm, key, context, customization, outputLength) {
+        switch (algorithm) {
+            case "KMAC256":
+                return ReallyMeKmac.deriveKmac256WithProvider(resolveWasmProvider(), key, context, customization, outputLength);
             default:
                 throw new ReallyMeCryptoError("unsupported-algorithm");
         }
     },
     wrapKey(algorithm, wrappingKey, keyToWrap) {
         switch (algorithm) {
+            case "AES-128-KW":
+            case "AES-192-KW":
             case "AES-256-KW":
-                return ReallyMeAesKw.wrapKeyWithProvider(resolveWasmProvider(), wrappingKey, keyToWrap);
+                return ReallyMeAesKw.wrapKeyWithProvider(algorithm, resolveWasmProvider(), wrappingKey, keyToWrap);
             default:
                 throw new ReallyMeCryptoError("unsupported-algorithm");
         }
     },
     unwrapKey(algorithm, wrappingKey, wrappedKey) {
         switch (algorithm) {
+            case "AES-128-KW":
+            case "AES-192-KW":
             case "AES-256-KW":
-                return ReallyMeAesKw.unwrapKeyWithProvider(resolveWasmProvider(), wrappingKey, wrappedKey);
+                return ReallyMeAesKw.unwrapKeyWithProvider(algorithm, resolveWasmProvider(), wrappingKey, wrappedKey);
             default:
                 throw new ReallyMeCryptoError("unsupported-algorithm");
         }
@@ -333,7 +350,6 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
     generateKemKeyPair(algorithm) {
         switch (algorithm) {
             case "X-Wing-768":
-            case "X-Wing-1024":
                 return ReallyMeXWing.generateKeyPairWithProvider(resolveWasmProvider(), algorithm);
             case "ML-KEM-512":
             case "ML-KEM-768":
@@ -346,7 +362,6 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
     deriveKemKeyPair(algorithm, secretKey) {
         switch (algorithm) {
             case "X-Wing-768":
-            case "X-Wing-1024":
                 return ReallyMeXWing.deriveKeyPairWithProvider(resolveWasmProvider(), algorithm, secretKey);
             case "ML-KEM-512":
             case "ML-KEM-768":
@@ -359,7 +374,6 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
     encapsulate(algorithm, publicKey) {
         switch (algorithm) {
             case "X-Wing-768":
-            case "X-Wing-1024":
                 return ReallyMeXWing.encapsulateWithProvider(resolveWasmProvider(), algorithm, publicKey);
             case "ML-KEM-512":
             case "ML-KEM-768":
@@ -372,7 +386,6 @@ const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
     decapsulate(algorithm, ciphertext, secretKey) {
         switch (algorithm) {
             case "X-Wing-768":
-            case "X-Wing-1024":
                 return ReallyMeXWing.decapsulateWithProvider(resolveWasmProvider(), algorithm, ciphertext, secretKey);
             case "ML-KEM-512":
             case "ML-KEM-768":

package/dist/hkdf.d.ts

@@ -4,4 +4,5 @@ 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;
+    readonly deriveSha384: (inputKeyMaterial: Uint8Array, salt: Uint8Array, info: Uint8Array, outputLength: number) => Uint8Array;
 };

package/dist/hkdf.js

@@ -2,7 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { hkdf } from "@noble/hashes/hkdf.js";
-import { sha256 } from "@noble/hashes/sha2.js";
+import { sha256, sha384 } 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;
@@ -13,6 +13,10 @@ export const ReallyMeHkdf = {
         validate(inputKeyMaterial, salt, info, outputLength);
         return hkdf(sha256, inputKeyMaterial, salt, info, outputLength);
     },
+    deriveSha384(inputKeyMaterial, salt, info, outputLength) {
+        validate(inputKeyMaterial, salt, info, outputLength);
+        return hkdf(sha384, inputKeyMaterial, salt, info, outputLength);
+    },
 };
 function validate(inputKeyMaterial, salt, info, outputLength) {
     if (inputKeyMaterial.length < HKDF_MIN_INPUT_KEY_MATERIAL_LENGTH ||

package/dist/hmac.d.ts

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

package/dist/hmac.js

@@ -2,16 +2,21 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { hmac } from "@noble/hashes/hmac.js";
-import { sha256, sha512 } from "@noble/hashes/sha2.js";
+import { sha256, sha384, 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_SHA384_TAG_LENGTH = 48;
 export const HMAC_SHA512_TAG_LENGTH = 64;
 export const ReallyMeHmac = {
     authenticateSha256(key, message) {
         validateKey(key);
         return hmac(sha256, key, message);
     },
+    authenticateSha384(key, message) {
+        validateKey(key);
+        return hmac(sha384, key, message);
+    },
     authenticateSha512(key, message) {
         validateKey(key);
         return hmac(sha512, key, message);
@@ -20,13 +25,19 @@ export const ReallyMeHmac = {
         if (tag.length !== HMAC_SHA256_TAG_LENGTH) {
             throw new ReallyMeCryptoError("invalid-input");
         }
-        return constantTimeEquals(tag, ReallyMeHmac.authenticateSha256(key, message));
+        return verifyAndClearExpectedTag(tag, ReallyMeHmac.authenticateSha256(key, message));
+    },
+    verifySha384(tag, key, message) {
+        if (tag.length !== HMAC_SHA384_TAG_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        return verifyAndClearExpectedTag(tag, ReallyMeHmac.authenticateSha384(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));
+        return verifyAndClearExpectedTag(tag, ReallyMeHmac.authenticateSha512(key, message));
     },
 };
 function validateKey(key) {
@@ -48,3 +59,13 @@ function constantTimeEquals(left, right) {
     }
     return difference === 0;
 }
+function verifyAndClearExpectedTag(tag, expectedTag) {
+    try {
+        return constantTimeEquals(tag, expectedTag);
+    }
+    finally {
+        // Noble returns a new typed array. Clear it immediately so verification
+        // does not retain key-derived authentication material until a GC cycle.
+        expectedTag.fill(0);
+    }
+}

package/dist/hpke.d.ts

@@ -5,6 +5,7 @@ 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 declare const HPKE_INFO_MAX_LENGTH = 65530;
 export type ReallyMeHpkeSealedMessage = Readonly<{
     encapsulatedKey: Uint8Array;
     ciphertext: Uint8Array;
@@ -15,5 +16,3 @@ export declare const ReallyMeHpke: {
     readonly openBase: (suite: ReallyMeHpkeSuite, recipientSecretKey: Uint8Array, encapsulatedKey: Uint8Array, info: Uint8Array, aad: Uint8Array, ciphertext: Uint8Array) => Uint8Array;
     readonly openBaseWithProvider: (provider: ReallyMeWasmProvider, 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;
-export declare const sealHpkeBaseDeterministicallyWithProviderForTest: (provider: ReallyMeWasmProvider, suite: ReallyMeHpkeSuite, recipientPublicKey: Uint8Array, encapsulationRandomness: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array) => ReallyMeHpkeSealedMessage;

package/dist/hpke.js

@@ -2,13 +2,14 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { ReallyMeCryptoError } from "./errors.js";
-import { ensureBytes, readByteArrayProperty } from "./validateBytes.js";
+import { ensureByteArrayAtMost, ensureBytes, ensureIndependentByteArray, MAX_CRYPTO_INPUT_LENGTH, readIndependentByteArrayProperty, } 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;
+export const HPKE_INFO_MAX_LENGTH = 65_530;
 const hpkeSuite = (suite) => {
     switch (suite) {
         case "DHKEM-P256-HKDF-SHA256-HKDF-SHA256-AES-256-GCM":
@@ -23,57 +24,67 @@ const hpkeSuite = (suite) => {
                 publicKeyLength: HPKE_X25519_PUBLIC_KEY_LENGTH,
                 privateKeyLength: HPKE_X25519_PRIVATE_KEY_LENGTH,
             };
+        default:
+            // JavaScript callers can bypass TypeScript's string union at runtime.
+            // Reject before a numeric selector can reach wasm-bindgen and truncate.
+            throw new ReallyMeCryptoError("invalid-input");
     }
 };
-const readSealedMessage = (value, suite, plaintextLength) => ({
-    encapsulatedKey: readByteArrayProperty(value, "encapsulatedKey", suite.publicKeyLength),
-    ciphertext: readByteArrayProperty(value, "ciphertext", plaintextLength + HPKE_AEAD_TAG_LENGTH),
-});
-const requirePlaintext = (value) => {
+const readSealedMessage = (value, suite, plaintextLength, inputs) => {
+    const encapsulatedKey = readIndependentByteArrayProperty(value, "encapsulatedKey", suite.publicKeyLength, inputs);
+    const ciphertext = readIndependentByteArrayProperty(value, "ciphertext", plaintextLength + HPKE_AEAD_TAG_LENGTH, [...inputs, encapsulatedKey]);
+    return { encapsulatedKey, ciphertext };
+};
+const requirePlaintext = (value, expectedLength, inputs) => {
     if (!(value instanceof Uint8Array)) {
         throw new ReallyMeCryptoError("provider-failure");
     }
+    ensureIndependentByteArray(value, inputs);
+    if (value.length !== expectedLength) {
+        value.fill(0);
+        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);
+        ensureByteArrayAtMost(info, HPKE_INFO_MAX_LENGTH);
+        ensureByteArrayAtMost(aad, MAX_CRYPTO_INPUT_LENGTH);
+        ensureByteArrayAtMost(plaintext, MAX_CRYPTO_INPUT_LENGTH);
+        return readSealedMessage(requireReallyMeWasmProvider().hpkeSealBase(config.id, recipientPublicKey, info, aad, plaintext), config, plaintext.length, [recipientPublicKey, info, aad, plaintext]);
     },
     sealBaseWithProvider(provider, suite, recipientPublicKey, info, aad, plaintext) {
         const config = hpkeSuite(suite);
         ensureBytes(recipientPublicKey, config.publicKeyLength);
-        return readSealedMessage(provider.hpkeSealBase(config.id, recipientPublicKey, info, aad, plaintext), config, plaintext.length);
+        ensureByteArrayAtMost(info, HPKE_INFO_MAX_LENGTH);
+        ensureByteArrayAtMost(aad, MAX_CRYPTO_INPUT_LENGTH);
+        ensureByteArrayAtMost(plaintext, MAX_CRYPTO_INPUT_LENGTH);
+        return readSealedMessage(provider.hpkeSealBase(config.id, recipientPublicKey, info, aad, plaintext), config, plaintext.length, [recipientPublicKey, info, aad, plaintext]);
     },
     openBase(suite, recipientSecretKey, encapsulatedKey, info, aad, ciphertext) {
         const config = hpkeSuite(suite);
         ensureBytes(recipientSecretKey, config.privateKeyLength);
         ensureBytes(encapsulatedKey, config.publicKeyLength);
+        ensureByteArrayAtMost(info, HPKE_INFO_MAX_LENGTH);
+        ensureByteArrayAtMost(aad, MAX_CRYPTO_INPUT_LENGTH);
+        ensureByteArrayAtMost(ciphertext, MAX_CRYPTO_INPUT_LENGTH + HPKE_AEAD_TAG_LENGTH);
         if (ciphertext.length < HPKE_AEAD_TAG_LENGTH) {
             throw new ReallyMeCryptoError("invalid-input");
         }
-        return requirePlaintext(requireReallyMeWasmProvider().hpkeOpenBase(config.id, recipientSecretKey, encapsulatedKey, info, aad, ciphertext));
+        return requirePlaintext(requireReallyMeWasmProvider().hpkeOpenBase(config.id, recipientSecretKey, encapsulatedKey, info, aad, ciphertext), ciphertext.length - HPKE_AEAD_TAG_LENGTH, [recipientSecretKey, encapsulatedKey, info, aad, ciphertext]);
     },
     openBaseWithProvider(provider, suite, recipientSecretKey, encapsulatedKey, info, aad, ciphertext) {
         const config = hpkeSuite(suite);
         ensureBytes(recipientSecretKey, config.privateKeyLength);
         ensureBytes(encapsulatedKey, config.publicKeyLength);
+        ensureByteArrayAtMost(info, HPKE_INFO_MAX_LENGTH);
+        ensureByteArrayAtMost(aad, MAX_CRYPTO_INPUT_LENGTH);
+        ensureByteArrayAtMost(ciphertext, MAX_CRYPTO_INPUT_LENGTH + HPKE_AEAD_TAG_LENGTH);
         if (ciphertext.length < HPKE_AEAD_TAG_LENGTH) {
             throw new ReallyMeCryptoError("invalid-input");
         }
-        return requirePlaintext(provider.hpkeOpenBase(config.id, recipientSecretKey, encapsulatedKey, info, aad, ciphertext));
+        return requirePlaintext(provider.hpkeOpenBase(config.id, recipientSecretKey, encapsulatedKey, info, aad, ciphertext), ciphertext.length - HPKE_AEAD_TAG_LENGTH, [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);
-};
-export const sealHpkeBaseDeterministicallyWithProviderForTest = (provider, suite, recipientPublicKey, encapsulationRandomness, info, aad, plaintext) => {
-    const config = hpkeSuite(suite);
-    ensureBytes(recipientPublicKey, config.publicKeyLength);
-    ensureBytes(encapsulationRandomness, config.privateKeyLength);
-    return readSealedMessage(provider.hpkeSealBaseDerand(config.id, recipientPublicKey, encapsulationRandomness, info, aad, plaintext), config, plaintext.length);
-};

package/dist/index.d.ts

@@ -1,16 +1,16 @@
 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 type { ReallyMeAeadAlgorithm, ReallyMeHashAlgorithm, ReallyMeHkdfAlgorithm, ReallyMeHpkeSuite, ReallyMeJwaConcatKdfAlgorithm, ReallyMeKdfAlgorithm, ReallyMeKemAlgorithm, ReallyMeKeyAgreementAlgorithm, ReallyMeKeyWrapAlgorithm, ReallyMeKmacKdfAlgorithm, ReallyMeMacAlgorithm, ReallyMePbkdf2Algorithm, ReallyMeSignatureAlgorithm, } from "./algorithms.js";
 export { AEAD_KEY_LENGTH, AEAD_NONCE_LENGTH, AEAD_TAG_LENGTH, AES_128_GCM_KEY_LENGTH, AES_192_GCM_KEY_LENGTH, AES_256_GCM_KEY_LENGTH, CHACHA20_POLY1305_KEY_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 { ARGON2ID_DERIVED_KEY_LENGTH, ARGON2ID_SALT_MAX_LENGTH, ARGON2ID_SALT_MIN_LENGTH, ARGON2ID_SECRET_MAX_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 { HPKE_AEAD_TAG_LENGTH, HPKE_INFO_MAX_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 { 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 { 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_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";
@@ -23,21 +23,23 @@ export type { ReallyMeCryptoFacade, ReallyMeCryptoProviders, ReallyMeHpkeSealedM
 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 { KMAC256_MAX_CONTEXT_LENGTH, KMAC256_MAX_CUSTOMIZATION_LENGTH, KMAC256_MAX_KEY_LENGTH, KMAC256_MAX_OUTPUT_LENGTH, KMAC256_MIN_KEY_LENGTH, KMAC256_MIN_OUTPUT_LENGTH, ReallyMeKmac, } from "./kmac.js";
 export { JWA_CONCAT_KDF_MAX_INFO_LENGTH, JWA_CONCAT_KDF_MAX_OUTPUT_LENGTH, JWA_CONCAT_KDF_MAX_SHARED_SECRET_LENGTH, JWA_CONCAT_KDF_MIN_OUTPUT_LENGTH, JWA_CONCAT_KDF_SHA256_DIGEST_LENGTH, ReallyMeJwaConcatKdf, } from "./jwaConcatKdf.js";
 export { bestEffortClear } from "./memory.js";
-export { HMAC_MAX_KEY_LENGTH, HMAC_SHA256_TAG_LENGTH, HMAC_SHA512_TAG_LENGTH, ReallyMeHmac, } from "./hmac.js";
+export { processOperationResponse, processOperationResponseJson, } from "./operationResponse.js";
+export { HMAC_MAX_KEY_LENGTH, HMAC_SHA256_TAG_LENGTH, HMAC_SHA384_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_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH, P384_ECDH_SECRET_KEY_LENGTH, P384_ECDH_SHARED_SECRET_LENGTH, ReallyMeP384Ecdh, } from "./p384Ecdh.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_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH, P521_ECDH_SECRET_KEY_LENGTH, P521_ECDH_SHARED_SECRET_LENGTH, ReallyMeP521Ecdh, } from "./p521Ecdh.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 { PBKDF2_MAX_INPUT_LENGTH, PBKDF2_MAX_ITERATIONS, 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 { createReallyMeWasmProvider, 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 { ReallyMeXWing, X_WING_768_CIPHERTEXT_LENGTH, X_WING_768_PUBLIC_KEY_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

@@ -5,11 +5,11 @@ 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, AES_128_GCM_KEY_LENGTH, AES_192_GCM_KEY_LENGTH, AES_256_GCM_KEY_LENGTH, CHACHA20_POLY1305_KEY_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 { ARGON2ID_DERIVED_KEY_LENGTH, ARGON2ID_SALT_MAX_LENGTH, ARGON2ID_SALT_MIN_LENGTH, ARGON2ID_SECRET_MAX_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 { HPKE_AEAD_TAG_LENGTH, HPKE_INFO_MAX_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 { 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_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_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";
@@ -17,18 +17,20 @@ export { createReallyMeCrypto, 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 { KMAC256_MAX_CONTEXT_LENGTH, KMAC256_MAX_CUSTOMIZATION_LENGTH, KMAC256_MAX_KEY_LENGTH, KMAC256_MAX_OUTPUT_LENGTH, KMAC256_MIN_KEY_LENGTH, KMAC256_MIN_OUTPUT_LENGTH, ReallyMeKmac, } from "./kmac.js";
 export { JWA_CONCAT_KDF_MAX_INFO_LENGTH, JWA_CONCAT_KDF_MAX_OUTPUT_LENGTH, JWA_CONCAT_KDF_MAX_SHARED_SECRET_LENGTH, JWA_CONCAT_KDF_MIN_OUTPUT_LENGTH, JWA_CONCAT_KDF_SHA256_DIGEST_LENGTH, ReallyMeJwaConcatKdf, } from "./jwaConcatKdf.js";
 export { bestEffortClear } from "./memory.js";
-export { HMAC_MAX_KEY_LENGTH, HMAC_SHA256_TAG_LENGTH, HMAC_SHA512_TAG_LENGTH, ReallyMeHmac, } from "./hmac.js";
+export { processOperationResponse, processOperationResponseJson, } from "./operationResponse.js";
+export { HMAC_MAX_KEY_LENGTH, HMAC_SHA256_TAG_LENGTH, HMAC_SHA384_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_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH, P384_ECDH_SECRET_KEY_LENGTH, P384_ECDH_SHARED_SECRET_LENGTH, ReallyMeP384Ecdh, } from "./p384Ecdh.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_ECDH_COMPRESSED_PUBLIC_KEY_LENGTH, P521_ECDH_SECRET_KEY_LENGTH, P521_ECDH_SHARED_SECRET_LENGTH, ReallyMeP521Ecdh, } from "./p521Ecdh.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 { PBKDF2_MAX_INPUT_LENGTH, PBKDF2_MAX_ITERATIONS, 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 { createReallyMeWasmProvider, 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";
+export { ReallyMeXWing, X_WING_768_CIPHERTEXT_LENGTH, X_WING_768_PUBLIC_KEY_LENGTH, X_WING_SECRET_KEY_LENGTH, X_WING_SHARED_SECRET_LENGTH, } from "./xWing.js";

package/dist/jwk.d.ts

@@ -1,4 +1,4 @@
-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 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";
 export type ReallyMeOkpJwk = Readonly<{
     alg: string;
     crv: "Ed25519" | "X25519";
@@ -32,6 +32,7 @@ export type ReallyMeJwks = Readonly<{
 export type ReallyMeJwksKeySet = Readonly<{
     keys: ReadonlyArray<ReallyMeJwkKey>;
 }>;
+export declare const MAX_JWKS_KEYS = 1024;
 export declare const ReallyMeJwk: {
     readonly toJwk: (algorithm: ReallyMeJwkAlgorithm, publicKey: Uint8Array) => ReallyMeJwk;
     readonly fromJwk: (value: unknown) => ReallyMeJwkKey;