wasm-pqc-subtle 0.1.3 → 0.2.4

package/README.md

@@ -1,10 +1,221 @@
 # wasm-pqc-subtle
 
-Library for post-quantum encryption
+Post-quantum key encapsulation, digital signatures, and password hashing for the browser. A WebAssembly library implementing [ML-KEM](https://csrc.nist.gov/pubs/fips/203/final) (FIPS 203), [ML-DSA](https://csrc.nist.gov/pubs/fips/204/final) (FIPS 204), and [Argon2](https://datatracker.ietf.org/doc/html/rfc9106), compiled from Rust.
 
-# Prerequisites
-- Rust
-- wasm-pack
+## Overview
 
-## Build
-`make all`
+This library provides ML-KEM, ML-DSA, and Argon2 via WebAssembly, enabling post-quantum key exchange, digital signatures, and modern password hashing in web applications. It wraps the [`ml-kem`](https://crates.io/crates/ml-kem), [`ml-dsa`](https://crates.io/crates/ml-dsa), and [`argon2`](https://crates.io/crates/argon2) Rust crates using [`wasm-bindgen`](https://crates.io/crates/wasm-bindgen) and targets the `wasm32-unknown-unknown` platform.
+
+**WASM binary size:** ~68 KB (optimized with LTO + binaryen)
+
+### Supported Algorithms
+
+| Algorithm | NIST Security Level | Use Case |
+|-----------|-------------------|----------|
+| ML-KEM-768 | Level 3 (~192-bit) | Default. Recommended for most applications. |
+| ML-KEM-1024 | Level 5 (~256-bit) | Higher security margin. |
+| ML-DSA-44 | Level 2 (~128-bit) | Digital signatures (compact). |
+| ML-DSA-65 | Level 3 (~192-bit) | Standard digital signatures. |
+| ML-DSA-87 | Level 5 (~256-bit) | High-security digital signatures. |
+
+## Installation
+
+```bash
+npm install wasm-pqc-subtle
+```
+
+## Usage
+
+### Key Encapsulation (ML-KEM)
+
+```javascript
+import init, {
+  ml_kem_768_generate_keypair,
+  ml_kem_768_encapsulate,
+  ml_kem_768_decapsulate,
+} from "wasm-pqc-subtle";
+
+await init();
+
+// Generate a keypair
+const keypair = ml_kem_768_generate_keypair();
+
+// Encapsulate: produce a ciphertext and shared secret from the public key
+const result = ml_kem_768_encapsulate(keypair.public_key);
+
+// Decapsulate: recover the shared secret from the ciphertext and secret key
+const sharedSecret = ml_kem_768_decapsulate(keypair.secret_key, result.ciphertext);
+
+// result.shared_secret and sharedSecret are identical
+```
+
+ML-KEM-1024 functions follow the same pattern (`ml_kem_1024_generate_keypair`, etc.). Convenience aliases `kem_generate_keypair`, `kem_encapsulate`, and `kem_decapsulate` default to ML-KEM-768.
+
+### Digital Signatures (ML-DSA)
+
+```javascript
+import init, {
+  ml_dsa_65_generate_keypair,
+  ml_dsa_65_sign,
+  ml_dsa_65_verify,
+} from "wasm-pqc-subtle";
+
+await init();
+
+const message = new TextEncoder().encode("Hello Post-Quantum!");
+
+// Generate a keypair
+const keypair = ml_dsa_65_generate_keypair();
+
+// Sign
+const signature = ml_dsa_65_sign(keypair.secret_key, message);
+
+// Verify
+const isValid = ml_dsa_65_verify(keypair.public_key, message, signature);
+```
+
+ML-DSA-44 and ML-DSA-87 functions follow the same pattern (`ml_dsa_44_generate_keypair`, etc.). Convenience aliases `dsa_generate_keypair`, `dsa_sign`, and `dsa_verify` default to ML-DSA-65.
+
+### Password Hashing (Argon2)
+
+```javascript
+import init, { argon2id_hash, argon2_verify } from "wasm-pqc-subtle";
+
+await init();
+
+const password = new TextEncoder().encode("correct horse battery staple");
+
+// Hash using Argon2id with a random salt and recommended defaults
+const phc = argon2id_hash(password); // returns a PHC string like "$argon2id$v=19$m=...$...$..."
+
+// Verify
+const ok = argon2_verify(password, phc); // true
+const bad = argon2_verify(new TextEncoder().encode("wrong"), phc); // false
+```
+
+Notes:
+- `argon2id_hash` generates a secure random salt internally and returns a standard PHC string.
+- `argon2_verify` parses the PHC string and verifies using parameters embedded in it.
+- Defaults are tuned by the upstream `argon2` crate and suitable for browsers; adjust at build-time if you need stricter limits.
+
+## API
+
+### ML-KEM API
+
+#### `ml_kem_768_generate_keypair() -> KemKeyPair`
+
+Generates an ML-KEM-768 key pair.
+
+#### `ml_kem_768_encapsulate(public_key: Uint8Array) -> CiphertextAndSharedSecret`
+
+Encapsulates against a public key, returning a ciphertext and shared secret.
+
+#### `ml_kem_768_decapsulate(secret_key: Uint8Array, ciphertext: Uint8Array) -> Uint8Array`
+
+Decapsulates a ciphertext with a secret key, returning the shared secret.
+
+#### `ml_kem_1024_generate_keypair()` / `ml_kem_1024_encapsulate()` / `ml_kem_1024_decapsulate()`
+
+Same interface as above, using ML-KEM-1024 parameters.
+
+#### `kem_generate_keypair()` / `kem_encapsulate()` / `kem_decapsulate()`
+
+Convenience aliases that use ML-KEM-768.
+
+### ML-DSA API
+
+#### `ml_dsa_65_generate_keypair() -> DsaKeyPair`
+
+Generates an ML-DSA-65 key pair.
+
+#### `ml_dsa_65_sign(secret_key: Uint8Array, message: Uint8Array) -> Uint8Array`
+
+Signs a message with a secret key.
+
+#### `ml_dsa_65_verify(public_key: Uint8Array, message: Uint8Array, signature: Uint8Array) -> boolean`
+
+Verifies a signature against a public key and message.
+
+#### `ml_dsa_44_generate_keypair()` / `ml_dsa_44_sign()` / `ml_dsa_44_verify()`
+#### `ml_dsa_87_generate_keypair()` / `ml_dsa_87_sign()` / `ml_dsa_87_verify()`
+
+Same interface as above, using ML-DSA-44 or ML-DSA-87 parameters.
+
+#### `dsa_generate_keypair()` / `dsa_sign()` / `dsa_verify()`
+
+Convenience aliases that use ML-DSA-65.
+
+### Argon2 API
+
+#### `argon2id_hash(password: Uint8Array) -> string`
+
+Hashes a password using Argon2id (v=0x13) with a securely generated random salt. Returns a PHC-formatted string suitable for storage.
+
+#### `argon2_verify(password: Uint8Array, phc: string) -> boolean`
+
+Verifies a password against a PHC-formatted Argon2 hash.
+
+### Types
+
+```typescript
+class KemKeyPair {
+  readonly public_key: Uint8Array;
+  readonly secret_key: Uint8Array;
+}
+
+class DsaKeyPair {
+  readonly public_key: Uint8Array;
+  readonly secret_key: Uint8Array;
+}
+
+class CiphertextAndSharedSecret {
+  readonly ciphertext: Uint8Array;
+  readonly shared_secret: Uint8Array;
+}
+```
+
+## Building from Source
+
+### Prerequisites
+
+- [Rust](https://rustup.rs/)
+- [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/)
+- [binaryen](https://github.com/WebAssembly/binaryen) (for `wasm-opt`)
+
+### Build
+
+```bash
+make all
+```
+
+This runs `wasm-pack build --target web --release` followed by `wasm-opt -Oz` for size optimization. Output goes to `./pkg/`.
+
+### Test
+
+Open `index.html` in a browser (served over HTTP) to run the ML-KEM, ML-DSA, and Argon2 test suite.
+
+### Publish
+
+```bash
+make publish
+```
+
+## Export Control Notice
+
+This software implements cryptographic functionality and is subject to export controls.
+
+**ECCN:** 5D002 — This software is classified under Export Control Classification Number 5D002 ("Information Security" software) on the Commerce Control List (CCL).
+
+**License Exception:** This software is publicly available open-source encryption source code, distributed under License Exception TSU (Technology and Software Unrestricted) pursuant to 15 CFR 740.13(e) of the U.S. Export Administration Regulations (EAR). The compiled WebAssembly binary is distributed under License Exception ENC pursuant to 15 CFR 740.17(b).
+
+**Notification:** In accordance with 15 CFR 742.15(b), a notification has been or should be submitted to the Bureau of Industry and Security (crypt@bis.gov) and the ENC Encryption Request Coordinator (enc@nsa.gov) prior to or concurrent with the first public release of this software.
+
+**Restrictions:** This software may not be exported or re-exported to any country in U.S. Country Group E:1 (currently Cuba, Iran, North Korea, Syria, and the Crimea/Donetsk/Luhansk regions of Ukraine) or to any person or entity on the BIS Denied Persons List, Entity List, or Unverified List.
+
+**International:** Users outside the United States should be aware that similar controls may apply under the Wassenaar Arrangement, EU Dual-Use Regulation (EU 2021/821), and other national export control regimes. The Wassenaar Arrangement's General Software Note provides decontrol for software that is "in the public domain," though implementation varies by jurisdiction.
+
+**This is not legal advice.** Export control regulations are complex and subject to change. Consult a qualified export control attorney for compliance guidance specific to your circumstances.
+
+## License
+
+See repository for license terms.

package/package.json

@@ -4,8 +4,8 @@
   "collaborators": [
     "github.com/geoffsee"
   ],
-  "description": "Library for post-quantum encryption",
-  "version": "0.1.3",
+  "description": "Library for cross-platform post-quantum cryptography",
+  "version": "0.2.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/geoffsee/wasm-pqc-subtle"

package/wasm_pqc_subtle.d.ts

@@ -1,38 +1,187 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * Container for ML-KEM ciphertext + derived shared secret
+ */
 export class CiphertextAndSharedSecret {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Returns a copy of the ML-KEM ciphertext
+     */
     readonly ciphertext: Uint8Array;
+    /**
+     * Returns a copy of the 32-byte shared secret derived from encapsulation
+     */
     readonly shared_secret: Uint8Array;
 }
 
+/**
+ * Key pair for ML-DSA (post-quantum digital signature scheme)
+ */
+export class DsaKeyPair {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Returns a copy of the ML-DSA verifying (public) key as bytes
+     */
+    readonly public_key: Uint8Array;
+    /**
+     * Returns a copy of the ML-DSA signing (secret) key as bytes
+     */
+    readonly secret_key: Uint8Array;
+}
+
+/**
+ * Key pair for ML-KEM (post-quantum KEM)
+ */
 export class KemKeyPair {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Returns a copy of the ML-KEM public key (encapsulation key) as bytes
+     */
     readonly public_key: Uint8Array;
+    /**
+     * Returns a copy of the ML-KEM secret key (decapsulation key) as bytes
+     */
     readonly secret_key: Uint8Array;
 }
 
+/**
+ * Verifies that the provided password matches the stored PHC hash string.
+ *
+ * Returns `true` if the password is correct.
+ */
+export function argon2_verify(password: Uint8Array, phc: string): boolean;
+
+/**
+ * Hashes a password using Argon2id (v=0x13, default/recommended parameters) and returns PHC string.
+ *
+ * Suitable for password storage. Includes random salt.
+ */
+export function argon2id_hash(password: Uint8Array): string;
+
+/**
+ * Alias: generate ML-DSA-65 key pair (current default security level)
+ */
+export function dsa_generate_keypair(): DsaKeyPair;
+
+/**
+ * Alias: sign with ML-DSA-65
+ */
+export function dsa_sign(secret_key_bytes: Uint8Array, message: Uint8Array): Uint8Array;
+
+/**
+ * Alias: verify with ML-DSA-65
+ */
+export function dsa_verify(public_key_bytes: Uint8Array, message: Uint8Array, signature_bytes: Uint8Array): boolean;
+
+/**
+ * Alias: decapsulate using ML-KEM-768 secret key + ciphertext
+ */
 export function kem_decapsulate(secret_key_bytes: Uint8Array, ciphertext_bytes: Uint8Array): Uint8Array;
 
+/**
+ * Alias: encapsulate using ML-KEM-768 public key
+ */
 export function kem_encapsulate(public_key_bytes: Uint8Array): CiphertextAndSharedSecret;
 
+/**
+ * Alias: generate ML-KEM-768 key pair
+ */
 export function kem_generate_keypair(): KemKeyPair;
 
+/**
+ * Generates a fresh ML-DSA-44 key pair.
+ */
+export function ml_dsa_44_generate_keypair(): DsaKeyPair;
+
+/**
+ * Signs a message using an ML-DSA-44 secret key.
+ */
+export function ml_dsa_44_sign(secret_key_bytes: Uint8Array, message: Uint8Array): Uint8Array;
+
+/**
+ * Verifies an ML-DSA-44 signature against a message and public key.
+ */
+export function ml_dsa_44_verify(public_key_bytes: Uint8Array, message: Uint8Array, signature_bytes: Uint8Array): boolean;
+
+/**
+ * Generates a fresh ML-DSA-65 key pair.
+ */
+export function ml_dsa_65_generate_keypair(): DsaKeyPair;
+
+/**
+ * Signs a message using an ML-DSA-65 secret key.
+ */
+export function ml_dsa_65_sign(secret_key_bytes: Uint8Array, message: Uint8Array): Uint8Array;
+
+/**
+ * Verifies an ML-DSA-65 signature.
+ */
+export function ml_dsa_65_verify(public_key_bytes: Uint8Array, message: Uint8Array, signature_bytes: Uint8Array): boolean;
+
+/**
+ * Generates a fresh ML-DSA-87 key pair.
+ */
+export function ml_dsa_87_generate_keypair(): DsaKeyPair;
+
+/**
+ * Signs a message using an ML-DSA-87 secret key.
+ */
+export function ml_dsa_87_sign(secret_key_bytes: Uint8Array, message: Uint8Array): Uint8Array;
+
+/**
+ * Verifies an ML-DSA-87 signature.
+ */
+export function ml_dsa_87_verify(public_key_bytes: Uint8Array, message: Uint8Array, signature_bytes: Uint8Array): boolean;
+
+/**
+ * Performs ML-KEM-1024 decapsulation.
+ */
 export function ml_kem_1024_decapsulate(secret_key_bytes: Uint8Array, ciphertext_bytes: Uint8Array): Uint8Array;
 
+/**
+ * Performs ML-KEM-1024 encapsulation.
+ */
 export function ml_kem_1024_encapsulate(public_key_bytes: Uint8Array): CiphertextAndSharedSecret;
 
+/**
+ * Generates a fresh ML-KEM-1024 key pair using OS RNG.
+ */
 export function ml_kem_1024_generate_keypair(): KemKeyPair;
 
+/**
+ * Performs ML-KEM-768 decapsulation to recover the shared secret.
+ *
+ * # Arguments
+ * * `secret_key_bytes`  – Encoded ML-KEM-768 decapsulation key (2400 bytes)
+ * * `ciphertext_bytes`  – ML-KEM-768 ciphertext (1088 bytes)
+ *
+ * Returns: 32-byte shared secret (or error)
+ */
 export function ml_kem_768_decapsulate(secret_key_bytes: Uint8Array, ciphertext_bytes: Uint8Array): Uint8Array;
 
+/**
+ * Performs ML-KEM-768 encapsulation using the provided public key.
+ *
+ * # Arguments
+ * * `public_key_bytes` - Encoded ML-KEM-768 encapsulation key (1184 bytes)
+ *
+ * Returns: ciphertext + 32-byte shared secret
+ */
 export function ml_kem_768_encapsulate(public_key_bytes: Uint8Array): CiphertextAndSharedSecret;
 
+/**
+ * Generates a fresh ML-KEM-768 key pair using OS RNG.
+ *
+ * Returns: `KemKeyPair` containing public & secret key bytes.
+ */
 export function ml_kem_768_generate_keypair(): KemKeyPair;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
@@ -48,16 +197,34 @@ export interface InitOutput {
     readonly kem_generate_keypair: (a: number) => void;
     readonly kem_encapsulate: (a: number, b: number, c: number) => void;
     readonly kem_decapsulate: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly ml_dsa_44_generate_keypair: (a: number) => void;
+    readonly ml_dsa_44_sign: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly ml_dsa_44_verify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly ml_dsa_87_generate_keypair: (a: number) => void;
+    readonly ml_dsa_87_sign: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly ml_dsa_87_verify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly dsa_generate_keypair: (a: number) => void;
+    readonly dsa_sign: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly dsa_verify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly argon2id_hash: (a: number, b: number, c: number) => void;
+    readonly argon2_verify: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly ml_kem_768_decapsulate: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly ml_dsa_65_sign: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly ml_kem_768_encapsulate: (a: number, b: number, c: number) => void;
+    readonly ml_dsa_65_verify: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly ml_kem_768_generate_keypair: (a: number) => void;
+    readonly ml_dsa_65_generate_keypair: (a: number) => void;
     readonly kemkeypair_secret_key: (a: number, b: number) => void;
     readonly kemkeypair_public_key: (a: number, b: number) => void;
     readonly __wbg_kemkeypair_free: (a: number, b: number) => void;
+    readonly dsakeypair_secret_key: (a: number, b: number) => void;
+    readonly dsakeypair_public_key: (a: number, b: number) => void;
+    readonly __wbg_dsakeypair_free: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number) => void;
     readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
-    readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
-    readonly __wbindgen_export3: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
 }
 
 export type SyncInitInput = BufferSource | WebAssembly.Module;

package/wasm_pqc_subtle.js

@@ -1,5 +1,8 @@
 /* @ts-self-types="./wasm_pqc_subtle.d.ts" */
 
+/**
+ * Container for ML-KEM ciphertext + derived shared secret
+ */
 export class CiphertextAndSharedSecret {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -19,6 +22,7 @@ export class CiphertextAndSharedSecret {
         wasm.__wbg_ciphertextandsharedsecret_free(ptr, 0);
     }
     /**
+     * Returns a copy of the ML-KEM ciphertext
      * @returns {Uint8Array}
      */
     get ciphertext() {
@@ -28,13 +32,14 @@ export class CiphertextAndSharedSecret {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export2(r0, r1 * 1, 1);
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
+     * Returns a copy of the 32-byte shared secret derived from encapsulation
      * @returns {Uint8Array}
      */
     get shared_secret() {
@@ -44,7 +49,7 @@ export class CiphertextAndSharedSecret {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export2(r0, r1 * 1, 1);
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -53,6 +58,67 @@ export class CiphertextAndSharedSecret {
 }
 if (Symbol.dispose) CiphertextAndSharedSecret.prototype[Symbol.dispose] = CiphertextAndSharedSecret.prototype.free;
 
+/**
+ * Key pair for ML-DSA (post-quantum digital signature scheme)
+ */
+export class DsaKeyPair {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DsaKeyPair.prototype);
+        obj.__wbg_ptr = ptr;
+        DsaKeyPairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DsaKeyPairFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dsakeypair_free(ptr, 0);
+    }
+    /**
+     * Returns a copy of the ML-DSA verifying (public) key as bytes
+     * @returns {Uint8Array}
+     */
+    get public_key() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ciphertextandsharedsecret_ciphertext(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns a copy of the ML-DSA signing (secret) key as bytes
+     * @returns {Uint8Array}
+     */
+    get secret_key() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ciphertextandsharedsecret_shared_secret(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) DsaKeyPair.prototype[Symbol.dispose] = DsaKeyPair.prototype.free;
+
+/**
+ * Key pair for ML-KEM (post-quantum KEM)
+ */
 export class KemKeyPair {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -72,6 +138,7 @@ export class KemKeyPair {
         wasm.__wbg_kemkeypair_free(ptr, 0);
     }
     /**
+     * Returns a copy of the ML-KEM public key (encapsulation key) as bytes
      * @returns {Uint8Array}
      */
     get public_key() {
@@ -81,13 +148,14 @@ export class KemKeyPair {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export2(r0, r1 * 1, 1);
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
+     * Returns a copy of the ML-KEM secret key (decapsulation key) as bytes
      * @returns {Uint8Array}
      */
     get secret_key() {
@@ -97,7 +165,7 @@ export class KemKeyPair {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export2(r0, r1 * 1, 1);
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -107,6 +175,147 @@ export class KemKeyPair {
 if (Symbol.dispose) KemKeyPair.prototype[Symbol.dispose] = KemKeyPair.prototype.free;
 
 /**
+ * Verifies that the provided password matches the stored PHC hash string.
+ *
+ * Returns `true` if the password is correct.
+ * @param {Uint8Array} password
+ * @param {string} phc
+ * @returns {boolean}
+ */
+export function argon2_verify(password, phc) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(password, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(phc, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.argon2_verify(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 r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Hashes a password using Argon2id (v=0x13, default/recommended parameters) and returns PHC string.
+ *
+ * Suitable for password storage. Includes random salt.
+ * @param {Uint8Array} password
+ * @returns {string}
+ */
+export function argon2id_hash(password) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(password, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.argon2id_hash(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);
+    }
+}
+
+/**
+ * Alias: generate ML-DSA-65 key pair (current default security level)
+ * @returns {DsaKeyPair}
+ */
+export function dsa_generate_keypair() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.dsa_generate_keypair(retptr);
+        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 DsaKeyPair.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Alias: sign with ML-DSA-65
+ * @param {Uint8Array} secret_key_bytes
+ * @param {Uint8Array} message
+ * @returns {Uint8Array}
+ */
+export function dsa_sign(secret_key_bytes, message) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.dsa_sign(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);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Alias: verify with ML-DSA-65
+ * @param {Uint8Array} public_key_bytes
+ * @param {Uint8Array} message
+ * @param {Uint8Array} signature_bytes
+ * @returns {boolean}
+ */
+export function dsa_verify(public_key_bytes, message, signature_bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(signature_bytes, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.dsa_verify(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);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Alias: decapsulate using ML-KEM-768 secret key + ciphertext
  * @param {Uint8Array} secret_key_bytes
  * @param {Uint8Array} ciphertext_bytes
  * @returns {Uint8Array}
@@ -114,9 +323,9 @@ if (Symbol.dispose) KemKeyPair.prototype[Symbol.dispose] = KemKeyPair.prototype.
 export function kem_decapsulate(secret_key_bytes, ciphertext_bytes) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(ciphertext_bytes, wasm.__wbindgen_export3);
+        const ptr1 = passArray8ToWasm0(ciphertext_bytes, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         wasm.kem_decapsulate(retptr, ptr0, len0, ptr1, len1);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -127,7 +336,7 @@ export function kem_decapsulate(secret_key_bytes, ciphertext_bytes) {
             throw takeObject(r2);
         }
         var v3 = getArrayU8FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
         return v3;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -135,13 +344,14 @@ export function kem_decapsulate(secret_key_bytes, ciphertext_bytes) {
 }
 
 /**
+ * Alias: encapsulate using ML-KEM-768 public key
  * @param {Uint8Array} public_key_bytes
  * @returns {CiphertextAndSharedSecret}
  */
 export function kem_encapsulate(public_key_bytes) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         wasm.kem_encapsulate(retptr, ptr0, len0);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -157,6 +367,7 @@ export function kem_encapsulate(public_key_bytes) {
 }
 
 /**
+ * Alias: generate ML-KEM-768 key pair
  * @returns {KemKeyPair}
  */
 export function kem_generate_keypair() {
@@ -176,6 +387,241 @@ export function kem_generate_keypair() {
 }
 
 /**
+ * Generates a fresh ML-DSA-44 key pair.
+ * @returns {DsaKeyPair}
+ */
+export function ml_dsa_44_generate_keypair() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.ml_dsa_44_generate_keypair(retptr);
+        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 DsaKeyPair.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Signs a message using an ML-DSA-44 secret key.
+ * @param {Uint8Array} secret_key_bytes
+ * @param {Uint8Array} message
+ * @returns {Uint8Array}
+ */
+export function ml_dsa_44_sign(secret_key_bytes, message) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ml_dsa_44_sign(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);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verifies an ML-DSA-44 signature against a message and public key.
+ * @param {Uint8Array} public_key_bytes
+ * @param {Uint8Array} message
+ * @param {Uint8Array} signature_bytes
+ * @returns {boolean}
+ */
+export function ml_dsa_44_verify(public_key_bytes, message, signature_bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(signature_bytes, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.ml_dsa_44_verify(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);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Generates a fresh ML-DSA-65 key pair.
+ * @returns {DsaKeyPair}
+ */
+export function ml_dsa_65_generate_keypair() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.dsa_generate_keypair(retptr);
+        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 DsaKeyPair.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Signs a message using an ML-DSA-65 secret key.
+ * @param {Uint8Array} secret_key_bytes
+ * @param {Uint8Array} message
+ * @returns {Uint8Array}
+ */
+export function ml_dsa_65_sign(secret_key_bytes, message) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.dsa_sign(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);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verifies an ML-DSA-65 signature.
+ * @param {Uint8Array} public_key_bytes
+ * @param {Uint8Array} message
+ * @param {Uint8Array} signature_bytes
+ * @returns {boolean}
+ */
+export function ml_dsa_65_verify(public_key_bytes, message, signature_bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(signature_bytes, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.dsa_verify(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);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Generates a fresh ML-DSA-87 key pair.
+ * @returns {DsaKeyPair}
+ */
+export function ml_dsa_87_generate_keypair() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.ml_dsa_87_generate_keypair(retptr);
+        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 DsaKeyPair.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Signs a message using an ML-DSA-87 secret key.
+ * @param {Uint8Array} secret_key_bytes
+ * @param {Uint8Array} message
+ * @returns {Uint8Array}
+ */
+export function ml_dsa_87_sign(secret_key_bytes, message) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ml_dsa_87_sign(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);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verifies an ML-DSA-87 signature.
+ * @param {Uint8Array} public_key_bytes
+ * @param {Uint8Array} message
+ * @param {Uint8Array} signature_bytes
+ * @returns {boolean}
+ */
+export function ml_dsa_87_verify(public_key_bytes, message, signature_bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(signature_bytes, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.ml_dsa_87_verify(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);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Performs ML-KEM-1024 decapsulation.
  * @param {Uint8Array} secret_key_bytes
  * @param {Uint8Array} ciphertext_bytes
  * @returns {Uint8Array}
@@ -183,9 +629,9 @@ export function kem_generate_keypair() {
 export function ml_kem_1024_decapsulate(secret_key_bytes, ciphertext_bytes) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(ciphertext_bytes, wasm.__wbindgen_export3);
+        const ptr1 = passArray8ToWasm0(ciphertext_bytes, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         wasm.ml_kem_1024_decapsulate(retptr, ptr0, len0, ptr1, len1);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -196,7 +642,7 @@ export function ml_kem_1024_decapsulate(secret_key_bytes, ciphertext_bytes) {
             throw takeObject(r2);
         }
         var v3 = getArrayU8FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
         return v3;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -204,13 +650,14 @@ export function ml_kem_1024_decapsulate(secret_key_bytes, ciphertext_bytes) {
 }
 
 /**
+ * Performs ML-KEM-1024 encapsulation.
  * @param {Uint8Array} public_key_bytes
  * @returns {CiphertextAndSharedSecret}
  */
 export function ml_kem_1024_encapsulate(public_key_bytes) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         wasm.ml_kem_1024_encapsulate(retptr, ptr0, len0);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -226,6 +673,7 @@ export function ml_kem_1024_encapsulate(public_key_bytes) {
 }
 
 /**
+ * Generates a fresh ML-KEM-1024 key pair using OS RNG.
  * @returns {KemKeyPair}
  */
 export function ml_kem_1024_generate_keypair() {
@@ -245,6 +693,13 @@ export function ml_kem_1024_generate_keypair() {
 }
 
 /**
+ * Performs ML-KEM-768 decapsulation to recover the shared secret.
+ *
+ * # Arguments
+ * * `secret_key_bytes`  – Encoded ML-KEM-768 decapsulation key (2400 bytes)
+ * * `ciphertext_bytes`  – ML-KEM-768 ciphertext (1088 bytes)
+ *
+ * Returns: 32-byte shared secret (or error)
  * @param {Uint8Array} secret_key_bytes
  * @param {Uint8Array} ciphertext_bytes
  * @returns {Uint8Array}
@@ -252,9 +707,9 @@ export function ml_kem_1024_generate_keypair() {
 export function ml_kem_768_decapsulate(secret_key_bytes, ciphertext_bytes) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(ciphertext_bytes, wasm.__wbindgen_export3);
+        const ptr1 = passArray8ToWasm0(ciphertext_bytes, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         wasm.kem_decapsulate(retptr, ptr0, len0, ptr1, len1);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -265,7 +720,7 @@ export function ml_kem_768_decapsulate(secret_key_bytes, ciphertext_bytes) {
             throw takeObject(r2);
         }
         var v3 = getArrayU8FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
         return v3;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -273,13 +728,19 @@ export function ml_kem_768_decapsulate(secret_key_bytes, ciphertext_bytes) {
 }
 
 /**
+ * Performs ML-KEM-768 encapsulation using the provided public key.
+ *
+ * # Arguments
+ * * `public_key_bytes` - Encoded ML-KEM-768 encapsulation key (1184 bytes)
+ *
+ * Returns: ciphertext + 32-byte shared secret
  * @param {Uint8Array} public_key_bytes
  * @returns {CiphertextAndSharedSecret}
  */
 export function ml_kem_768_encapsulate(public_key_bytes) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         wasm.kem_encapsulate(retptr, ptr0, len0);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -295,6 +756,9 @@ export function ml_kem_768_encapsulate(public_key_bytes) {
 }
 
 /**
+ * Generates a fresh ML-KEM-768 key pair using OS RNG.
+ *
+ * Returns: `KemKeyPair` containing public & secret key bytes.
  * @returns {KemKeyPair}
  */
 export function ml_kem_768_generate_keypair() {
@@ -348,6 +812,9 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).crypto;
             return addHeapObject(ret);
         },
+        __wbg_getRandomValues_2a91986308c74a93: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
         __wbg_getRandomValues_b3f15fcbfabb0f8b: function() { return handleError(function (arg0, arg1) {
             getObject(arg0).getRandomValues(getObject(arg1));
         }, arguments); },
@@ -436,6 +903,9 @@ function __wbg_get_imports() {
 const CiphertextAndSharedSecretFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ciphertextandsharedsecret_free(ptr >>> 0, 1));
+const DsaKeyPairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dsakeypair_free(ptr >>> 0, 1));
 const KemKeyPairFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kemkeypair_free(ptr >>> 0, 1));
@@ -507,6 +977,43 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
 function takeObject(idx) {
     const ret = getObject(idx);
     dropObject(idx);
@@ -527,6 +1034,19 @@ function decodeText(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
 let WASM_VECTOR_LEN = 0;
 
 let wasmModule, wasm;