@f0rest8/metamorphic-crypto 0.8.1 → 0.10.0

package/metamorphic_crypto.d.ts

@@ -42,6 +42,58 @@ export function deriveSessionKey(password: string, salt_b64: string): string;
  */
 export function deriveSigningPublicKey(secret_key_b64: string): string;
 
+/**
+ * Generate an ECVRF-Edwards25519 keypair. Returns JSON: `{ secretKey, publicKey }`.
+ */
+export function ecvrfEd25519GenerateKeyPair(): any;
+
+/**
+ * Recover the base64 ECVRF-Edwards25519 output from a proof, without verifying.
+ */
+export function ecvrfEd25519ProofToHash(proof_b64: string): string;
+
+/**
+ * Produce an ECVRF-Edwards25519 proof (base64) for base64 `alpha`.
+ */
+export function ecvrfEd25519Prove(secret_key_b64: string, alpha_b64: string): string;
+
+/**
+ * Derive the base64 ECVRF-Edwards25519 public key from a base64 secret key.
+ */
+export function ecvrfEd25519PublicKey(secret_key_b64: string): string;
+
+/**
+ * Verify an ECVRF-Edwards25519 proof. Returns the base64 output on success, or
+ * `null` on a cryptographic rejection.
+ */
+export function ecvrfEd25519Verify(public_key_b64: string, alpha_b64: string, proof_b64: string): string | undefined;
+
+/**
+ * Generate an ECVRF-P256 keypair. Returns JSON: `{ secretKey, publicKey }`.
+ */
+export function ecvrfP256GenerateKeyPair(): any;
+
+/**
+ * Recover the base64 ECVRF-P256 output from a proof, without verifying.
+ */
+export function ecvrfP256ProofToHash(proof_b64: string): string;
+
+/**
+ * Produce an ECVRF-P256 proof (base64) for base64 `alpha`.
+ */
+export function ecvrfP256Prove(secret_key_b64: string, alpha_b64: string): string;
+
+/**
+ * Derive the base64 ECVRF-P256 public key from a base64 secret key.
+ */
+export function ecvrfP256PublicKey(secret_key_b64: string): string;
+
+/**
+ * Verify an ECVRF-P256 proof. Returns the base64 output on success, or `null`
+ * on a cryptographic rejection.
+ */
+export function ecvrfP256Verify(public_key_b64: string, alpha_b64: string, proof_b64: string): string | undefined;
+
 /**
  * Encrypt a base64 private key with a session key. Returns base64 ciphertext.
  */
@@ -121,6 +173,27 @@ export function generateSigningKeyPair(level: string): any;
  */
 export function generateSigningKeyPairSuite(suite: string, level: string): any;
 
+/**
+ * HKDF-SHA512 (RFC 5869) extract-then-expand over base64-encoded inputs.
+ *
+ * Derives `length` bytes of output keying material and returns it as base64.
+ * `salt_b64` and `ikm_b64` are base64; `info` is a UTF-8 context label (bound
+ * into Expand for domain separation). An empty `salt_b64` means "not provided"
+ * (HashLen zero bytes, RFC 5869 §2.2).
+ *
+ * Byte-for-byte identical to `metamorphic_crypto::hkdf::hkdf_sha512` (native /
+ * Elixir NIF) and to `@noble/hashes` / WebCrypto HKDF-SHA-512 for the same
+ * inputs — the guarantee that a wrapping key derived in the browser matches
+ * one derived anywhere else.
+ */
+export function hkdfSha512(salt_b64: string, ikm_b64: string, info: string, length: number): string;
+
+/**
+ * HMAC-SHA256 of base64 `msg` under base64 `key`. Returns the 32-byte tag as
+ * base64. Any key length is accepted (RFC 2104).
+ */
+export function hmacSha256(key_b64: string, msg_b64: string): string;
+
 /**
  * Open a CNSA-2.0 (or legacy) hybrid ciphertext, supplying the context label
  * used at seal time for the new suites. Returns base64-encoded plaintext.
@@ -257,6 +330,7 @@ export interface InitOutput {
     readonly parseSaltFromKeyHash: (a: number, b: number, c: number) => void;
     readonly sha3_512: (a: number, b: number, c: number) => void;
     readonly sha3_512WithContext: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly hkdfSha512: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly sha3_256: (a: number, b: number, c: number) => void;
     readonly sha256: (a: number, b: number, c: number) => void;
     readonly sha512: (a: number, b: number, c: number) => void;
@@ -265,10 +339,21 @@ export interface InitOutput {
     readonly deriveSigningPublicKey: (a: number, b: number, c: number) => void;
     readonly sign: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly verify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
-    readonly decryptSecretboxToString: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly hmacSha256: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly ecvrfEd25519GenerateKeyPair: () => number;
+    readonly ecvrfEd25519PublicKey: (a: number, b: number, c: number) => void;
+    readonly ecvrfEd25519Prove: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly ecvrfEd25519Verify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly ecvrfEd25519ProofToHash: (a: number, b: number, c: number) => void;
+    readonly ecvrfP256GenerateKeyPair: () => number;
+    readonly ecvrfP256PublicKey: (a: number, b: number, c: number) => void;
+    readonly ecvrfP256Prove: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly ecvrfP256Verify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly ecvrfP256ProofToHash: (a: number, b: number, c: number) => void;
     readonly encryptSecretboxString: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly decryptPrivateKeyWithRecovery: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly encryptPrivateKeyForRecovery: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly decryptSecretboxToString: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly decryptPrivateKeyWithRecovery: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/metamorphic_crypto.js

@@ -281,6 +281,294 @@ export function deriveSigningPublicKey(secret_key_b64) {
     }
 }
 
+/**
+ * Generate an ECVRF-Edwards25519 keypair. Returns JSON: `{ secretKey, publicKey }`.
+ * @returns {any}
+ */
+export function ecvrfEd25519GenerateKeyPair() {
+    const ret = wasm.ecvrfEd25519GenerateKeyPair();
+    return takeObject(ret);
+}
+
+/**
+ * Recover the base64 ECVRF-Edwards25519 output from a proof, without verifying.
+ * @param {string} proof_b64
+ * @returns {string}
+ */
+export function ecvrfEd25519ProofToHash(proof_b64) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(proof_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ecvrfEd25519ProofToHash(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Produce an ECVRF-Edwards25519 proof (base64) for base64 `alpha`.
+ * @param {string} secret_key_b64
+ * @param {string} alpha_b64
+ * @returns {string}
+ */
+export function ecvrfEd25519Prove(secret_key_b64, alpha_b64) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(secret_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(alpha_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ecvrfEd25519Prove(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Derive the base64 ECVRF-Edwards25519 public key from a base64 secret key.
+ * @param {string} secret_key_b64
+ * @returns {string}
+ */
+export function ecvrfEd25519PublicKey(secret_key_b64) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(secret_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ecvrfEd25519PublicKey(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Verify an ECVRF-Edwards25519 proof. Returns the base64 output on success, or
+ * `null` on a cryptographic rejection.
+ * @param {string} public_key_b64
+ * @param {string} alpha_b64
+ * @param {string} proof_b64
+ * @returns {string | undefined}
+ */
+export function ecvrfEd25519Verify(public_key_b64, alpha_b64, proof_b64) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(public_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(alpha_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(proof_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.ecvrfEd25519Verify(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        let v4;
+        if (r0 !== 0) {
+            v4 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        }
+        return v4;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Generate an ECVRF-P256 keypair. Returns JSON: `{ secretKey, publicKey }`.
+ * @returns {any}
+ */
+export function ecvrfP256GenerateKeyPair() {
+    const ret = wasm.ecvrfP256GenerateKeyPair();
+    return takeObject(ret);
+}
+
+/**
+ * Recover the base64 ECVRF-P256 output from a proof, without verifying.
+ * @param {string} proof_b64
+ * @returns {string}
+ */
+export function ecvrfP256ProofToHash(proof_b64) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(proof_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ecvrfP256ProofToHash(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Produce an ECVRF-P256 proof (base64) for base64 `alpha`.
+ * @param {string} secret_key_b64
+ * @param {string} alpha_b64
+ * @returns {string}
+ */
+export function ecvrfP256Prove(secret_key_b64, alpha_b64) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(secret_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(alpha_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ecvrfP256Prove(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Derive the base64 ECVRF-P256 public key from a base64 secret key.
+ * @param {string} secret_key_b64
+ * @returns {string}
+ */
+export function ecvrfP256PublicKey(secret_key_b64) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(secret_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ecvrfP256PublicKey(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Verify an ECVRF-P256 proof. Returns the base64 output on success, or `null`
+ * on a cryptographic rejection.
+ * @param {string} public_key_b64
+ * @param {string} alpha_b64
+ * @param {string} proof_b64
+ * @returns {string | undefined}
+ */
+export function ecvrfP256Verify(public_key_b64, alpha_b64, proof_b64) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(public_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(alpha_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(proof_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.ecvrfP256Verify(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        let v4;
+        if (r0 !== 0) {
+            v4 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        }
+        return v4;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Encrypt a base64 private key with a session key. Returns base64 ciphertext.
  * @param {string} private_key_b64
@@ -603,6 +891,91 @@ export function generateSigningKeyPairSuite(suite, level) {
     }
 }
 
+/**
+ * HKDF-SHA512 (RFC 5869) extract-then-expand over base64-encoded inputs.
+ *
+ * Derives `length` bytes of output keying material and returns it as base64.
+ * `salt_b64` and `ikm_b64` are base64; `info` is a UTF-8 context label (bound
+ * into Expand for domain separation). An empty `salt_b64` means "not provided"
+ * (HashLen zero bytes, RFC 5869 §2.2).
+ *
+ * Byte-for-byte identical to `metamorphic_crypto::hkdf::hkdf_sha512` (native /
+ * Elixir NIF) and to `@noble/hashes` / WebCrypto HKDF-SHA-512 for the same
+ * inputs — the guarantee that a wrapping key derived in the browser matches
+ * one derived anywhere else.
+ * @param {string} salt_b64
+ * @param {string} ikm_b64
+ * @param {string} info
+ * @param {number} length
+ * @returns {string}
+ */
+export function hkdfSha512(salt_b64, ikm_b64, info, length) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(salt_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(ikm_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(info, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.hkdfSha512(retptr, ptr0, len0, ptr1, len1, ptr2, len2, length);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr4 = r0;
+        var len4 = r1;
+        if (r3) {
+            ptr4 = 0; len4 = 0;
+            throw takeObject(r2);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred5_0, deferred5_1, 1);
+    }
+}
+
+/**
+ * HMAC-SHA256 of base64 `msg` under base64 `key`. Returns the 32-byte tag as
+ * base64. Any key length is accepted (RFC 2104).
+ * @param {string} key_b64
+ * @param {string} msg_b64
+ * @returns {string}
+ */
+export function hmacSha256(key_b64, msg_b64) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(msg_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.hmacSha256(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Open a CNSA-2.0 (or legacy) hybrid ciphertext, supplying the context label
  * used at seal time for the new suites. Returns base64-encoded plaintext.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@f0rest8/metamorphic-crypto",
   "type": "module",
   "description": "Zero-knowledge end-to-end encryption with post-quantum hybrid KEM (ML-KEM + X25519) and an opt-in CNSA 2.0 suite axis (matched-strength hybrid + pure ML-KEM-1024 / ML-DSA-87 / AES-256-GCM)",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",