@dstorage-tech/dstorage-sdk 0.0.4

package/dist/chunk-GUYENY5N.mjs

@@ -0,0 +1 @@
+import{a as n}from"./chunk-PKHRAYFD.mjs";import{a as i,q as p,r as w,s as h}from"./chunk-EYF3263P.mjs";import{scrypt as S}from"@noble/hashes/scrypt.js";var d={v1:{N:131072,r:8,p:1},"v1-lite":{N:65536,r:8,p:1}},N=class m{constructor(t){this.name="password",O(t.password,t.minPasswordLength??12,t.minEntropyBits??60,t.additionalValidators),this.salt=P(t.salt);let r=A(t.preset,t.params);this.N=r.N,this.r=r.r,this.p=r.p;let a=new TextEncoder().encode(t.password),s=S(a,this.salt,{N:this.N,r:this.r,p:this.p,dkLen:64});this.kekMaterialPromise=globalThis.crypto.subtle.importKey("raw",s,"HKDF",!1,["deriveBits"]).then(o=>(s.fill(0),o),o=>{throw s.fill(0),o})}static fromKdfParams(t){if(t.kdf!=="scrypt")throw new i(n.PASSWORD_UNSUPPORTED_KDF,`[dStorage] PasswordEncryptionAdapter.fromKdfParams: unsupported kdf "${t.kdf}". Only "scrypt" is supported.`);return new m({password:t.password,salt:t.salt,params:{N:t.N,r:t.r,p:t.p},...t.minPasswordLength!==void 0&&{minPasswordLength:t.minPasswordLength},...t.minEntropyBits!==void 0&&{minEntropyBits:t.minEntropyBits},...t.additionalValidators!==void 0&&{additionalValidators:t.additionalValidators}})}getKdfParams(){return{kdf:"scrypt",N:this.N,r:this.r,p:this.p}}async wrapDek(t){let r=await this.kekMaterialPromise,a=await p(r);try{return{algorithm:"xchacha20poly1305-v1",kekDerivation:"hkdf-sha256-v1",wrappedDek:await w(t,a)}}finally{a.fill(0)}}async unwrapDek({wrappedDek:t}){let r=await this.kekMaterialPromise,a=await p(r);try{return h(t,a)}finally{a.fill(0)}}async intoKeypairEncryptionAdapter(t,r){let{KeypairEncryptionAdapter:a}=await import("./KeypairEncryptionAdapter-XUKCLRFU-6ERIZN2M.mjs"),{mlkemGenerateKeypairFromSeed:s}=await import("./dist-MEZZWKP4.mjs"),o=await this.kekMaterialPromise,l=await globalThis.crypto.subtle.deriveBits({name:"HKDF",hash:"SHA-256",salt:new Uint8Array(32),info:new TextEncoder().encode("dstorage:mlkem-seed:v1")},o,512),c=new Uint8Array(l);try{let{pk:u,sk:k}=s(c,r);return a.fromKeypair(u,k,t,r)}finally{c.fill(0)}}};function P(e){let t=typeof e=="string"?new TextEncoder().encode(e):e;if(t.length===0)throw new i(n.PASSWORD_EMPTY_SALT,'[dStorage] PasswordEncryptionAdapter: salt must not be empty. Provide an app-specific domain label, e.g. "myapp:v1:alice@example.com".');return t}function A(e,t){if(e!==void 0){if(!(e in d))throw new i(n.PASSWORD_UNKNOWN_PRESET,`[dStorage] PasswordEncryptionAdapter: unknown preset "${e}". Valid presets: ${Object.keys(d).join(", ")}.`);return d[e]}return{N:t?.N??d.v1.N,r:t?.r??d.v1.r,p:t?.p??d.v1.p}}function E(e){let t=0;return/[a-z]/.test(e)&&(t+=26),/[A-Z]/.test(e)&&(t+=26),/[0-9]/.test(e)&&(t+=10),/[^a-zA-Z0-9]/.test(e)&&(t+=32),t===0?0:Math.log2(t)*e.length}function y(e,t=5){for(let r=0;r<=e.length-t;r++){let a=!0,s=!0;for(let o=1;o<t;o++){let l=e.charCodeAt(r+o)-e.charCodeAt(r+o-1);if(l!==1&&(a=!1),l!==-1&&(s=!1),!a&&!s)break}if(a||s)return!0}return!1}var v=["qwertyuiop","asdfghjkl","zxcvbnm","1234567890"];function f(e,t=5){let r=e.toLowerCase();for(let a of v)for(let s=0;s<=a.length-t;s++){let o=a.slice(s,s+t),l=o.split("").reverse().join("");if(r.includes(o)||r.includes(l))return!0}return!1}function _(){for(;;){let e=globalThis.crypto.getRandomValues(new Uint8Array(32)),r=btoa(Array.from(e,a=>String.fromCharCode(a)).join("")).replace(/\+/g,"-").replace(/\//g,"_").replace(/=/g,"");if(new Set(r).size>=3&&!y(r)&&!f(r))return r}}function O(e,t,r,a){if(e.length<t)throw new i(n.PASSWORD_TOO_SHORT,`[dStorage] Password too short: ${e.length} character(s) (minimum ${t}). Use a longer passphrase.`);if(new Set(e).size<3)throw new i(n.PASSWORD_TOO_FEW_DISTINCT,"[dStorage] Password is too weak: too few distinct characters.");if(y(e))throw new i(n.PASSWORD_SEQUENTIAL_RUN,"[dStorage] Password is too weak: contains a sequential character run (e.g. abcde, 12345).");if(f(e))throw new i(n.PASSWORD_KEYBOARD_WALK,"[dStorage] Password is too weak: contains a keyboard-row pattern (e.g. qwerty, asdfg).");let s=E(e);if(s<r)throw new i(n.PASSWORD_ENTROPY_TOO_LOW,`[dStorage] Password entropy too low: ~${Math.round(s)} bits (minimum ${r} bits). Use a longer password with a mix of uppercase, lowercase, digits, and symbols.`);if(a)for(let o of a)o(e)}export{d as a,N as b,_ as c};

package/dist/chunk-HDD6SUU4.mjs

@@ -0,0 +1,276 @@
+import {
+  EncryptionErrorCode
+} from "./chunk-O37NHERH.mjs";
+import {
+  DStorageError,
+  deriveKek,
+  unwrapKey,
+  wrapKey
+} from "./chunk-BWLEAAFW.mjs";
+
+// ../encryption/dist/chunk-6IHXTW2Y.mjs
+import { scrypt } from "@noble/hashes/scrypt.js";
+var KDF_PRESETS = {
+  v1: { N: 131072, r: 8, p: 1 },
+  "v1-lite": { N: 65536, r: 8, p: 1 }
+};
+var PasswordEncryptionAdapter = class _PasswordEncryptionAdapter {
+  constructor(config) {
+    this.name = "password";
+    validatePassword(
+      config.password,
+      config.minPasswordLength ?? 12,
+      config.minEntropyBits ?? 60,
+      config.additionalValidators
+    );
+    this.salt = resolveSalt(config.salt);
+    const resolved = resolveParams(config.preset, config.params);
+    this.N = resolved.N;
+    this.r = resolved.r;
+    this.p = resolved.p;
+    const passwordBytes = new TextEncoder().encode(config.password);
+    const seed = scrypt(passwordBytes, this.salt, {
+      N: this.N,
+      r: this.r,
+      p: this.p,
+      dkLen: 64
+    });
+    this.kekMaterialPromise = globalThis.crypto.subtle.importKey("raw", seed, "HKDF", false, ["deriveBits"]).then(
+      (key) => {
+        seed.fill(0);
+        return key;
+      },
+      (err) => {
+        seed.fill(0);
+        throw err;
+      }
+    );
+  }
+  /**
+   * Reconstruct an adapter from parameters previously stored via `getKdfParams()`.
+   * Use this when loading existing encrypted data — ensures the exact same N/r/p
+   * are used regardless of what the current SDK defaults are.
+   *
+   * @example
+   * const adapter = PasswordEncryptionAdapter.fromKdfParams({
+   *   password,
+   *   salt: meta.salt,
+   *   kdf: meta.kdf,
+   *   N: meta.N,
+   *   r: meta.r,
+   *   p: meta.p,
+   * });
+   */
+  static fromKdfParams(config) {
+    if (config.kdf !== "scrypt") {
+      throw new DStorageError(
+        EncryptionErrorCode.PASSWORD_UNSUPPORTED_KDF,
+        `[dStorage] PasswordEncryptionAdapter.fromKdfParams: unsupported kdf "${config.kdf}". Only "scrypt" is supported.`
+      );
+    }
+    return new _PasswordEncryptionAdapter({
+      password: config.password,
+      salt: config.salt,
+      params: { N: config.N, r: config.r, p: config.p },
+      ...config.minPasswordLength !== void 0 && {
+        minPasswordLength: config.minPasswordLength
+      },
+      ...config.minEntropyBits !== void 0 && {
+        minEntropyBits: config.minEntropyBits
+      },
+      ...config.additionalValidators !== void 0 && {
+        additionalValidators: config.additionalValidators
+      }
+    });
+  }
+  /**
+   * Returns the resolved KDF parameters to store alongside encrypted data.
+   *
+   * These values are language- and SDK-agnostic: any scrypt implementation
+   * can re-derive the key from `{ kdf, N, r, p }` + the original salt and
+   * password, without any knowledge of this SDK's preset names.
+   *
+   * @example
+   * const meta = {
+   *   ...adapter.getKdfParams(),  // { kdf: "scrypt", N: 131072, r: 8, p: 1 }
+   *   salt: "myapp:alice@example.com",
+   * };
+   * await db.save({ encryptedData, meta });
+   */
+  getKdfParams() {
+    return { kdf: "scrypt", N: this.N, r: this.r, p: this.p };
+  }
+  async wrapDek(dek) {
+    const kekMaterial = await this.kekMaterialPromise;
+    const kek = await deriveKek(kekMaterial);
+    try {
+      return {
+        algorithm: "xchacha20poly1305-v1",
+        kekDerivation: "hkdf-sha256-v1",
+        wrappedDek: await wrapKey(dek, kek)
+      };
+    } finally {
+      kek.fill(0);
+    }
+  }
+  async unwrapDek({ wrappedDek }) {
+    const kekMaterial = await this.kekMaterialPromise;
+    const kek = await deriveKek(kekMaterial);
+    try {
+      return unwrapKey(wrappedDek, kek);
+    } finally {
+      kek.fill(0);
+    }
+  }
+  /**
+   * Deterministically derive a ML-KEM keypair from this adapter's key material.
+   *
+   * Uses Web Crypto HKDF to derive a 64-byte ML-KEM seed from the stored
+   * CryptoKey, domain-separated from the symmetric KEK derivation path with
+   * info="dstorage:mlkem-seed:v1". This is equivalent to noble's
+   * hkdf(sha256, scryptOutput, undefined, info, 64) but avoids materialising
+   * the raw scrypt output in a JS-accessible variable.
+   *
+   * Same password + salt + variant always produces the same keypair.
+   *
+   * @param context  Domain-separation string bound into the KEK derivation
+   * @param variant  ML-KEM variant. Default: "mlkem768".
+   */
+  async intoKeypairEncryptionAdapter(context, variant) {
+    const { KeypairEncryptionAdapter } = await import("./KeypairEncryptionAdapter-XUKCLRFU-ERPYK5S4.mjs");
+    const { mlkemGenerateKeypairFromSeed } = await import("./dist-MOLWJ4Y7.mjs");
+    const kekMaterial = await this.kekMaterialPromise;
+    const mlkemBits = await globalThis.crypto.subtle.deriveBits(
+      {
+        name: "HKDF",
+        hash: "SHA-256",
+        salt: new Uint8Array(32),
+        info: new TextEncoder().encode("dstorage:mlkem-seed:v1")
+      },
+      kekMaterial,
+      512
+      // 64 bytes
+    );
+    const mlkemSeed = new Uint8Array(mlkemBits);
+    try {
+      const { pk, sk } = mlkemGenerateKeypairFromSeed(mlkemSeed, variant);
+      return KeypairEncryptionAdapter.fromKeypair(pk, sk, context, variant);
+    } finally {
+      mlkemSeed.fill(0);
+    }
+  }
+};
+function resolveSalt(salt) {
+  const bytes = typeof salt === "string" ? new TextEncoder().encode(salt) : salt;
+  if (bytes.length === 0) {
+    throw new DStorageError(
+      EncryptionErrorCode.PASSWORD_EMPTY_SALT,
+      '[dStorage] PasswordEncryptionAdapter: salt must not be empty. Provide an app-specific domain label, e.g. "myapp:v1:alice@example.com".'
+    );
+  }
+  return bytes;
+}
+function resolveParams(preset, params) {
+  if (preset !== void 0) {
+    if (!(preset in KDF_PRESETS)) {
+      throw new DStorageError(
+        EncryptionErrorCode.PASSWORD_UNKNOWN_PRESET,
+        `[dStorage] PasswordEncryptionAdapter: unknown preset "${preset}". Valid presets: ${Object.keys(KDF_PRESETS).join(", ")}.`
+      );
+    }
+    return KDF_PRESETS[preset];
+  }
+  return {
+    N: params?.N ?? KDF_PRESETS["v1"].N,
+    r: params?.r ?? KDF_PRESETS["v1"].r,
+    p: params?.p ?? KDF_PRESETS["v1"].p
+  };
+}
+function estimateEntropyBits(password) {
+  let pool = 0;
+  if (/[a-z]/.test(password)) pool += 26;
+  if (/[A-Z]/.test(password)) pool += 26;
+  if (/[0-9]/.test(password)) pool += 10;
+  if (/[^a-zA-Z0-9]/.test(password)) pool += 32;
+  return pool === 0 ? 0 : Math.log2(pool) * password.length;
+}
+function hasSequentialRun(pw, runLength = 5) {
+  for (let i = 0; i <= pw.length - runLength; i++) {
+    let ascending = true;
+    let descending = true;
+    for (let j = 1; j < runLength; j++) {
+      const diff = pw.charCodeAt(i + j) - pw.charCodeAt(i + j - 1);
+      if (diff !== 1) ascending = false;
+      if (diff !== -1) descending = false;
+      if (!ascending && !descending) break;
+    }
+    if (ascending || descending) return true;
+  }
+  return false;
+}
+var KEYBOARD_ROWS = ["qwertyuiop", "asdfghjkl", "zxcvbnm", "1234567890"];
+function hasKeyboardWalk(pw, minLen = 5) {
+  const lower = pw.toLowerCase();
+  for (const row of KEYBOARD_ROWS) {
+    for (let i = 0; i <= row.length - minLen; i++) {
+      const fwd = row.slice(i, i + minLen);
+      const rev = fwd.split("").reverse().join("");
+      if (lower.includes(fwd) || lower.includes(rev)) return true;
+    }
+  }
+  return false;
+}
+function generatePqsPassword() {
+  while (true) {
+    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(32));
+    const b64 = btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join(""));
+    const password = b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    if (new Set(password).size >= 3 && !hasSequentialRun(password) && !hasKeyboardWalk(password)) {
+      return password;
+    }
+  }
+}
+function validatePassword(password, minLength, minEntropyBits, additionalValidators) {
+  if (password.length < minLength) {
+    throw new DStorageError(
+      EncryptionErrorCode.PASSWORD_TOO_SHORT,
+      `[dStorage] Password too short: ${password.length} character(s) (minimum ${minLength}). Use a longer passphrase.`
+    );
+  }
+  if (new Set(password).size < 3) {
+    throw new DStorageError(
+      EncryptionErrorCode.PASSWORD_TOO_FEW_DISTINCT,
+      "[dStorage] Password is too weak: too few distinct characters."
+    );
+  }
+  if (hasSequentialRun(password)) {
+    throw new DStorageError(
+      EncryptionErrorCode.PASSWORD_SEQUENTIAL_RUN,
+      "[dStorage] Password is too weak: contains a sequential character run (e.g. abcde, 12345)."
+    );
+  }
+  if (hasKeyboardWalk(password)) {
+    throw new DStorageError(
+      EncryptionErrorCode.PASSWORD_KEYBOARD_WALK,
+      "[dStorage] Password is too weak: contains a keyboard-row pattern (e.g. qwerty, asdfg)."
+    );
+  }
+  const entropy = estimateEntropyBits(password);
+  if (entropy < minEntropyBits) {
+    throw new DStorageError(
+      EncryptionErrorCode.PASSWORD_ENTROPY_TOO_LOW,
+      `[dStorage] Password entropy too low: ~${Math.round(entropy)} bits (minimum ${minEntropyBits} bits). Use a longer password with a mix of uppercase, lowercase, digits, and symbols.`
+    );
+  }
+  if (additionalValidators) {
+    for (const validate of additionalValidators) {
+      validate(password);
+    }
+  }
+}
+
+export {
+  KDF_PRESETS,
+  PasswordEncryptionAdapter,
+  generatePqsPassword
+};

package/dist/chunk-JMPRZK5D.mjs

@@ -0,0 +1,62 @@
+// ../chain/dist/chunk-AGLD4HA4.mjs
+var ChainErrorCode = {
+  // mock.ts — 11001-11009
+  MOCK_REF_NOT_FOUND: 11001,
+  MOCK_REF_NOT_FOUND_REMOVE: 11002,
+  MOCK_REF_NOT_FOUND_UPDATE: 11003,
+  MOCK_OWNER_SECRET_REQUIRED: 11004,
+  MOCK_OWNER_SECRET_MISMATCH: 11005,
+  // httpGateway.ts — 11201-11219
+  GATEWAY_WRITE_FAILED: 11201,
+  GATEWAY_WRITE_HTTP_ERROR: 11202,
+  GATEWAY_UPDATE_FAILED: 11203,
+  GATEWAY_UPDATE_HTTP_ERROR: 11204,
+  GATEWAY_READ_FAILED: 11205,
+  GATEWAY_READ_HTTP_ERROR: 11206,
+  GATEWAY_READ_INVALID_JSON: 11207,
+  GATEWAY_READ_INVALID_SHAPE: 11208,
+  GATEWAY_LIST_FAILED: 11209,
+  GATEWAY_LIST_HTTP_ERROR: 11210,
+  GATEWAY_LIST_INVALID_JSON: 11211,
+  GATEWAY_LIST_NOT_ARRAY: 11212,
+  GATEWAY_REMOVE_FAILED: 11213,
+  GATEWAY_REMOVE_HTTP_ERROR: 11214,
+  // contract-api.ts — 11401-11409
+  CONTRACT_UNSUPPORTED_VERSION: 11401,
+  CONTRACT_CIRCUIT_RESULT_MISSING: 11402,
+  // midnight.ts — 11501-11599
+  MIDNIGHT_NETWORK_REQUIRED: 11501,
+  MIDNIGHT_WALLET_PROVIDER_REQUIRED: 11502,
+  MIDNIGHT_PRIVATE_STATE_PASSWORD_REQUIRED: 11503,
+  MIDNIGHT_ZK_ARTIFACTS_PATH_EMPTY: 11504,
+  MIDNIGHT_ZK_CONFIG_BASE_URL_EMPTY: 11505,
+  MIDNIGHT_UNSUPPORTED_NETWORK: 11506,
+  MIDNIGHT_AUTH_TOKEN_REQUIRED: 11507,
+  MIDNIGHT_ZK_CONFIG_BASE_URL_REQUIRED: 11508,
+  MIDNIGHT_ZK_ARTIFACTS_PATH_REQUIRED: 11509,
+  MIDNIGHT_ZK_ARTIFACTS_PATH_NOT_FOUND: 11510,
+  MIDNIGHT_CONNECTOR_NOT_INITIALIZED: 11511,
+  MIDNIGHT_COIN_PUBLIC_KEY_MISSING: 11512,
+  MIDNIGHT_ENC_PUBLIC_KEY_MISSING: 11513,
+  MIDNIGHT_INDEXER_HTTP_NOT_SET: 11514,
+  MIDNIGHT_INDEXER_WS_NOT_SET: 11515,
+  MIDNIGHT_PROOF_SERVER_NOT_SET: 11516,
+  MIDNIGHT_NOT_INITIALIZED: 11517,
+  MIDNIGHT_INVALID_CONTRACT_ADDRESS: 11518,
+  MIDNIGHT_REF_NOT_FOUND: 11519,
+  MIDNIGHT_KEYENVELOPE_REQUIRED: 11520,
+  MIDNIGHT_OWNER_SECRET_REQUIRED_WRITE: 11521,
+  MIDNIGHT_OWNER_SECRET_REQUIRED_REMOVE: 11522,
+  MIDNIGHT_OWNER_SECRET_REQUIRED_UPDATE: 11523,
+  MIDNIGHT_WALLET_NOT_FOUND: 11524,
+  MIDNIGHT_NO_WALLETS_FOUND: 11525,
+  MIDNIGHT_WALLET_CONNECT_FAILED: 11526,
+  MIDNIGHT_NO_ADDRESSES: 11527,
+  MIDNIGHT_EXTRACT_ADDRESSES_FAILED: 11528,
+  MIDNIGHT_GET_ADDRESSES_NOT_INITIALIZED: 11529,
+  MIDNIGHT_GET_BALANCES_NOT_INITIALIZED: 11530
+};
+
+export {
+  ChainErrorCode
+};

package/dist/chunk-L5QD6GHB.mjs

@@ -0,0 +1,101 @@
+import {
+  EncryptionErrorCode
+} from "./chunk-O37NHERH.mjs";
+import {
+  DStorageError,
+  KeyDeriver,
+  deriveKek,
+  unwrapKey,
+  wrapKey
+} from "./chunk-TSZ37JDY.mjs";
+
+// ../encryption/dist/chunk-QPJOFIIO.mjs
+var MnemonicEncryptionAdapter = class {
+  constructor(input) {
+    this.name = "mnemonic";
+    if (input.mnemonic !== void 0) {
+      const wordCount = input.mnemonic.trim().split(/\s+/).length;
+      if (wordCount < 24) {
+        throw new DStorageError(
+          EncryptionErrorCode.MNEMONIC_TOO_SHORT,
+          `[dStorage] MnemonicEncryptionAdapter: a 24-word BIP-39 mnemonic is required (${wordCount} word${wordCount === 1 ? "" : "s"} provided). Shorter mnemonics provide insufficient entropy for post-quantum-safe key derivation \u2014 a 12-word mnemonic gives only 64-bit PQ security (below NIST's 128-bit minimum). Use a 24-word mnemonic or pass a 64-byte seedHex instead.`
+        );
+      }
+    }
+    const deriver = new KeyDeriver(input);
+    this.kekMaterialPromise = deriver.getSeed().then(
+      (seed) => (
+        // Uint8Array.from() produces Uint8Array<ArrayBuffer> required by Web Crypto.
+        globalThis.crypto.subtle.importKey("raw", Uint8Array.from(seed), "HKDF", false, ["deriveBits"]).then(
+          (key) => {
+            seed.fill(0);
+            return key;
+          },
+          (err) => {
+            seed.fill(0);
+            throw err;
+          }
+        )
+      )
+    );
+  }
+  async wrapDek(dek) {
+    const kekMaterial = await this.kekMaterialPromise;
+    const kek = await deriveKek(kekMaterial);
+    try {
+      return {
+        algorithm: "xchacha20poly1305-v1",
+        kekDerivation: "hkdf-sha256-v1",
+        wrappedDek: await wrapKey(dek, kek)
+      };
+    } finally {
+      kek.fill(0);
+    }
+  }
+  async unwrapDek({ wrappedDek }) {
+    const kekMaterial = await this.kekMaterialPromise;
+    const kek = await deriveKek(kekMaterial);
+    try {
+      return unwrapKey(wrappedDek, kek);
+    } finally {
+      kek.fill(0);
+    }
+  }
+  /**
+   * Deterministically derive a ML-KEM keypair from this adapter's key material.
+   *
+   * Uses Web Crypto HKDF to derive a 64-byte ML-KEM seed from the stored
+   * CryptoKey with info="dstorage:mlkem-seed:v1", domain-separated from the
+   * symmetric KEK derivation path. The same derivation applies to all seed
+   * types (mnemonic or hex), producing consistent, domain-separated keypairs.
+   *
+   * @param variant  ML-KEM variant. Default: "mlkem768".
+   */
+  async intoKeypairEncryptionAdapter(context, variant) {
+    const { KeypairEncryptionAdapter } = await import("./KeypairEncryptionAdapter-AE75YC4W-AOWNSH2M.mjs");
+    const { mlkemGenerateKeypairFromSeed } = await import("./dist-UD4WRMYJ.mjs");
+    const kekMaterial = await this.kekMaterialPromise;
+    const mlkemBits = await globalThis.crypto.subtle.deriveBits(
+      {
+        name: "HKDF",
+        hash: "SHA-256",
+        salt: new Uint8Array(32),
+        info: new TextEncoder().encode("dstorage:mlkem-seed:v1")
+      },
+      kekMaterial,
+      512
+      // 64 bytes
+    );
+    const mlkemSeed = new Uint8Array(mlkemBits);
+    try {
+      const { pk, sk } = mlkemGenerateKeypairFromSeed(mlkemSeed, variant);
+      return KeypairEncryptionAdapter.fromKeypair(pk, sk, context, variant);
+    } finally {
+      mlkemSeed.fill(0);
+    }
+  }
+};
+
+export {
+  MnemonicEncryptionAdapter
+};

package/dist/chunk-O37NHERH.mjs

@@ -0,0 +1,17 @@
+// ../encryption/dist/chunk-WBLC4ONG.mjs
+var EncryptionErrorCode = {
+  KEYPAIR_MISSING_SECRET_KEY: 13001,
+  MNEMONIC_TOO_SHORT: 13002,
+  PASSWORD_UNSUPPORTED_KDF: 13003,
+  PASSWORD_EMPTY_SALT: 13004,
+  PASSWORD_UNKNOWN_PRESET: 13005,
+  PASSWORD_TOO_SHORT: 13006,
+  PASSWORD_TOO_FEW_DISTINCT: 13007,
+  PASSWORD_SEQUENTIAL_RUN: 13008,
+  PASSWORD_KEYBOARD_WALK: 13009,
+  PASSWORD_ENTROPY_TOO_LOW: 13010
+};
+
+export {
+  EncryptionErrorCode
+};

package/dist/chunk-OLGVVM5Y.mjs

@@ -0,0 +1,102 @@
+import {
+  EncryptionErrorCode
+} from "./chunk-O37NHERH.mjs";
+import {
+  DStorageError,
+  KeyDeriver,
+  deriveKek,
+  unwrapKey,
+  wrapKey
+} from "./chunk-BWLEAAFW.mjs";
+
+// ../encryption/dist/chunk-SW62VRE3.mjs
+var MnemonicEncryptionAdapter = class {
+  constructor(input) {
+    this.name = "mnemonic";
+    if (input.mnemonic !== void 0) {
+      const wordCount = input.mnemonic.trim().split(/\s+/).length;
+      if (wordCount < 24) {
+        throw new DStorageError(
+          EncryptionErrorCode.MNEMONIC_TOO_SHORT,
+          `[dStorage] MnemonicEncryptionAdapter: a 24-word BIP-39 mnemonic is required (${wordCount} word${wordCount === 1 ? "" : "s"} provided). Shorter mnemonics provide insufficient entropy for post-quantum-safe key derivation \u2014 a 12-word mnemonic gives only 64-bit PQ security (below NIST's 128-bit minimum). Use a 24-word mnemonic or pass a 64-byte seedHex instead.`
+        );
+      }
+    }
+    const deriver = new KeyDeriver(input);
+    this.kekMaterialPromise = deriver.getSeed().then(
+      (seed) => (
+        // Uint8Array.from() produces Uint8Array<ArrayBuffer> required by Web Crypto.
+        globalThis.crypto.subtle.importKey("raw", Uint8Array.from(seed), "HKDF", false, ["deriveBits"]).then(
+          (key) => {
+            seed.fill(0);
+            return key;
+          },
+          (err) => {
+            seed.fill(0);
+            throw err;
+          }
+        )
+      )
+    );
+  }
+  async wrapDek(dek) {
+    const kekMaterial = await this.kekMaterialPromise;
+    const kek = await deriveKek(kekMaterial);
+    try {
+      return {
+        algorithm: "xchacha20poly1305-v1",
+        kekDerivation: "hkdf-sha256-v1",
+        wrappedDek: await wrapKey(dek, kek)
+      };
+    } finally {
+      kek.fill(0);
+    }
+  }
+  async unwrapDek({ wrappedDek }) {
+    const kekMaterial = await this.kekMaterialPromise;
+    const kek = await deriveKek(kekMaterial);
+    try {
+      return unwrapKey(wrappedDek, kek);
+    } finally {
+      kek.fill(0);
+    }
+  }
+  /**
+   * Deterministically derive a ML-KEM keypair from this adapter's key material.
+   *
+   * Uses Web Crypto HKDF to derive a 64-byte ML-KEM seed from the stored
+   * CryptoKey with info="dstorage:mlkem-seed:v1", domain-separated from the
+   * symmetric KEK derivation path. The same derivation applies to all seed
+   * types (mnemonic or hex), producing consistent, domain-separated keypairs.
+   *
+   * @param context  Domain-separation string bound into the KEK derivation
+   * @param variant  ML-KEM variant. Default: "mlkem768".
+   */
+  async intoKeypairEncryptionAdapter(context, variant) {
+    const { KeypairEncryptionAdapter } = await import("./KeypairEncryptionAdapter-XUKCLRFU-ERPYK5S4.mjs");
+    const { mlkemGenerateKeypairFromSeed } = await import("./dist-MOLWJ4Y7.mjs");
+    const kekMaterial = await this.kekMaterialPromise;
+    const mlkemBits = await globalThis.crypto.subtle.deriveBits(
+      {
+        name: "HKDF",
+        hash: "SHA-256",
+        salt: new Uint8Array(32),
+        info: new TextEncoder().encode("dstorage:mlkem-seed:v1")
+      },
+      kekMaterial,
+      512
+      // 64 bytes
+    );
+    const mlkemSeed = new Uint8Array(mlkemBits);
+    try {
+      const { pk, sk } = mlkemGenerateKeypairFromSeed(mlkemSeed, variant);
+      return KeypairEncryptionAdapter.fromKeypair(pk, sk, context, variant);
+    } finally {
+      mlkemSeed.fill(0);
+    }
+  }
+};
+
+export {
+  MnemonicEncryptionAdapter
+};

package/dist/chunk-PKHRAYFD.mjs

@@ -0,0 +1 @@
+var S={KEYPAIR_MISSING_SECRET_KEY:13001,MNEMONIC_TOO_SHORT:13002,PASSWORD_UNSUPPORTED_KDF:13003,PASSWORD_EMPTY_SALT:13004,PASSWORD_UNKNOWN_PRESET:13005,PASSWORD_TOO_SHORT:13006,PASSWORD_TOO_FEW_DISTINCT:13007,PASSWORD_SEQUENTIAL_RUN:13008,PASSWORD_KEYBOARD_WALK:13009,PASSWORD_ENTROPY_TOO_LOW:13010};export{S as a};

package/dist/chunk-PLAOCKSS.mjs

@@ -0,0 +1,101 @@
+import {
+  EncryptionErrorCode
+} from "./chunk-O37NHERH.mjs";
+import {
+  DStorageError,
+  KeyDeriver,
+  deriveKek,
+  unwrapKey,
+  wrapKey
+} from "./chunk-BWLEAAFW.mjs";
+
+// ../encryption/dist/chunk-QPJOFIIO.mjs
+var MnemonicEncryptionAdapter = class {
+  constructor(input) {
+    this.name = "mnemonic";
+    if (input.mnemonic !== void 0) {
+      const wordCount = input.mnemonic.trim().split(/\s+/).length;
+      if (wordCount < 24) {
+        throw new DStorageError(
+          EncryptionErrorCode.MNEMONIC_TOO_SHORT,
+          `[dStorage] MnemonicEncryptionAdapter: a 24-word BIP-39 mnemonic is required (${wordCount} word${wordCount === 1 ? "" : "s"} provided). Shorter mnemonics provide insufficient entropy for post-quantum-safe key derivation \u2014 a 12-word mnemonic gives only 64-bit PQ security (below NIST's 128-bit minimum). Use a 24-word mnemonic or pass a 64-byte seedHex instead.`
+        );
+      }
+    }
+    const deriver = new KeyDeriver(input);
+    this.kekMaterialPromise = deriver.getSeed().then(
+      (seed) => (
+        // Uint8Array.from() produces Uint8Array<ArrayBuffer> required by Web Crypto.
+        globalThis.crypto.subtle.importKey("raw", Uint8Array.from(seed), "HKDF", false, ["deriveBits"]).then(
+          (key) => {
+            seed.fill(0);
+            return key;
+          },
+          (err) => {
+            seed.fill(0);
+            throw err;
+          }
+        )
+      )
+    );
+  }
+  async wrapDek(dek) {
+    const kekMaterial = await this.kekMaterialPromise;
+    const kek = await deriveKek(kekMaterial);
+    try {
+      return {
+        algorithm: "xchacha20poly1305-v1",
+        kekDerivation: "hkdf-sha256-v1",
+        wrappedDek: await wrapKey(dek, kek)
+      };
+    } finally {
+      kek.fill(0);
+    }
+  }
+  async unwrapDek({ wrappedDek }) {
+    const kekMaterial = await this.kekMaterialPromise;
+    const kek = await deriveKek(kekMaterial);
+    try {
+      return unwrapKey(wrappedDek, kek);
+    } finally {
+      kek.fill(0);
+    }
+  }
+  /**
+   * Deterministically derive a ML-KEM keypair from this adapter's key material.
+   *
+   * Uses Web Crypto HKDF to derive a 64-byte ML-KEM seed from the stored
+   * CryptoKey with info="dstorage:mlkem-seed:v1", domain-separated from the
+   * symmetric KEK derivation path. The same derivation applies to all seed
+   * types (mnemonic or hex), producing consistent, domain-separated keypairs.
+   *
+   * @param variant  ML-KEM variant. Default: "mlkem768".
+   */
+  async intoKeypairEncryptionAdapter(context, variant) {
+    const { KeypairEncryptionAdapter } = await import("./KeypairEncryptionAdapter-AE75YC4W-VAOH6AAL.mjs");
+    const { mlkemGenerateKeypairFromSeed } = await import("./dist-INTAFXQ7.mjs");
+    const kekMaterial = await this.kekMaterialPromise;
+    const mlkemBits = await globalThis.crypto.subtle.deriveBits(
+      {
+        name: "HKDF",
+        hash: "SHA-256",
+        salt: new Uint8Array(32),
+        info: new TextEncoder().encode("dstorage:mlkem-seed:v1")
+      },
+      kekMaterial,
+      512
+      // 64 bytes
+    );
+    const mlkemSeed = new Uint8Array(mlkemBits);
+    try {
+      const { pk, sk } = mlkemGenerateKeypairFromSeed(mlkemSeed, variant);
+      return KeypairEncryptionAdapter.fromKeypair(pk, sk, context, variant);
+    } finally {
+      mlkemSeed.fill(0);
+    }
+  }
+};
+
+export {
+  MnemonicEncryptionAdapter
+};