@f0rest8/metamorphic-crypto 0.6.0 → 0.7.1

package/README.md

@@ -1,6 +1,6 @@
 # @f0rest8/metamorphic-crypto
 
-Zero-knowledge end-to-end encryption with post-quantum hybrid KEM (ML-KEM-512/768/1024 + X25519).
+Zero-knowledge end-to-end encryption with post-quantum hybrid KEM (ML-KEM-512/768/1024 + X25519), hybrid PQ signatures (ML-DSA + Ed25519), and an opt-in CNSA 2.0 suite axis.
 
 Built for [Metamorphic](https://metamorphic.app) and [Mosslet](https://mosslet.com) — privacy-first apps by [Moss Piglet Corporation](https://mosspiglet.dev) where all user data is encrypted client-side and the server only stores opaque ciphertext.
 
@@ -218,6 +218,49 @@ across native Rust, WASM, and the Elixir NIF.
 > composite remains at least as strong as Ed25519 even if a flaw is found in the
 > young post-quantum implementation. Pinned and tracked for the FIPS-mode roadmap.
 
+### CNSA 2.0 suite axis (opt-in)
+
+Everything above is the default **`hybrid`** suite (classical+PQ strict-AND). If
+you have no specific mandate, that is the recommended choice. For deployments
+that must follow the NSA's **CNSA 2.0** suite (NIST IR 8547), a `suite` argument
+raises the posture. It is **orthogonal** to the `"cat1"`/`"cat3"`/`"cat5"` level,
+so you have two independent knobs.
+
+| `suite` string | What it is | Status |
+|----------------|------------|--------|
+| `"hybrid"` | Existing classical+PQ strict-AND. Byte-for-byte unchanged. | **Default, recommended** |
+| `"hybridMatched"` | Classical partner matched to the PQ category (KEM: Cat-3→X448, Cat-5→P-521 · Sign: Cat-3→Ed448, Cat-5→ECDSA-P-521) | Opt-in |
+| `"pureCnsa2"` | Pure post-quantum, no classical half (ML-KEM-1024 / AES-256-GCM; ML-DSA-87) | Opt-in, **Cat-5 only** |
+
+```js
+import {
+  generateHybridKeyPairSuite, hybridSealSuite, hybridOpenWithContext,
+  generateSigningKeyPairSuite, sign, verify,
+} from "@f0rest8/metamorphic-crypto";
+
+// Pure CNSA-2.0 KEM box (ML-KEM-1024 + AES-256-GCM)
+const kp = generateHybridKeyPairSuite("pureCnsa2", "cat5"); // { publicKey, secretKey }
+const sealed = hybridSealSuite(plaintextBase64, kp.publicKey, "pureCnsa2", "cat5");
+// Open with the context label used at seal time (default "metamorphic/seal/v1"):
+const opened = hybridOpenWithContext(sealed, kp.secretKey, "metamorphic/seal/v1"); // base64
+
+// Pure ML-DSA-87 signatures — sign/verify auto-detect the suite from the tag
+const sk = generateSigningKeyPairSuite("pureCnsa2", "cat5");
+const sig = sign(btoa("checkpoint"), "metamorphic/sign/v1", sk.secretKey);
+const ok = verify(btoa("checkpoint"), "metamorphic/sign/v1", sig, sk.publicKey); // true
+```
+
+The new suites bind a versioned **context label** (`"<namespace>/<purpose>/v<major>"`)
+into the seal — use `hybridSealSuiteWithContext(..., "mosslet/seal/v1")` for a
+custom per-tenant namespace and open with the same label. `sealForUserWithSuite`
+mirrors `sealForUser` with the suite/level appended (legacy X25519 fallback when
+no PQ key is present).
+
+> **Honest claims.** "CNSA 2.0 algorithm suite, NCC-audited components,
+> pure-Rust, memory-safe (`forbid-unsafe`)" — **not** "FIPS 140-3 validated."
+> `pureCnsa2` drops the classical backstop, so the strict-AND `hybrid` default
+> stays recommended until the lattice implementations are independently audited.
+
 ## Security levels
 
 | Level | ML-KEM | NIST Category | Equivalent | Default |

package/metamorphic_crypto.d.ts

@@ -77,6 +77,11 @@ export function generateHybridKeyPair1024(): any;
  */
 export function generateHybridKeyPair512(): any;
 
+/**
+ * Generate a keypair for `(suite, level)`. Returns JSON: `{ publicKey, secretKey }`.
+ */
+export function generateHybridKeyPairSuite(suite: string, level: string): any;
+
 /**
  * Generate a random 32-byte symmetric key (base64).
  */
@@ -105,6 +110,35 @@ export function generateSalt(): string;
  */
 export function generateSigningKeyPair(level: string): any;
 
+/**
+ * Generate a signing keypair for a full CNSA-2.0 `(suite, level)`.
+ *
+ * `suite` is `"hybrid"` (default), `"hybridMatched"` (Cat-3→Ed448,
+ * Cat-5→ECDSA-P-521), or `"pureCnsa2"` (ML-DSA-87 only, Cat-5). `level` is
+ * `"cat2"`/`"cat3"`/`"cat5"`. `sign` / `verify` / `deriveSigningPublicKey`
+ * auto-detect the suite from the key/signature version tag, so no suite
+ * argument is needed there. Returns JSON: `{ publicKey, secretKey }`.
+ */
+export function generateSigningKeyPairSuite(suite: string, level: string): any;
+
+/**
+ * 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.
+ */
+export function hybridOpenWithContext(ciphertext_b64: string, seed_b64: string, context_label: string): string;
+
+/**
+ * Seal plaintext (base64) to a `(suite, level)` combined public key, binding
+ * the default `"metamorphic/seal/v1"` context label. Returns base64 ciphertext.
+ */
+export function hybridSealSuite(plaintext_b64: string, combined_pk_b64: string, suite: string, level: string): string;
+
+/**
+ * Seal plaintext (base64) to a `(suite, level)` combined public key, binding a
+ * custom `context_label`. Returns base64 ciphertext.
+ */
+export function hybridSealSuiteWithContext(plaintext_b64: string, combined_pk_b64: string, suite: string, level: string, context_label: string): string;
+
 /**
  * Check if a base64 ciphertext is hybrid (v2/v3) format.
  */
@@ -134,6 +168,12 @@ export function sealForUser(plaintext_b64: string, public_key_b64: string, pq_pu
  */
 export function sealForUserWithLevel(plaintext_b64: string, public_key_b64: string, pq_public_key_b64: string | null | undefined, level: string): string;
 
+/**
+ * Seal plaintext (base64) to a user's key(s) under a full `(suite, level)`.
+ * Falls back to legacy X25519 if `pq_public_key_b64` is absent/empty.
+ */
+export function sealForUserWithSuite(plaintext_b64: string, public_key_b64: string, pq_public_key_b64: string | null | undefined, suite: string, level: string): string;
+
 /**
  * SHA-256 (SHA-2) digest of base64-encoded `data`. Returns the 32-byte digest as base64.
  */
@@ -202,6 +242,11 @@ export interface InitOutput {
     readonly generateHybridKeyPair: () => number;
     readonly generateHybridKeyPair1024: () => number;
     readonly isHybridCiphertext: (a: number, b: number) => number;
+    readonly generateHybridKeyPairSuite: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly hybridSealSuite: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly hybridSealSuiteWithContext: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+    readonly hybridOpenWithContext: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly sealForUserWithSuite: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
     readonly generateKey: (a: number) => void;
     readonly generateKeyPair: () => number;
     readonly generateSalt: (a: number) => void;
@@ -216,13 +261,14 @@ export interface InitOutput {
     readonly sha256: (a: number, b: number, c: number) => void;
     readonly sha512: (a: number, b: number, c: number) => void;
     readonly generateSigningKeyPair: (a: number, b: number, c: number) => void;
+    readonly generateSigningKeyPairSuite: (a: number, b: number, c: number, d: number, e: number) => void;
     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 decryptPrivateKeyWithRecovery: (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 encryptSecretboxString: (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 encryptSecretboxString: (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

@@ -448,6 +448,32 @@ export function generateHybridKeyPair512() {
     return takeObject(ret);
 }
 
+/**
+ * Generate a keypair for `(suite, level)`. Returns JSON: `{ publicKey, secretKey }`.
+ * @param {string} suite
+ * @param {string} level
+ * @returns {any}
+ */
+export function generateHybridKeyPairSuite(suite, level) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(suite, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(level, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.generateHybridKeyPairSuite(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);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Generate a random 32-byte symmetric key (base64).
  * @returns {string}
@@ -545,6 +571,164 @@ export function generateSigningKeyPair(level) {
     }
 }
 
+/**
+ * Generate a signing keypair for a full CNSA-2.0 `(suite, level)`.
+ *
+ * `suite` is `"hybrid"` (default), `"hybridMatched"` (Cat-3→Ed448,
+ * Cat-5→ECDSA-P-521), or `"pureCnsa2"` (ML-DSA-87 only, Cat-5). `level` is
+ * `"cat2"`/`"cat3"`/`"cat5"`. `sign` / `verify` / `deriveSigningPublicKey`
+ * auto-detect the suite from the key/signature version tag, so no suite
+ * argument is needed there. Returns JSON: `{ publicKey, secretKey }`.
+ * @param {string} suite
+ * @param {string} level
+ * @returns {any}
+ */
+export function generateSigningKeyPairSuite(suite, level) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(suite, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(level, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.generateSigningKeyPairSuite(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);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * 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.
+ * @param {string} ciphertext_b64
+ * @param {string} seed_b64
+ * @param {string} context_label
+ * @returns {string}
+ */
+export function hybridOpenWithContext(ciphertext_b64, seed_b64, context_label) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(ciphertext_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(seed_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(context_label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.hybridOpenWithContext(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);
+        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);
+    }
+}
+
+/**
+ * Seal plaintext (base64) to a `(suite, level)` combined public key, binding
+ * the default `"metamorphic/seal/v1"` context label. Returns base64 ciphertext.
+ * @param {string} plaintext_b64
+ * @param {string} combined_pk_b64
+ * @param {string} suite
+ * @param {string} level
+ * @returns {string}
+ */
+export function hybridSealSuite(plaintext_b64, combined_pk_b64, suite, level) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(plaintext_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(combined_pk_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(suite, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(level, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.hybridSealSuite(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        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 ptr5 = r0;
+        var len5 = r1;
+        if (r3) {
+            ptr5 = 0; len5 = 0;
+            throw takeObject(r2);
+        }
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred6_0, deferred6_1, 1);
+    }
+}
+
+/**
+ * Seal plaintext (base64) to a `(suite, level)` combined public key, binding a
+ * custom `context_label`. Returns base64 ciphertext.
+ * @param {string} plaintext_b64
+ * @param {string} combined_pk_b64
+ * @param {string} suite
+ * @param {string} level
+ * @param {string} context_label
+ * @returns {string}
+ */
+export function hybridSealSuiteWithContext(plaintext_b64, combined_pk_b64, suite, level, context_label) {
+    let deferred7_0;
+    let deferred7_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(plaintext_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(combined_pk_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(suite, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(level, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(context_label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.hybridSealSuiteWithContext(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        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 ptr6 = r0;
+        var len6 = r1;
+        if (r3) {
+            ptr6 = 0; len6 = 0;
+            throw takeObject(r2);
+        }
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred7_0, deferred7_1, 1);
+    }
+}
+
 /**
  * Check if a base64 ciphertext is hybrid (v2/v3) format.
  * @param {string} ciphertext_b64
@@ -704,6 +888,51 @@ export function sealForUserWithLevel(plaintext_b64, public_key_b64, pq_public_ke
     }
 }
 
+/**
+ * Seal plaintext (base64) to a user's key(s) under a full `(suite, level)`.
+ * Falls back to legacy X25519 if `pq_public_key_b64` is absent/empty.
+ * @param {string} plaintext_b64
+ * @param {string} public_key_b64
+ * @param {string | null | undefined} pq_public_key_b64
+ * @param {string} suite
+ * @param {string} level
+ * @returns {string}
+ */
+export function sealForUserWithSuite(plaintext_b64, public_key_b64, pq_public_key_b64, suite, level) {
+    let deferred7_0;
+    let deferred7_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(plaintext_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(public_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(pq_public_key_b64) ? 0 : passStringToWasm0(pq_public_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(suite, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(level, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.sealForUserWithSuite(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        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 ptr6 = r0;
+        var len6 = r1;
+        if (r3) {
+            ptr6 = 0; len6 = 0;
+            throw takeObject(r2);
+        }
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred7_0, deferred7_1, 1);
+    }
+}
+
 /**
  * SHA-256 (SHA-2) digest of base64-encoded `data`. Returns the 32-byte digest as base64.
  * @param {string} data_b64
@@ -992,34 +1221,34 @@ export function verify(message_b64, context, signature_b64, public_key_b64) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wbindgen_debug_string_56c147eb1a51f0c4: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
             const ret = debugString(getObject(arg1));
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_is_function_147961669f068cd4: function(arg0) {
+        __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
             const ret = typeof(getObject(arg0)) === 'function';
             return ret;
         },
-        __wbg___wbindgen_is_object_3a2c414391dbf751: function(arg0) {
+        __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
             const val = getObject(arg0);
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_string_6541b0f6ecd4e8e5: function(arg0) {
+        __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
             const ret = typeof(getObject(arg0)) === 'string';
             return ret;
         },
-        __wbg___wbindgen_is_undefined_4410e3c20a99fa97: function(arg0) {
+        __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
             const ret = getObject(arg0) === undefined;
             return ret;
         },
-        __wbg___wbindgen_throw_bbadd78c1bac3a77: function(arg0, arg1) {
+        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_call_ec09a4cf93377d3a: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments); },
@@ -1030,7 +1259,7 @@ function __wbg_get_imports() {
         __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
             getObject(arg0).getRandomValues(getObject(arg1));
         }, arguments); },
-        __wbg_length_68a9d5278d084f4f: function(arg0) {
+        __wbg_length_1f0964f4a5e2c6d8: function(arg0) {
             const ret = getObject(arg0).length;
             return ret;
         },
@@ -1038,11 +1267,11 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).msCrypto;
             return addHeapObject(ret);
         },
-        __wbg_new_20b778a4c5c691c3: function() {
+        __wbg_new_da52cf8fe3429cb2: function() {
             const ret = new Object();
             return addHeapObject(ret);
         },
-        __wbg_new_with_length_4b57a7a5dc67221c: function(arg0) {
+        __wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
             const ret = new Uint8Array(arg0 >>> 0);
             return addHeapObject(ret);
         },
@@ -1054,7 +1283,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).process;
             return addHeapObject(ret);
         },
-        __wbg_prototypesetcall_956c7493c68e29b4: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
         __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
@@ -1064,27 +1293,27 @@ function __wbg_get_imports() {
             const ret = module.require;
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_set_a6ba3ac0e634b822: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
             return ret;
         }, arguments); },
-        __wbg_static_accessor_GLOBAL_60a4124bab7dcc9a: function() {
+        __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_static_accessor_GLOBAL_THIS_95ca6460658b5d13: function() {
+        __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
             const ret = typeof globalThis === 'undefined' ? null : globalThis;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_static_accessor_SELF_4c95f759a91e9aae: function() {
+        __wbg_static_accessor_SELF_146583524fe1469b: function() {
             const ret = typeof self === 'undefined' ? null : self;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_static_accessor_WINDOW_44b435597f9e9ee7: function() {
+        __wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_subarray_42216645a367cd7a: function(arg0, arg1, arg2) {
+        __wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
             return addHeapObject(ret);
         },

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@f0rest8/metamorphic-crypto",
   "type": "module",
-  "description": "Zero-knowledge end-to-end encryption with post-quantum hybrid KEM (ML-KEM-512/768/1024 + X25519)",
-  "version": "0.6.0",
+  "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.7.1",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",