@wishknish/knishio-client-ts 0.9.5 → 0.9.7

package/dist/index.iife.js

@@ -57,8 +57,8 @@ var KnishIO = (function (exports) {
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   };
-  var __commonJS = (cb, mod2) => function __require() {
-    return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
     for (var name2 in all)
@@ -72,15 +72,15 @@ var KnishIO = (function (exports) {
     }
     return to;
   };
-  var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
     // If the importer is in node compatibility mode or this is not an ESM
     // file that has been converted to a CommonJS file using a Babel-
     // compatible transform (i.e. "__esModule" has not been set), then set
     // "default" to the CommonJS "module.exports" for node compatibility.
-    __defProp(target, "default", { value: mod2, enumerable: true }) ,
-    mod2
+    __defProp(target, "default", { value: mod, enumerable: true }) ,
+    mod
   ));
-  var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
   // src/exception/BaseException.ts
   exports.BaseException = void 0;
@@ -20064,6 +20064,55 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   });
 
+  // src/exception/SecretStorageException.ts
+  exports.SecretStorageException = void 0;
+  var init_SecretStorageException = __esm({
+    "src/exception/SecretStorageException.ts"() {
+      init_BaseException();
+      exports.SecretStorageException = class _SecretStorageException extends exports.BaseException {
+        constructor(message = "Secret storage operation failed", options = {}) {
+          super("WALLET_CREDENTIAL_ERROR", message, {
+            code: "SECRET_STORAGE_ERROR",
+            ...options
+          });
+        }
+        /**
+         * Secret not found for the requested bundle hash
+         */
+        static notFound(bundleHash) {
+          return new _SecretStorageException(`Secret not found for bundle: ${bundleHash}`, {
+            code: "SECRET_NOT_FOUND",
+            details: { bundleHash }
+          });
+        }
+        /**
+         * Decryption failed (wrong passphrase or corrupted payload)
+         */
+        static decryptionFailed(reason) {
+          return new _SecretStorageException(
+            `Failed to decrypt master secret: ${reason || "Invalid passphrase or corrupted ciphertext"}`,
+            {
+              code: "DECRYPTION_FAILED",
+              details: { reason }
+            }
+          );
+        }
+        /**
+         * Provider is unavailable in current platform
+         */
+        static unavailable(provider, reason) {
+          return new _SecretStorageException(
+            `Secret storage provider '${provider}' is unavailable: ${reason || "Hardware or API not accessible"}`,
+            {
+              code: "STORAGE_UNAVAILABLE",
+              details: { provider, reason }
+            }
+          );
+        }
+      };
+    }
+  });
+
   // src/exception/InvalidResponseException.ts
   exports.InvalidResponseException = void 0;
   var init_InvalidResponseException = __esm({
@@ -20526,6 +20575,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       init_SignatureMismatchException();
       init_TransferBalanceException();
       init_WalletCredentialException();
+      init_SecretStorageException();
       init_InvalidResponseException();
       init_BalanceInsufficientException();
       init_BatchIdException();
@@ -39975,11 +40025,9 @@ ${operationTypes.join("\n")}
       const base17Hash = convertToBase17(molecularHash);
       const enumerated = enumerateMolecularHash(base17Hash);
       const normalized = normalizeMolecularHash(enumerated);
-      let ots = otsFragments;
+      const ots = otsFragments;
       if (ots.length !== 2048) {
-        if (ots.length !== 2048) {
-          return false;
-        }
+        return false;
       }
       const otsChunks = [];
       for (let i4 = 0; i4 < ots.length; i4 += CRYPTO_CONSTANTS.KEY_FRAGMENT_SIZE) {
@@ -40482,6 +40530,123 @@ ${operationTypes.join("\n")}
       });
     }
   };
+
+  // src/libraries/array.ts
+  function deepCloning(o3, h3) {
+    let i4;
+    let r3;
+    let x2;
+    const t3 = [Array, Date, Number, String, Boolean];
+    const s2 = Object.prototype.toString;
+    h3 = h3 || [];
+    for (i4 = 0; i4 < h3.length; i4 += 2) {
+      if (o3 === h3[i4]) {
+        return h3[i4 + 1];
+      }
+    }
+    if (!r3 && o3 && typeof o3 === "object") {
+      r3 = {};
+      for (i4 = 0; i4 < t3.length; i4++) {
+        if (s2.call(o3) === s2.call(x2 = new t3[i4](o3))) {
+          r3 = i4 ? x2 : [];
+        }
+      }
+      h3.push(o3, r3);
+      for (i4 in o3) {
+        if (Object.prototype.hasOwnProperty.call(o3, i4)) {
+          r3[i4] = deepCloning(o3[i4], h3);
+        }
+      }
+    }
+    return r3 || o3;
+  }
+  function chunkArray(arr, size) {
+    const chunks = [];
+    for (let i4 = 0; i4 < arr.length; i4 += size) {
+      chunks.push(arr.slice(i4, i4 + size));
+    }
+    return chunks;
+  }
+  function diff(...arrays) {
+    return [].concat(...arrays.map((arr, i4) => {
+      const others = arrays.slice(0);
+      others.splice(i4, 1);
+      const unique = [...new Set([].concat(...others))];
+      return arr.filter((item) => !unique.includes(item));
+    }));
+  }
+  function intersect(...arrays) {
+    if (arrays.length === 0) return [];
+    if (arrays.length === 1) return arrays[0];
+    return arrays.reduce(
+      (first, second) => first.filter((item) => second.includes(item))
+    );
+  }
+
+  // src/core/PolicyMeta.ts
+  var PolicyMeta = class _PolicyMeta {
+    policy;
+    /**
+     * Create new PolicyMeta instance
+     * Matches JavaScript SDK constructor signature exactly
+     */
+    constructor(policy = {}, metaKeys = []) {
+      this.policy = _PolicyMeta.normalizePolicy(policy);
+      this.fillDefault(metaKeys);
+    }
+    /**
+     * Normalize policy object structure
+     * Matches JavaScript SDK normalizePolicy method exactly
+     */
+    static normalizePolicy(policy = {}) {
+      const policyMeta = {};
+      for (const [policyKey, value2] of Object.entries(policy)) {
+        if (value2 !== null && ["read", "write"].includes(policyKey)) {
+          policyMeta[policyKey] = {};
+          for (const [key, content] of Object.entries(value2)) {
+            policyMeta[policyKey][key] = content;
+          }
+        }
+      }
+      return policyMeta;
+    }
+    /**
+     * Fill default policy values for metadata keys
+     * Matches JavaScript SDK fillDefault method exactly
+     */
+    fillDefault(metaKeys = []) {
+      const readPolicy = Array.from(this.policy).filter((item) => item.action === "read");
+      const writePolicy = Array.from(this.policy).filter((item) => item.action === "write");
+      for (const [type2, value2] of Object.entries({
+        read: readPolicy,
+        write: writePolicy
+      })) {
+        const policyKey = value2.map((item) => item.key);
+        if (!this.policy[type2]) {
+          this.policy[type2] = {};
+        }
+        for (const key of diff(metaKeys, policyKey)) {
+          if (!this.policy[type2][key]) {
+            this.policy[type2][key] = type2 === "write" && !["characters", "pubkey"].includes(key) ? ["self"] : ["all"];
+          }
+        }
+      }
+    }
+    /**
+     * Get the policy object
+     * Matches JavaScript SDK get method exactly
+     */
+    get() {
+      return this.policy;
+    }
+    /**
+     * Convert policy to JSON string
+     * Matches JavaScript SDK toJson method exactly
+     */
+    toJson() {
+      return JSON.stringify(this.get());
+    }
+  };
   var AtomMeta = class _AtomMeta {
     meta;
     /**
@@ -40577,8 +40742,9 @@ ${operationTypes.join("\n")}
      * @return This instance for chaining
      */
     addPolicy(policy) {
+      const policyMeta = new PolicyMeta(policy, Object.keys(this.meta));
       this.merge({
-        policy: JSON.stringify(policy)
+        policy: policyMeta.toJson()
       });
       return this;
     }
@@ -41214,8 +41380,89 @@ ${operationTypes.join("\n")}
     return value2;
   }
 
+  // src/core/TokenUnit.ts
+  var TokenUnit = class _TokenUnit {
+    id;
+    name;
+    metas;
+    /**
+     * Create new TokenUnit instance
+     * Matches JavaScript SDK constructor signature exactly
+     */
+    constructor(id, name2, metas) {
+      this.id = id;
+      this.name = name2;
+      this.metas = metas || {};
+    }
+    /**
+     * Create TokenUnit from GraphQL response data
+     * Matches JavaScript SDK createFromGraphQL method exactly
+     */
+    static createFromGraphQL(data) {
+      let metas = data.metas || {};
+      if (Array.isArray(metas) && metas.length) {
+        try {
+          metas = JSON.parse(metas);
+          if (!metas) {
+            metas = {};
+          }
+        } catch (error62) {
+          metas = {};
+        }
+      }
+      return new _TokenUnit(
+        data.id,
+        data.name,
+        metas
+      );
+    }
+    /**
+     * Create TokenUnit from database array data
+     * Matches JavaScript SDK createFromDB method exactly
+     */
+    static createFromDB(data) {
+      return new _TokenUnit(
+        data[0],
+        data[1],
+        data.length > 2 ? data[2] : {}
+      );
+    }
+    /**
+     * Get fragment zone from metadata
+     * Matches JavaScript SDK getFragmentZone method exactly
+     */
+    getFragmentZone() {
+      return this.metas.fragmentZone || null;
+    }
+    /**
+     * Get fused token units from metadata
+     * Matches JavaScript SDK getFusedTokenUnits method exactly
+     */
+    getFusedTokenUnits() {
+      return this.metas.fusedTokenUnits || null;
+    }
+    /**
+     * Convert to data array format
+     * Matches JavaScript SDK toData method exactly
+     */
+    toData() {
+      return [this.id, this.name, this.metas];
+    }
+    /**
+     * Convert to GraphQL response format
+     * Matches JavaScript SDK toGraphQLResponse method exactly
+     */
+    toGraphQLResponse() {
+      return {
+        id: this.id,
+        name: this.name,
+        metas: JSON.stringify(this.metas)
+      };
+    }
+  };
+
   // node_modules/@noble/hashes/_u64.js
-  var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  var U32_MASK64 = /* @__PURE__ */ (() => BigInt(2 ** 32 - 1))();
   var _32n = /* @__PURE__ */ BigInt(32);
   function fromBig(n3, le = false) {
     if (le)
@@ -41232,44 +41479,60 @@ ${operationTypes.join("\n")}
     }
     return [Ah, Al];
   }
-  var rotlSH = (h3, l3, s2) => h3 << s2 | l3 >>> 32 - s2;
-  var rotlSL = (h3, l3, s2) => l3 << s2 | h3 >>> 32 - s2;
-  var rotlBH = (h3, l3, s2) => l3 << s2 - 32 | h3 >>> 64 - s2;
-  var rotlBL = (h3, l3, s2) => h3 << s2 - 32 | l3 >>> 64 - s2;
 
   // node_modules/@noble/hashes/utils.js
   function isBytes(a3) {
-    return a3 instanceof Uint8Array || ArrayBuffer.isView(a3) && a3.constructor.name === "Uint8Array";
+    return a3 instanceof Uint8Array || ArrayBuffer.isView(a3) && a3.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a3 && a3.BYTES_PER_ELEMENT === 1;
   }
+  var atitle = (title) => title ? `"${title}" ` : "";
   function anumber(n3, title = "") {
-    if (!Number.isSafeInteger(n3) || n3 < 0) {
-      const prefix = title && `"${title}" `;
-      throw new Error(`${prefix}expected integer >= 0, got ${n3}`);
-    }
+    if (typeof n3 !== "number")
+      throw new TypeError(atitle(title) + "expected number, got " + typeof n3);
+    if (!Number.isSafeInteger(n3) || n3 < 0)
+      throw new RangeError(atitle(title) + "expected integer >= 0, got " + n3);
+    return n3;
   }
-  function abytes(value2, length, title = "") {
-    const bytes = isBytes(value2);
-    const len = value2?.length;
-    const needsLen = length !== void 0;
-    if (!bytes || needsLen && len !== length) {
-      const prefix = title && `"${title}" `;
-      const ofLen = needsLen ? ` of length ${length}` : "";
-      const got = bytes ? `length=${len}` : `type=${typeof value2}`;
-      throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
-    }
+  function abool(value2, title = "") {
+    if (typeof value2 !== "boolean")
+      throw new TypeError(atitle(title) + "expected boolean, got type=" + typeof value2);
     return value2;
   }
+  function abytes(value2, length, title = "") {
+    if (isBytes(value2) && (length === void 0 || value2.length === length))
+      return value2;
+    if (length !== void 0)
+      anumber(length, "length");
+    const bytes = isBytes(value2);
+    const ofLen = length !== void 0 ? ` of length ${length}` : "";
+    const got = bytes ? `length=${value2.length}` : `type=${typeof value2}`;
+    const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+    if (!bytes)
+      throw new TypeError(message);
+    throw new RangeError(message);
+  }
+  var aobject = (value2, label) => {
+    if (value2 === null || typeof value2 !== "object" || Array.isArray(value2))
+      throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value2);
+  };
+  var aopts = (value2, label) => {
+    aobject(value2, label);
+    const proto = Object.getPrototypeOf(value2);
+    if (proto !== Object.prototype && proto !== null)
+      throw new TypeError(`"${label}" expected plain object`);
+    if (Object.hasOwn(value2, "__proto__"))
+      throw new TypeError(`"${label}.__proto__" is not allowed`);
+  };
   function aexists(instance, checkFinished = true) {
     if (instance.destroyed)
-      throw new Error("Hash instance has been destroyed");
+      throw new Error("hash was destroyed");
     if (checkFinished && instance.finished)
-      throw new Error("Hash#digest() has already been called");
+      throw new Error("digest() was already called");
   }
   function aoutput(out, instance) {
-    abytes(out, void 0, "digestInto() output");
+    abytes(out, void 0, "output");
     const min = instance.outputLen;
-    if (out.length < min) {
-      throw new Error('"digestInto() output" expected to be of length >=' + min);
+    if (!(out.length >= min)) {
+      throw new RangeError('"output" expected length >= ' + min);
     }
   }
   function u32(arr) {
@@ -41291,22 +41554,38 @@ ${operationTypes.join("\n")}
     return arr;
   }
   var swap32IfBE = isLE ? (u4) => u4 : byteSwap32;
+  function checkOpts(defaults, opts2, title = "opts") {
+    aopts(defaults, "defaults");
+    if (opts2 !== void 0)
+      aopts(opts2, title);
+    const merged = Object.assign(/* @__PURE__ */ Object.create(null), defaults, opts2);
+    return merged;
+  }
   function createHasher(hashCons, info = {}) {
+    if (typeof hashCons !== "function")
+      throw new TypeError('"hashCons" expected function, got type=' + typeof hashCons);
+    info = checkOpts({}, info, "info");
     const hashC = (msg, opts2) => hashCons(opts2).update(msg).digest();
     const tmp = hashCons(void 0);
     hashC.outputLen = tmp.outputLen;
     hashC.blockLen = tmp.blockLen;
+    hashC.canXOF = tmp.canXOF;
     hashC.create = (opts2) => hashCons(opts2);
     Object.assign(hashC, info);
     return Object.freeze(hashC);
   }
   function randomBytes(bytesLength = 32) {
+    anumber(bytesLength, "bytesLength");
     const cr = typeof globalThis === "object" ? globalThis.crypto : null;
     if (typeof cr?.getRandomValues !== "function")
       throw new Error("crypto.getRandomValues must be defined");
+    if (bytesLength > 65536)
+      throw new RangeError(`"bytesLength" expected <= 65536, got ${bytesLength}`);
     return cr.getRandomValues(new Uint8Array(bytesLength));
   }
   var oidNist = (suffix) => ({
+    // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+    // Larger suffix values would need base-128 OID encoding and a different length byte.
     oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
   });
 
@@ -41335,10 +41614,21 @@ ${operationTypes.join("\n")}
   var IOTAS = split(_SHA3_IOTA, true);
   var SHA3_IOTA_H = IOTAS[0];
   var SHA3_IOTA_L = IOTAS[1];
+  var rotlSH = (h3, l3, s2) => h3 << s2 | l3 >>> 32 - s2;
+  var rotlSL = (h3, l3, s2) => l3 << s2 | h3 >>> 32 - s2;
+  var rotlBH = (h3, l3, s2) => l3 << s2 - 32 | h3 >>> 64 - s2;
+  var rotlBL = (h3, l3, s2) => h3 << s2 - 32 | l3 >>> 64 - s2;
   var rotlH = (h3, l3, s2) => s2 > 32 ? rotlBH(h3, l3, s2) : rotlSH(h3, l3, s2);
   var rotlL = (h3, l3, s2) => s2 > 32 ? rotlBL(h3, l3, s2) : rotlSL(h3, l3, s2);
+  var B2 = new Uint32Array(5 * 2);
   function keccakP(s2, rounds = 24) {
-    const B2 = new Uint32Array(5 * 2);
+    if (!(s2 instanceof Uint32Array))
+      throw new TypeError('"s" expected Uint32Array(50), got type=' + typeof s2);
+    if (s2.length !== 50)
+      throw new RangeError('"s" expected Uint32Array(50), got length=' + s2.length);
+    anumber(rounds, "rounds");
+    if (rounds < 1 || rounds > 24)
+      throw new Error('"rounds" expected integer 1..24');
     for (let round = 24 - rounds; round < 24; round++) {
       for (let x2 = 0; x2 < 10; x2++)
         B2[x2] = s2[x2] ^ s2[x2 + 10] ^ s2[x2 + 20] ^ s2[x2 + 30] ^ s2[x2 + 40];
@@ -41367,10 +41657,17 @@ ${operationTypes.join("\n")}
         s2[PI + 1] = Tl;
       }
       for (let y3 = 0; y3 < 50; y3 += 10) {
-        for (let x2 = 0; x2 < 10; x2++)
-          B2[x2] = s2[y3 + x2];
-        for (let x2 = 0; x2 < 10; x2++)
-          s2[y3 + x2] ^= ~B2[(x2 + 2) % 10] & B2[(x2 + 4) % 10];
+        const b0 = s2[y3], b1 = s2[y3 + 1], b2 = s2[y3 + 2], b3 = s2[y3 + 3];
+        s2[y3] ^= ~s2[y3 + 2] & s2[y3 + 4];
+        s2[y3 + 1] ^= ~s2[y3 + 3] & s2[y3 + 5];
+        s2[y3 + 2] ^= ~s2[y3 + 4] & s2[y3 + 6];
+        s2[y3 + 3] ^= ~s2[y3 + 5] & s2[y3 + 7];
+        s2[y3 + 4] ^= ~s2[y3 + 6] & s2[y3 + 8];
+        s2[y3 + 5] ^= ~s2[y3 + 7] & s2[y3 + 9];
+        s2[y3 + 6] ^= ~s2[y3 + 8] & b0;
+        s2[y3 + 7] ^= ~s2[y3 + 9] & b1;
+        s2[y3 + 8] ^= ~b0 & b2;
+        s2[y3 + 9] ^= ~b1 & b3;
       }
       s2[0] ^= SHA3_IOTA_H[round];
       s2[1] ^= SHA3_IOTA_L[round];
@@ -41387,18 +41684,24 @@ ${operationTypes.join("\n")}
     blockLen;
     suffix;
     outputLen;
+    canXOF;
     enableXOF = false;
     rounds;
     // NOTE: we accept arguments in bytes instead of bits here.
     constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+      anumber(blockLen, "blockLen");
+      anumber(suffix, "suffix");
+      anumber(rounds, "rounds");
+      abool(enableXOF, "enableXOF");
       this.blockLen = blockLen;
       this.suffix = suffix;
       this.outputLen = outputLen;
       this.enableXOF = enableXOF;
+      this.canXOF = enableXOF;
       this.rounds = rounds;
       anumber(outputLen, "outputLen");
       if (!(0 < blockLen && blockLen < 200))
-        throw new Error("only keccak-f1600 function is supported");
+        throw new Error('"blockLen" must be 1..199');
       this.state = new Uint8Array(200);
       this.state32 = u32(this.state);
     }
@@ -41415,9 +41718,20 @@ ${operationTypes.join("\n")}
     update(data) {
       aexists(this);
       abytes(data);
-      const { blockLen, state } = this;
+      const { blockLen, state, state32 } = this;
       const len = data.length;
+      const canUseU32 = blockLen % 4 === 0 && data.byteOffset % 4 === 0;
+      const blockLen32 = blockLen / 4;
+      const data32 = canUseU32 && len >= blockLen ? u32(data) : void 0;
       for (let pos = 0; pos < len; ) {
+        if (data32 !== void 0 && this.pos === 0 && pos % 4 === 0 && len - pos >= blockLen) {
+          for (let i4 = 0, o3 = pos / 4; i4 < blockLen32; i4++)
+            state32[i4] ^= data32[o3 + i4];
+          pos += blockLen;
+          this.pos = blockLen;
+          this.keccak();
+          continue;
+        }
         const take2 = Math.min(blockLen - this.pos, len - pos);
         for (let i4 = 0; i4 < take2; i4++)
           state[this.pos++] ^= data[pos++];
@@ -41455,7 +41769,7 @@ ${operationTypes.join("\n")}
     }
     xofInto(out) {
       if (!this.enableXOF)
-        throw new Error("XOF is not possible for this instance");
+        throw new Error("XOF is not enabled");
       return this.writeInto(out);
     }
     xof(bytes) {
@@ -41466,12 +41780,13 @@ ${operationTypes.join("\n")}
       aoutput(out, this);
       if (this.finished)
         throw new Error("digest() was already called");
-      this.writeInto(out);
+      this.writeInto(out.length === this.outputLen ? out : out.subarray(0, this.outputLen));
       this.destroy();
-      return out;
     }
     digest() {
-      return this.digestInto(new Uint8Array(this.outputLen));
+      const out = new Uint8Array(this.outputLen);
+      this.digestInto(out);
+      return out;
     }
     destroy() {
       this.destroyed = true;
@@ -41480,6 +41795,7 @@ ${operationTypes.join("\n")}
     _cloneInto(to) {
       const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
       to ||= new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds);
+      to.blockLen = blockLen;
       to.state32.set(this.state32);
       to.pos = this.pos;
       to.posOut = this.posOut;
@@ -41488,6 +41804,7 @@ ${operationTypes.join("\n")}
       to.suffix = suffix;
       to.outputLen = outputLen;
       to.enableXOF = enableXOF;
+      to.canXOF = this.canXOF;
       to.destroyed = this.destroyed;
       return to;
     }
@@ -41505,35 +41822,73 @@ ${operationTypes.join("\n")}
     64,
     /* @__PURE__ */ oidNist(10)
   );
-  var genShake = (suffix, blockLen, outputLen, info = {}) => createHasher((opts2 = {}) => new Keccak(blockLen, suffix, opts2.dkLen === void 0 ? outputLen : opts2.dkLen, true), info);
+  var genShake = (suffix, blockLen, outputLen, info = {}) => createHasher((opts2 = {}) => {
+    opts2 = checkOpts({}, opts2);
+    return new Keccak(blockLen, suffix, opts2.dkLen === void 0 ? outputLen : opts2.dkLen, true);
+  }, info);
   var shake128 = /* @__PURE__ */ genShake(31, 168, 16, /* @__PURE__ */ oidNist(11));
   var shake2562 = /* @__PURE__ */ genShake(31, 136, 32, /* @__PURE__ */ oidNist(12));
 
+  // node_modules/@noble/curves/utils.js
+  function aobject2(value2, title = "object") {
+    if (value2 === null || typeof value2 !== "object" || Array.isArray(value2))
+      throw new TypeError(title === "object" ? "expected valid options object" : `"${title}" expected object, got type=${typeof value2}`);
+    return value2;
+  }
+  function validateObject(object2, fields = {}, optFields = {}, title = "object") {
+    aobject2(object2, title);
+    aobject2(fields, "fields");
+    aobject2(optFields, "optFields");
+    function checkField(fieldName, expectedType, isOpt) {
+      const label = title === "object" ? `param "${String(fieldName)}"` : `"${title}.${String(fieldName)}"`;
+      const val = object2[fieldName];
+      if (!Object.hasOwn(object2, fieldName) && (isOpt ? val !== void 0 : expectedType !== "function")) {
+        throw new TypeError(`${label} is invalid: expected own property`);
+      }
+      if (isOpt && val === void 0)
+        return;
+      const current = typeof val;
+      if (current !== expectedType || val === null)
+        throw new TypeError(`${label} is invalid: expected ${expectedType}, got ${current}`);
+    }
+    const iter = (f3, isOpt) => Object.entries(f3).forEach(([k2, v3]) => checkField(k2, v3, isOpt));
+    iter(fields, false);
+    iter(optFields, true);
+  }
+
   // node_modules/@noble/curves/abstract/fft.js
-  function checkU32(n3) {
+  function checkU32(n3, title = "n") {
+    if (typeof n3 !== "number")
+      throw new TypeError(`wrong u32 integer "${title}": expected number, got type=${typeof n3}`);
     if (!Number.isSafeInteger(n3) || n3 < 0 || n3 > 4294967295)
-      throw new Error("wrong u32 integer:" + n3);
+      throw new RangeError(`wrong u32 integer "${title}": expected 0..4294967295, got ${n3}`);
     return n3;
   }
   function isPowerOfTwo(x2) {
-    checkU32(x2);
+    checkU32(x2, "x");
     return (x2 & x2 - 1) === 0 && x2 !== 0;
   }
   function reverseBits(n3, bits) {
     checkU32(n3);
+    if (typeof bits !== "number")
+      throw new TypeError('"bits" expected number, got type=' + typeof bits);
+    if (!Number.isSafeInteger(bits) || bits < 0 || bits > 32)
+      throw new Error(`expected integer 0 <= bits <= 32, got ${bits}`);
     let reversed = 0;
     for (let i4 = 0; i4 < bits; i4++, n3 >>>= 1)
       reversed = reversed << 1 | n3 & 1;
-    return reversed;
+    return reversed >>> 0;
   }
   function log2(n3) {
     checkU32(n3);
     return 31 - Math.clz32(n3);
   }
   function bitReversalInplace(values) {
+    if (!values || typeof values !== "object" || typeof values.length !== "number")
+      throw new TypeError('"values" expected array-like, got type=' + typeof values);
     const n3 = values.length;
-    if (n3 < 2 || !isPowerOfTwo(n3))
-      throw new Error("n must be a power of 2 and greater than 1. Got " + n3);
+    if (!isPowerOfTwo(n3))
+      throw new Error("expected positive power-of-two length, got " + n3);
     const bits = log2(n3);
     for (let i4 = 0; i4 < n3; i4++) {
       const j2 = reverseBits(i4, bits);
@@ -41546,10 +41901,18 @@ ${operationTypes.join("\n")}
     return values;
   }
   var FFTCore = (F3, coreOpts) => {
+    validateObject(coreOpts, { N: "number", roots: "object", dit: "boolean" }, { invertButterflies: "boolean", skipStages: "number", brp: "boolean" }, "coreOpts");
     const { N: N3, roots, dit, invertButterflies = false, skipStages = 0, brp = true } = coreOpts;
+    checkU32(N3, "coreOpts.N");
     const bits = log2(N3);
     if (!isPowerOfTwo(N3))
       throw new Error("FFT: Polynomial size should be power of two");
+    checkU32(skipStages, "coreOpts.skipStages");
+    const maxSkipStages = bits === 0 ? 0 : bits - 1;
+    if (skipStages > maxSkipStages)
+      throw new Error(`FFT: wrong skipStages: expected 0 <= skipStages <= ${maxSkipStages}`);
+    if (roots.length !== N3)
+      throw new Error(`FFT: wrong roots length: expected ${N3}, got ${roots.length}`);
     const isDit = dit !== invertButterflies;
     return (values) => {
       if (values.length !== N3)
@@ -41590,8 +41953,19 @@ ${operationTypes.join("\n")}
   };
 
   // node_modules/@noble/post-quantum/utils.js
+  var abytesDoc = abytes;
   var randomBytes2 = randomBytes;
+  function aarray2(item, title, inner = () => {
+  }) {
+    if (!Array.isArray(item))
+      throw new TypeError(`"${title}" expected array, got type=${typeof item}`);
+    for (let i4 = 0; i4 < item.length; i4++)
+      inner(item[i4], `${title}[${i4}]`);
+    return item;
+  }
   function equalBytes(a3, b2) {
+    a3 = abytes(a3);
+    b2 = abytes(b2);
     if (a3.length !== b2.length)
       return false;
     let diff3 = 0;
@@ -41600,7 +41974,7 @@ ${operationTypes.join("\n")}
     return diff3 === 0;
   }
   function copyBytes(bytes) {
-    return Uint8Array.from(bytes);
+    return new Uint8Array(abytes(bytes));
   }
   function splitCoder(label, ...lengths) {
     const getLength = (c3) => typeof c3 === "number" ? c3 : c3.bytesLen;
@@ -41635,15 +42009,17 @@ ${operationTypes.join("\n")}
     };
   }
   function vecCoder(c3, vecLen) {
-    const bytesLen = vecLen * c3.bytesLen;
+    const coder = c3;
+    const bytesLen = vecLen * coder.bytesLen;
     return {
       bytesLen,
       encode: (u4) => {
-        if (u4.length !== vecLen)
-          throw new Error(`vecCoder.encode: wrong length=${u4.length}. Expected: ${vecLen}`);
+        const uArr = aarray2(u4, "u");
+        if (uArr.length !== vecLen)
+          throw new RangeError(`vecCoder.encode: wrong length=${uArr.length}. Expected: ${vecLen}`);
         const res = new Uint8Array(bytesLen);
-        for (let i4 = 0, pos = 0; i4 < u4.length; i4++) {
-          const b2 = c3.encode(u4[i4]);
+        for (let i4 = 0, pos = 0; i4 < uArr.length; i4++) {
+          const b2 = coder.encode(uArr[i4]);
           res.set(b2, pos);
           b2.fill(0);
           pos += b2.length;
@@ -41653,8 +42029,8 @@ ${operationTypes.join("\n")}
       decode: (a3) => {
         abytes(a3, bytesLen);
         const r3 = [];
-        for (let i4 = 0; i4 < a3.length; i4 += c3.bytesLen)
-          r3.push(c3.decode(a3.subarray(i4, i4 + c3.bytesLen)));
+        for (let i4 = 0; i4 < a3.length; i4 += coder.bytesLen)
+          r3.push(coder.decode(a3.subarray(i4, i4 + coder.bytesLen)));
         return r3;
       }
     };
@@ -41669,18 +42045,21 @@ ${operationTypes.join("\n")}
     }
   }
   function getMask(bits) {
-    return (1 << bits) - 1;
+    anumber(bits, "bits");
+    if (bits > 32)
+      throw new RangeError('"bits" expected <= 32, got ' + bits);
+    return bits === 32 ? 4294967295 : ~(-1 << bits) >>> 0;
   }
 
   // node_modules/@noble/post-quantum/_crystals.js
   var genCrystals = (opts2) => {
     const { newPoly, N: N3, Q: Q4, F: F3, ROOT_OF_UNITY: ROOT_OF_UNITY2, brvBits} = opts2;
-    const mod2 = (a3, modulo = Q4) => {
+    const mod = (a3, modulo = Q4) => {
       const result = a3 % modulo | 0;
       return (result >= 0 ? result | 0 : modulo + result | 0) | 0;
     };
     const smod = (a3, modulo = Q4) => {
-      const r3 = mod2(a3, modulo) | 0;
+      const r3 = mod(a3, modulo) | 0;
       return (r3 > modulo >> 1 ? r3 - modulo | 0 : r3) | 0;
     };
     function getZettas() {
@@ -41692,47 +42071,61 @@ ${operationTypes.join("\n")}
       }
       return out;
     }
-    const nttZetas2 = getZettas();
-    const field = {
-      add: (a3, b2) => mod2((a3 | 0) + (b2 | 0)) | 0,
-      sub: (a3, b2) => mod2((a3 | 0) - (b2 | 0)) | 0,
-      mul: (a3, b2) => mod2((a3 | 0) * (b2 | 0)) | 0,
-      inv: (_a3) => {
-        throw new Error("not implemented");
-      }
+    const nttZetas = getZettas();
+    const inv = (_a3) => {
+      throw new Error("not implemented");
     };
+    const field = {
+      add: (a3, b2) => {
+        const r3 = a3 + b2 | 0;
+        return r3 >= Q4 ? r3 - Q4 | 0 : r3;
+      },
+      sub: (a3, b2) => {
+        const r3 = a3 - b2 | 0;
+        return r3 < 0 ? r3 + Q4 | 0 : r3;
+      },
+      mul: (a3, b2) => mod((a3 | 0) * (b2 | 0)) | 0,
+      inv
+    } ;
     const nttOpts = {
       N: N3,
-      roots: nttZetas2,
+      roots: nttZetas,
       invertButterflies: true,
       skipStages: 1 ,
       brp: false
     };
     const dif = FFTCore(field, { dit: false, ...nttOpts });
     const dit = FFTCore(field, { dit: true, ...nttOpts });
-    const NTT2 = {
+    const NTT = {
       encode: (r3) => {
         return dif(r3);
       },
       decode: (r3) => {
         dit(r3);
         for (let i4 = 0; i4 < r3.length; i4++)
-          r3[i4] = mod2(F3 * r3[i4]);
+          r3[i4] = mod(F3 * r3[i4]);
         return r3;
       }
     };
-    const bitsCoder2 = (d4, c3) => {
+    const bitsCoder = (d4, c3) => {
+      for (let i4 = 0, bufLen = 0; i4 < N3; i4++) {
+        bufLen += d4;
+        if (bufLen > 32)
+          getMask(bufLen);
+        bufLen %= 8;
+      }
       const mask = getMask(d4);
       const bytesLen = d4 * (N3 / 8);
       return {
         bytesLen,
-        encode: (poly) => {
+        encode: (poly_) => {
+          const poly = poly_;
           const r3 = new Uint8Array(bytesLen);
           for (let i4 = 0, buf = 0, bufLen = 0, pos = 0; i4 < poly.length; i4++) {
             buf |= (c3.encode(poly[i4]) & mask) << bufLen;
             bufLen += d4;
             for (; bufLen >= 8; bufLen -= 8, buf >>= 8)
-              r3[pos++] = buf & getMask(bufLen);
+              r3[pos++] = buf & 255;
           }
           return r3;
         },
@@ -41748,7 +42141,16 @@ ${operationTypes.join("\n")}
         }
       };
     };
-    return { mod: mod2, smod, nttZetas: nttZetas2, NTT: NTT2, bitsCoder: bitsCoder2 };
+    return {
+      mod,
+      smod,
+      nttZetas,
+      NTT: {
+        encode: (r3) => NTT.encode(r3),
+        decode: (r3) => NTT.decode(r3)
+      },
+      bitsCoder
+    };
   };
   var createXofShake = (shake) => (seed, blockLen) => {
     if (!blockLen)
@@ -41786,43 +42188,57 @@ ${operationTypes.join("\n")}
   var Q2 = 3329;
   var F2 = 3303;
   var ROOT_OF_UNITY = 17;
-  var { mod, nttZetas, NTT, bitsCoder } = genCrystals({
+  var crystals = /* @__PURE__ */ genCrystals({
     N: N2,
     Q: Q2,
     F: F2,
     ROOT_OF_UNITY,
     newPoly: (n3) => new Uint16Array(n3),
     brvBits: 7});
-  var PARAMS = {
-    768: { N: N2, Q: Q2, K: 3, ETA1: 2, ETA2: 2, du: 10, dv: 4, RBGstrength: 192 }};
+  var PARAMS = /* @__PURE__ */ (() => Object.freeze({
+    512: Object.freeze({ N: N2, Q: Q2, K: 2, ETA1: 3, ETA2: 2, du: 10, dv: 4, RBGstrength: 128 }),
+    768: Object.freeze({ N: N2, Q: Q2, K: 3, ETA1: 2, ETA2: 2, du: 10, dv: 4, RBGstrength: 192 }),
+    1024: Object.freeze({ N: N2, Q: Q2, K: 4, ETA1: 2, ETA2: 2, du: 11, dv: 5, RBGstrength: 256 })
+  }))();
   var compress = (d4) => {
     if (d4 >= 12)
-      return { encode: (i4) => i4, decode: (i4) => i4 };
+      return { encode: (i4) => i4, decode: (i4) => i4 >= Q2 ? i4 - Q2 : i4 };
     const a3 = 2 ** (d4 - 1);
     return {
-      // const compress = (i: number) => round((2 ** d / Q) * i) % 2 ** d;
+      // This only matches standalone Compress_d after bitsCoder masks the result into Z_(2^d).
       encode: (i4) => ((i4 << d4) + Q2 / 2) / Q2,
       // const decompress = (i: number) => round((Q / 2 ** d) * i);
       decode: (i4) => i4 * Q2 + a3 >>> d4
     };
   };
-  var polyCoder = (d4) => bitsCoder(d4, compress(d4));
-  function polyAdd(a3, b2) {
-    for (let i4 = 0; i4 < N2; i4++)
-      a3[i4] = mod(a3[i4] + b2[i4]);
+  var byteCoder = (d4) => crystals.bitsCoder(d4, { encode: (i4) => i4, decode: (i4) => i4 >= Q2 ? i4 - Q2 : i4 } );
+  var polyCoder = (d4) => d4 === 12 ? byteCoder(12) : crystals.bitsCoder(d4, compress(d4));
+  function polyAdd(a_, b_) {
+    const a3 = a_;
+    const b2 = b_;
+    for (let i4 = 0; i4 < N2; i4++) {
+      const r3 = a3[i4] + b2[i4];
+      a3[i4] = r3 >= Q2 ? r3 - Q2 : r3;
+    }
   }
-  function polySub(a3, b2) {
-    for (let i4 = 0; i4 < N2; i4++)
-      a3[i4] = mod(a3[i4] - b2[i4]);
+  function polySub(a_, b_) {
+    const a3 = a_;
+    const b2 = b_;
+    for (let i4 = 0; i4 < N2; i4++) {
+      const r3 = a3[i4] - b2[i4];
+      a3[i4] = r3 < 0 ? r3 + Q2 : r3;
+    }
   }
   function BaseCaseMultiply(a0, a1, b0, b1, zeta) {
-    const c0 = mod(a1 * b1 * zeta + a0 * b0);
-    const c1 = mod(a0 * b1 + a1 * b0);
+    const c0 = crystals.mod(crystals.mod(a1 * b1) * zeta + a0 * b0);
+    const c1 = crystals.mod(a0 * b1 + a1 * b0);
     return { c0, c1 };
   }
-  function MultiplyNTTs(f3, g2) {
+  function MultiplyNTTs(f_, g_) {
+    const f3 = f_;
+    const g2 = g_;
     for (let i4 = 0; i4 < N2 / 2; i4++) {
-      let z3 = nttZetas[64 + (i4 >> 1)];
+      let z3 = crystals.nttZetas[64 + (i4 >> 1)];
       if (i4 & 1)
         z3 = -z3;
       const { c0, c1 } = BaseCaseMultiply(f3[2 * i4 + 0], f3[2 * i4 + 1], g2[2 * i4 + 0], g2[2 * i4 + 1], z3);
@@ -41831,7 +42247,8 @@ ${operationTypes.join("\n")}
     }
     return f3;
   }
-  function SampleNTT(xof) {
+  function SampleNTT(xof_) {
+    const xof = xof_;
     const r3 = new Uint16Array(N2);
     for (let j2 = 0; j2 < N2; ) {
       const b2 = xof();
@@ -41848,10 +42265,10 @@ ${operationTypes.join("\n")}
     }
     return r3;
   }
-  function sampleCBD(PRF, seed, nonce, eta) {
-    const buf = PRF(eta * N2 / 4, seed, nonce);
+  var sampleCBDBytes = (buf, eta) => {
     const r3 = new Uint16Array(N2);
     const b32 = u32(buf);
+    swap32IfBE(b32);
     let len = 0;
     for (let i4 = 0, p3 = 0, bb = 0, t0 = 0; i4 < b32.length; i4++) {
       let b2 = b32[i4];
@@ -41863,17 +42280,23 @@ ${operationTypes.join("\n")}
           t0 = bb;
           bb = 0;
         } else if (len === 2 * eta) {
-          r3[p3++] = mod(t0 - bb);
+          r3[p3++] = crystals.mod(t0 - bb);
           bb = 0;
           len = 0;
         }
       }
     }
+    swap32IfBE(b32);
     if (len)
       throw new Error(`sampleCBD: leftover bits: ${len}`);
     return r3;
+  };
+  function sampleCBD(PRF_, seed, nonce, eta) {
+    const PRF = PRF_;
+    return sampleCBDBytes(PRF(eta * N2 / 4, seed, nonce), eta);
   }
-  var genKPKE = (opts2) => {
+  var genKPKE = (opts_) => {
+    const opts2 = opts_;
     const { K: K2, PRF, XOF, HASH512, ETA1, ETA2, du, dv } = opts2;
     const poly1 = polyCoder(1);
     const polyV = polyCoder(dv);
@@ -41882,6 +42305,31 @@ ${operationTypes.join("\n")}
     const secretCoder = vecCoder(polyCoder(12), K2);
     const cipherCoder = splitCoder("ciphertext", vecCoder(polyU, K2), polyV);
     const seedCoder = splitCoder("seed", 32, 32);
+    const encryptCore = (tHat, getA, msg, seed) => {
+      const rHat = [];
+      for (let i4 = 0; i4 < K2; i4++)
+        rHat.push(crystals.NTT.encode(sampleCBD(PRF, seed, i4, ETA1)));
+      const tmp2 = new Uint16Array(N2);
+      const u4 = [];
+      for (let i4 = 0; i4 < K2; i4++) {
+        const e1 = sampleCBD(PRF, seed, K2 + i4, ETA2);
+        const tmp = new Uint16Array(N2);
+        for (let j2 = 0; j2 < K2; j2++) {
+          const aij = getA(i4, j2);
+          polyAdd(tmp, MultiplyNTTs(aij, rHat[j2]));
+        }
+        polyAdd(e1, crystals.NTT.decode(tmp));
+        u4.push(e1);
+        polyAdd(tmp2, MultiplyNTTs(tHat[i4], rHat[i4]));
+        cleanBytes(tmp);
+      }
+      const e22 = sampleCBD(PRF, seed, 2 * K2, ETA2);
+      polyAdd(e22, crystals.NTT.decode(tmp2));
+      const v3 = poly1.decode(msg);
+      polyAdd(v3, e22);
+      cleanBytes(tHat, rHat, tmp2, e22);
+      return cipherCoder.encode([u4, v3]);
+    };
     return {
       secretCoder,
       lengths: {
@@ -41890,7 +42338,7 @@ ${operationTypes.join("\n")}
         cipherText: cipherCoder.bytesLen
       },
       keygen: (seed) => {
-        abytes(seed, 32, "seed");
+        abytesDoc(seed, 32, "seed");
         const seedDst = new Uint8Array(33);
         seedDst.set(seed);
         seedDst[32] = K2;
@@ -41899,10 +42347,10 @@ ${operationTypes.join("\n")}
         const sHat = [];
         const tHat = [];
         for (let i4 = 0; i4 < K2; i4++)
-          sHat.push(NTT.encode(sampleCBD(PRF, sigma, i4, ETA1)));
+          sHat.push(crystals.NTT.encode(sampleCBD(PRF, sigma, i4, ETA1)));
         const x2 = XOF(rho);
         for (let i4 = 0; i4 < K2; i4++) {
-          const e4 = NTT.encode(sampleCBD(PRF, sigma, K2 + i4, ETA1));
+          const e4 = crystals.NTT.encode(sampleCBD(PRF, sigma, K2 + i4, ETA1));
           for (let j2 = 0; j2 < K2; j2++) {
             const aji = SampleNTT(x2.get(j2, i4));
             polyAdd(e4, MultiplyNTTs(aji, sHat[j2]));
@@ -41919,90 +42367,119 @@ ${operationTypes.join("\n")}
       },
       encrypt: (publicKey, msg, seed) => {
         const [tHat, rho] = publicCoder.decode(publicKey);
-        const rHat = [];
-        for (let i4 = 0; i4 < K2; i4++)
-          rHat.push(NTT.encode(sampleCBD(PRF, seed, i4, ETA1)));
         const x2 = XOF(rho);
-        const tmp2 = new Uint16Array(N2);
-        const u4 = [];
-        for (let i4 = 0; i4 < K2; i4++) {
-          const e1 = sampleCBD(PRF, seed, K2 + i4, ETA2);
-          const tmp = new Uint16Array(N2);
-          for (let j2 = 0; j2 < K2; j2++) {
-            const aij = SampleNTT(x2.get(i4, j2));
-            polyAdd(tmp, MultiplyNTTs(aij, rHat[j2]));
-          }
-          polyAdd(e1, NTT.decode(tmp));
-          u4.push(e1);
-          polyAdd(tmp2, MultiplyNTTs(tHat[i4], rHat[i4]));
-          cleanBytes(tmp);
-        }
+        const res = encryptCore(tHat, (i4, j2) => SampleNTT(x2.get(i4, j2)), msg, seed);
+        x2.clean();
+        return res;
+      },
+      // Expands the full  matrix (public data derived from rho) once, so repeated encryptions
+      // against the same ek skip the K² SampleNTT XOF expansions. Cached polys are copied per
+      // call because encryptCore mutates its inputs in place.
+      prepare: (publicKey) => {
+        const [tHat, rho] = publicCoder.decode(publicKey);
+        const x2 = XOF(rho);
+        const A2 = [];
+        for (let i4 = 0; i4 < K2; i4++)
+          for (let j2 = 0; j2 < K2; j2++)
+            A2.push(SampleNTT(x2.get(i4, j2)));
         x2.clean();
-        const e22 = sampleCBD(PRF, seed, 2 * K2, ETA2);
-        polyAdd(e22, NTT.decode(tmp2));
-        const v3 = poly1.decode(msg);
-        polyAdd(v3, e22);
-        cleanBytes(tHat, rHat, tmp2, e22);
-        return cipherCoder.encode([u4, v3]);
+        return {
+          encrypt: (msg, seed) => encryptCore(tHat.map((p3) => p3.slice()), (i4, j2) => A2[i4 * K2 + j2].slice(), msg, seed),
+          clean: () => cleanBytes(tHat, A2)
+        };
       },
       decrypt: (cipherText, privateKey) => {
         const [u4, v3] = cipherCoder.decode(cipherText);
         const sk = secretCoder.decode(privateKey);
         const tmp = new Uint16Array(N2);
         for (let i4 = 0; i4 < K2; i4++)
-          polyAdd(tmp, MultiplyNTTs(sk[i4], NTT.encode(u4[i4])));
-        polySub(v3, NTT.decode(tmp));
-        cleanBytes(tmp, sk, u4);
-        return poly1.encode(v3);
+          polyAdd(tmp, MultiplyNTTs(sk[i4], crystals.NTT.encode(u4[i4])));
+        polySub(v3, crystals.NTT.decode(tmp));
+        const res = poly1.encode(v3);
+        cleanBytes(tmp, sk, u4, v3);
+        return res;
       }
     };
   };
   function createKyber(opts2) {
-    const KPKE = genKPKE(opts2);
-    const { HASH256, HASH512, KDF } = opts2;
+    const rawOpts = opts2;
+    const KPKE = genKPKE(rawOpts);
+    const { HASH256, HASH512, KDF } = rawOpts;
     const { secretCoder: KPKESecretCoder, lengths } = KPKE;
     const secretCoder = splitCoder("secretKey", lengths.secretKey, lengths.publicKey, 32, 32);
     const msgLen = 32;
     const seedLen = 64;
-    return {
-      info: { type: "ml-kem" },
-      lengths: {
-        ...lengths,
-        seed: 64,
-        msg: msgLen,
-        msgRand: msgLen,
-        secretKey: secretCoder.bytesLen
-      },
-      keygen: (seed = randomBytes2(seedLen)) => {
-        abytes(seed, seedLen, "seed");
-        const { publicKey, secretKey: sk } = KPKE.keygen(seed.subarray(0, 32));
-        const publicKeyHash = HASH256(publicKey);
-        const secretKey = secretCoder.encode([sk, publicKey, publicKeyHash, seed.subarray(32)]);
-        cleanBytes(sk, publicKeyHash);
-        return { publicKey, secretKey };
+    const validateModulus = (publicKey, fn) => {
+      const eke = publicKey.subarray(0, 384 * rawOpts.K);
+      const ek = KPKESecretCoder.encode(KPKESecretCoder.decode(copyBytes(eke)));
+      const ok = equalBytes(ek, eke);
+      cleanBytes(ek);
+      if (!ok)
+        throw new Error(`ML-KEM.${fn}: wrong publicKey modulus`);
+    };
+    const kemLengths = Object.freeze({
+      ...lengths,
+      seed: 64,
+      msg: msgLen,
+      msgRand: msgLen,
+      secretKey: secretCoder.bytesLen
+    });
+    return Object.freeze({
+      info: Object.freeze({ type: "ml-kem" }),
+      lengths: kemLengths,
+      keygen: (seed) => {
+        const ownSeed = seed === void 0;
+        const s2 = ownSeed ? randomBytes2(seedLen) : seed;
+        let sk;
+        let publicKeyHash;
+        try {
+          abytesDoc(s2, seedLen, "seed");
+          const keys = KPKE.keygen(s2.subarray(0, 32));
+          const publicKey = keys.publicKey;
+          sk = keys.secretKey;
+          publicKeyHash = HASH256(publicKey);
+          const secretKey = secretCoder.encode([sk, publicKey, publicKeyHash, s2.subarray(32)]);
+          return {
+            publicKey,
+            secretKey
+          };
+        } finally {
+          if (sk !== void 0)
+            cleanBytes(sk);
+          if (publicKeyHash !== void 0)
+            cleanBytes(publicKeyHash);
+          if (ownSeed)
+            cleanBytes(s2);
+        }
       },
       getPublicKey: (secretKey) => {
         const [_sk, publicKey, _publicKeyHash, _z] = secretCoder.decode(secretKey);
         return Uint8Array.from(publicKey);
       },
-      encapsulate: (publicKey, msg = randomBytes2(msgLen)) => {
-        abytes(publicKey, lengths.publicKey, "publicKey");
-        abytes(msg, msgLen, "message");
-        const eke = publicKey.subarray(0, 384 * opts2.K);
-        const ek = KPKESecretCoder.encode(KPKESecretCoder.decode(copyBytes(eke)));
-        if (!equalBytes(ek, eke)) {
-          cleanBytes(ek);
-          throw new Error("ML-KEM.encapsulate: wrong publicKey modulus");
-        }
-        cleanBytes(ek);
-        const kr = HASH512.create().update(msg).update(HASH256(publicKey)).digest();
-        const cipherText = KPKE.encrypt(publicKey, msg, kr.subarray(32, 64));
-        cleanBytes(kr.subarray(32));
-        return { cipherText, sharedSecret: kr.subarray(0, 32) };
+      encapsulate: (publicKey, msg) => {
+        const ownMsg = msg === void 0;
+        const m2 = ownMsg ? randomBytes2(msgLen) : msg;
+        let kr;
+        try {
+          abytesDoc(publicKey, lengths.publicKey, "publicKey");
+          abytesDoc(m2, msgLen, "message");
+          validateModulus(publicKey, "encapsulate");
+          kr = HASH512.create().update(m2).update(HASH256(publicKey)).digest();
+          const cipherText = KPKE.encrypt(publicKey, m2, kr.subarray(32, 64));
+          return {
+            cipherText,
+            sharedSecret: kr.subarray(0, 32)
+          };
+        } finally {
+          if (kr !== void 0)
+            cleanBytes(kr.subarray(32));
+          if (ownMsg)
+            cleanBytes(m2);
+        }
       },
       decapsulate: (cipherText, secretKey) => {
-        abytes(secretKey, secretCoder.bytesLen, "secretKey");
-        abytes(cipherText, lengths.cipherText, "cipherText");
+        abytesDoc(secretKey, secretCoder.bytesLen, "secretKey");
+        abytesDoc(cipherText, lengths.cipherText, "cipherText");
         const k768 = secretCoder.bytesLen - 96;
         const start2 = k768 + 32;
         const test = HASH256(secretKey.subarray(k768 / 2, start2));
@@ -42015,25 +42492,76 @@ ${operationTypes.join("\n")}
         const cipherText2 = KPKE.encrypt(publicKey, msg, kr.subarray(32, 64));
         const isValid = equalBytes(cipherText, cipherText2);
         const Kbar = KDF.create({ dkLen: 32 }).update(z3).update(cipherText).digest();
-        cleanBytes(msg, cipherText2, !isValid ? Khat : Kbar);
+        cleanBytes(msg, cipherText2, kr.subarray(32), !isValid ? Khat : Kbar);
         return isValid ? Khat : Kbar;
+      },
+      /**
+       * Experimental prototype: pre-expand a public key so repeated encapsulate/decapsulate
+       * against the same key skip re-validation, H(ek), t̂ decoding and the K² SampleNTT
+       * XOF expansions of Â. Only public data is cached; see {@link KEMPrepared}.
+       */
+      prepare: (publicKey) => {
+        abytesDoc(publicKey, lengths.publicKey, "publicKey");
+        validateModulus(publicKey, "prepare");
+        const ek = copyBytes(publicKey);
+        const publicKeyHash = HASH256(ek);
+        const cached2 = KPKE.prepare(ek);
+        return Object.freeze({
+          publicKey: ek,
+          encapsulate: (msg) => {
+            const ownMsg = msg === void 0;
+            const m2 = ownMsg ? randomBytes2(msgLen) : msg;
+            let kr;
+            try {
+              abytesDoc(m2, msgLen, "message");
+              kr = HASH512.create().update(m2).update(publicKeyHash).digest();
+              const cipherText = cached2.encrypt(m2, kr.subarray(32, 64));
+              return {
+                cipherText,
+                sharedSecret: kr.subarray(0, 32)
+              };
+            } finally {
+              if (kr !== void 0)
+                cleanBytes(kr.subarray(32));
+              if (ownMsg)
+                cleanBytes(m2);
+            }
+          },
+          decapsulate: (cipherText, secretKey) => {
+            abytesDoc(secretKey, secretCoder.bytesLen, "secretKey");
+            abytesDoc(cipherText, lengths.cipherText, "cipherText");
+            const [sk, ekEmbedded, storedHash, z3] = secretCoder.decode(secretKey);
+            if (!equalBytes(ekEmbedded, ek) || !equalBytes(storedHash, publicKeyHash))
+              throw new Error("ML-KEM.decapsulate: secretKey does not match prepared publicKey");
+            const msg = KPKE.decrypt(cipherText, sk);
+            const kr = HASH512.create().update(msg).update(publicKeyHash).digest();
+            const Khat = kr.subarray(0, 32);
+            const cipherText2 = cached2.encrypt(msg, kr.subarray(32, 64));
+            const isValid = equalBytes(cipherText, cipherText2);
+            const Kbar = KDF.create({ dkLen: 32 }).update(z3).update(cipherText).digest();
+            cleanBytes(msg, cipherText2, kr.subarray(32), !isValid ? Khat : Kbar);
+            return isValid ? Khat : Kbar;
+          },
+          clean: cached2.clean
+        });
       }
-    };
+    });
   }
   function shakePRF(dkLen, key, nonce) {
     return shake2562.create({ dkLen }).update(key).update(new Uint8Array([nonce])).digest();
   }
-  var opts = {
+  var opts = /* @__PURE__ */ (() => ({
     HASH256: sha3_256,
     HASH512: sha3_512,
     KDF: shake2562,
     XOF: XOF128,
     PRF: shakePRF
-  };
-  var ml_kem768 = /* @__PURE__ */ createKyber({
+  }))();
+  var mk = (params) => createKyber({
     ...opts,
-    ...PARAMS[768]
+    ...params
   });
+  var ml_kem768 = /* @__PURE__ */ (() => mk(PARAMS[768]))();
 
   // src/core/Wallet.ts
   var Wallet = class _Wallet {
@@ -42176,11 +42704,13 @@ ${operationTypes.join("\n")}
       return typeof maybeBundleHash === "string" && isBundleHash(maybeBundleHash);
     }
     /**
-     * Get formatted token units from raw data
-     * Stub implementation for now
+     * Map raw token-unit tuples to TokenUnit instances.
+     * Matches JS SDK Wallet.getTokenUnits (Wallet.js:190-196). The serialised shape reaches hashed
+     * atom meta via AtomMeta.setAtomWallet -> JSON.stringify(getTokenUnitsData()), so returning raw
+     * tuples here would diverge from every other SDK.
      */
     static getTokenUnits(unitsData) {
-      return unitsData;
+      return unitsData.map((unitData) => TokenUnit.createFromDB(unitData));
     }
     /**
      * Create a remainder wallet for transactions
@@ -42480,7 +43010,7 @@ ${operationTypes.join("\n")}
   var TokenSlugSchema = external_exports.string().min(1, "Token slug cannot be empty").max(64, "Token slug cannot exceed 64 characters").transform((val) => val.toUpperCase()).brand();
   var MetaTypeSchema = external_exports.string().min(1, "Meta type cannot be empty").max(256, "Meta type cannot exceed 256 characters").brand();
   var MetaIdSchema = external_exports.string().min(1, "Meta ID cannot be empty").brand();
-  var BatchIdSchema = external_exports.string().min(1, "Batch ID cannot be empty").brand();
+  var BatchIdSchema = external_exports.string().regex(/^[0-9a-fA-F]{64}$/, "Batch ID must be 64 hexadecimal characters").brand();
   var CellSlugSchema = external_exports.string().min(1, "Cell slug cannot be empty").max(64, "Cell slug cannot exceed 64 characters").brand();
   var AtomIsotopeSchema = external_exports.enum(["C", "V", "U", "T", "M", "I", "R", "B", "F"], {
     error: "Invalid atom isotope. Must be one of: C, V, U, T, M, I, R, B, F"
@@ -42541,7 +43071,8 @@ ${operationTypes.join("\n")}
     socket: external_exports.unknown().optional(),
     serverSdkVersion: external_exports.number().int().min(1).optional(),
     logging: external_exports.boolean().optional(),
-    defaultRequestPolicy: external_exports.enum(["cache-first", "cache-only", "network-only", "cache-and-network"]).nullable().optional()
+    defaultRequestPolicy: external_exports.enum(["cache-first", "cache-only", "network-only", "cache-and-network"]).nullable().optional(),
+    secretStorage: external_exports.unknown().optional()
   }).strict();
   external_exports.object({
     token: external_exports.string().min(1, "Auth token cannot be empty"),
@@ -42804,58 +43335,6 @@ ${operationTypes.join("\n")}
   };
   var RuleArgumentException_default = RuleArgumentException;
 
-  // src/libraries/array.ts
-  function deepCloning(o3, h3) {
-    let i4;
-    let r3;
-    let x2;
-    const t3 = [Array, Date, Number, String, Boolean];
-    const s2 = Object.prototype.toString;
-    h3 = h3 || [];
-    for (i4 = 0; i4 < h3.length; i4 += 2) {
-      if (o3 === h3[i4]) {
-        return h3[i4 + 1];
-      }
-    }
-    if (!r3 && o3 && typeof o3 === "object") {
-      r3 = {};
-      for (i4 = 0; i4 < t3.length; i4++) {
-        if (s2.call(o3) === s2.call(x2 = new t3[i4](o3))) {
-          r3 = i4 ? x2 : [];
-        }
-      }
-      h3.push(o3, r3);
-      for (i4 in o3) {
-        if (Object.prototype.hasOwnProperty.call(o3, i4)) {
-          r3[i4] = deepCloning(o3[i4], h3);
-        }
-      }
-    }
-    return r3 || o3;
-  }
-  function chunkArray(arr, size) {
-    const chunks = [];
-    for (let i4 = 0; i4 < arr.length; i4 += size) {
-      chunks.push(arr.slice(i4, i4 + size));
-    }
-    return chunks;
-  }
-  function diff(...arrays) {
-    return [].concat(...arrays.map((arr, i4) => {
-      const others = arrays.slice(0);
-      others.splice(i4, 1);
-      const unique = [...new Set([].concat(...others))];
-      return arr.filter((item) => !unique.includes(item));
-    }));
-  }
-  function intersect(...arrays) {
-    if (arrays.length === 0) return [];
-    if (arrays.length === 1) return arrays[0];
-    return arrays.reduce(
-      (first, second) => first.filter((item) => second.includes(item))
-    );
-  }
-
   // src/instance/rules/Callback.ts
   init_exception();
   init_zod();
@@ -44187,6 +44666,51 @@ ${operationTypes.join("\n")}
       }));
       return this;
     }
+    /**
+     * Replenishes non-finite token supplies.
+     * Matches JS SDK Molecule.replenishToken (Molecule.js:521-566) exactly.
+     *
+     * Two orderings here are load-bearing for the molecular hash and must not be reordered:
+     * the remainder balance is computed BEFORE the source balance is overwritten, and the
+     * source V-atom is added BEFORE the remainder V-atom.
+     */
+    replenishToken({
+      amount,
+      units = []
+    }) {
+      if (amount < 0) {
+        throw new NegativeAmountException("Molecule::replenishToken() - Amount to replenish must be positive!");
+      }
+      if (!this.sourceWallet || !this.remainderWallet) {
+        throw new Error("Source and remainder wallets required for token replenishment");
+      }
+      if (units.length) {
+        const formatted = Wallet.getTokenUnits(units);
+        this.remainderWallet.tokenUnits = this.sourceWallet.tokenUnits;
+        for (const unit of formatted) {
+          this.remainderWallet.tokenUnits.push(unit);
+        }
+        this.remainderWallet.balance = String(this.remainderWallet.tokenUnits.length);
+        this.sourceWallet.tokenUnits = formatted;
+        this.sourceWallet.balance = String(this.sourceWallet.tokenUnits.length);
+      } else {
+        this.remainderWallet.balance = String(Number(this.sourceWallet.balance) + amount);
+        this.sourceWallet.balance = String(amount);
+      }
+      this.addAtom(Atom.create({
+        isotope: "V",
+        wallet: this.sourceWallet,
+        value: Number(this.sourceWallet.balance)
+      }));
+      this.addAtom(Atom.create({
+        isotope: "V",
+        wallet: this.remainderWallet,
+        value: Number(this.remainderWallet.balance),
+        metaType: "walletBundle",
+        metaId: this.remainderWallet.bundle
+      }));
+      return this;
+    }
     /**
      * Initialize authorization request
      * Creates U-isotope (authorization) atom for requesting auth token
@@ -46130,21 +46654,22 @@ ${operationTypes.join("\n")}
     }
   };
   var makeResult = (e4, r3, t3) => {
-    if (!("data" in r3 || "errors" in r3 && Array.isArray(r3.errors))) {
+    var a3 = r3.payload || r3;
+    if (!("data" in a3 || "errors" in a3 && Array.isArray(a3.errors))) {
       throw new Error("No Content");
     }
-    var a3 = "subscription" === e4.kind;
+    var n3 = "subscription" === e4.kind;
     return {
       operation: e4,
-      data: r3.data,
-      error: Array.isArray(r3.errors) ? new CombinedError({
-        graphQLErrors: r3.errors,
+      data: a3.data,
+      error: Array.isArray(a3.errors) ? new CombinedError({
+        graphQLErrors: a3.errors,
         response: t3
       }) : void 0,
-      extensions: r3.extensions ? {
-        ...r3.extensions
+      extensions: a3.extensions ? {
+        ...a3.extensions
       } : void 0,
-      hasNext: null == r3.hasNext ? a3 : r3.hasNext,
+      hasNext: null == r3.hasNext ? n3 : r3.hasNext,
       stale: false
     };
   };
@@ -46537,14 +47062,14 @@ ${operationTypes.join("\n")}
       var o3 = [];
       var s2 = {};
       for (var c3 = 0, u4 = r3.directives.length; c3 < u4; c3++) {
-        var p3 = r3.directives[c3];
-        var d4 = p3.name.value;
-        if ("_" !== d4[0]) {
-          o3.push(p3);
+        var d4 = r3.directives[c3];
+        var p3 = d4.name.value;
+        if ("_" !== p3[0]) {
+          o3.push(d4);
         } else {
-          d4 = d4.slice(1);
+          p3 = p3.slice(1);
         }
-        s2[d4] = p3;
+        s2[p3] = d4;
       }
       r3 = {
         ...r3,
@@ -46553,17 +47078,17 @@ ${operationTypes.join("\n")}
       };
     }
     if ("selectionSet" in r3) {
-      var v3 = [];
-      var l3 = r3.kind === e2.OPERATION_DEFINITION;
+      var l3 = [];
+      var v3 = r3.kind === e2.OPERATION_DEFINITION;
       if (r3.selectionSet) {
         for (var f3 = 0, h3 = r3.selectionSet.selections.length; f3 < h3; f3++) {
           var k2 = r3.selectionSet.selections[f3];
-          l3 = l3 || k2.kind === e2.FIELD && "__typename" === k2.name.value && !k2.alias;
+          v3 = v3 || k2.kind === e2.FIELD && "__typename" === k2.name.value && !k2.alias;
           var y3 = formatNode(k2);
-          v3.push(y3);
+          l3.push(y3);
         }
-        if (!l3) {
-          v3.push({
+        if (!v3) {
+          l3.push({
             kind: e2.FIELD,
             name: {
               kind: e2.NAME,
@@ -46576,7 +47101,7 @@ ${operationTypes.join("\n")}
           ...r3,
           selectionSet: {
             ...r3.selectionSet,
-            selections: v3
+            selections: l3
           }
         };
       }
@@ -46636,20 +47161,20 @@ ${operationTypes.join("\n")}
       s2 += arguments[0][c3];
     }
     o3.unshift(keyDocument(s2));
-    for (var p3 = 0; p3 < o3.length; p3++) {
-      for (var d4 = 0; d4 < o3[p3].definitions.length; d4++) {
-        var v3 = o3[p3].definitions[d4];
-        if (v3.kind === e2.FRAGMENT_DEFINITION) {
-          var l3 = v3.name.value;
-          var f3 = stringifyDocument(v3);
-          if (!a3.has(l3)) {
-            a3.set(l3, f3);
-            i4.push(v3);
-          } else if (a3.get(l3) !== f3) {
-            console.warn("[WARNING: Duplicate Fragment] A fragment with name `" + l3 + "` already exists in this document.\nWhile fragment names may not be unique across your source, each name must be unique per document.");
+    for (var d4 = 0; d4 < o3.length; d4++) {
+      for (var p3 = 0; p3 < o3[d4].definitions.length; p3++) {
+        var l3 = o3[d4].definitions[p3];
+        if (l3.kind === e2.FRAGMENT_DEFINITION) {
+          var v3 = l3.name.value;
+          var f3 = stringifyDocument(l3);
+          if (!a3.has(v3)) {
+            a3.set(v3, f3);
+            i4.push(l3);
+          } else if (a3.get(v3) !== f3) {
+            console.warn("[WARNING: Duplicate Fragment] A fragment with name `" + v3 + "` already exists in this document.\nWhile fragment names may not be unique across your source, each name must be unique per document.");
           }
         } else {
-          i4.push(v3);
+          i4.push(l3);
         }
       }
     }
@@ -46725,26 +47250,26 @@ ${operationTypes.join("\n")}
           });
           for (var c4 = 0; c4 < o4.length; c4++) {
             var u4 = o4[c4];
-            var p3 = i4.get(u4);
-            if (!p3) {
-              i4.set(u4, p3 = /* @__PURE__ */ new Set());
+            var d4 = i4.get(u4);
+            if (!d4) {
+              i4.set(u4, d4 = /* @__PURE__ */ new Set());
             }
-            for (var d4 of p3.values()) {
-              s3.add(d4);
+            for (var p3 of d4.values()) {
+              s3.add(p3);
             }
-            p3.clear();
+            d4.clear();
           }
-          for (var v3 of s3.values()) {
-            if (a3.has(v3)) {
-              n3 = a3.get(v3).operation;
-              a3.delete(v3);
+          for (var l3 of s3.values()) {
+            if (a3.has(l3)) {
+              n3 = a3.get(l3).operation;
+              a3.delete(l3);
               reexecuteOperation(r3, n3);
             }
           }
         } else if ("query" === n3.kind && e5.data) {
           a3.set(n3.key, e5);
-          for (var l3 = 0; l3 < o4.length; l3++) {
-            var f3 = o4[l3];
+          for (var v3 = 0; v3 < o4.length; v3++) {
+            var f3 = o4[v3];
             var h3 = i4.get(f3);
             if (!h3) {
               i4.set(f3, h3 = /* @__PURE__ */ new Set());
@@ -46795,13 +47320,12 @@ ${operationTypes.join("\n")}
                 complete() {
                   if (!i6) {
                     i6 = true;
-                    if ("subscription" === r5.kind) {
-                      a3.reexecuteOperation(makeOperation("teardown", r5, r5.context));
-                    }
                     if (u6 && u6.hasNext) {
                       nextResult({
                         hasNext: false
                       });
+                    } else if ("subscription" === r5.kind) {
+                      a3.reexecuteOperation(makeOperation("teardown", r5, r5.context));
                     }
                     e5.complete();
                   }
@@ -46817,8 +47341,8 @@ ${operationTypes.join("\n")}
           }));
         })(t5));
       }))(filter(((e5) => "teardown" !== e5.kind && u4(e5)))(r4));
-      var p3 = i4(filter(((e5) => "teardown" === e5.kind || !u4(e5)))(r4));
-      return merge2([t4, p3]);
+      var d4 = i4(filter(((e5) => "teardown" === e5.kind || !u4(e5)))(r4));
+      return merge2([t4, d4]);
     };
   };
   var fetchExchange = ({ forward: e4, dispatchDebug: r3 }) => (t3) => {
@@ -46910,7 +47434,7 @@ ${operationTypes.join("\n")}
       fetchSubscriptions: e4.fetchSubscriptions,
       fetchOptions: e4.fetchOptions,
       fetch: e4.fetch,
-      preferGetMethod: e4.preferGetMethod,
+      preferGetMethod: null != e4.preferGetMethod ? e4.preferGetMethod : "within-url-limit",
       requestPolicy: e4.requestPolicy || "cache-first"
     };
     var s2 = makeSubject();
@@ -46988,7 +47512,7 @@ ${operationTypes.join("\n")}
       return share(r4);
     };
     var u4 = this instanceof Client ? this : Object.create(Client.prototype);
-    var p3 = Object.assign(u4, {
+    var d4 = Object.assign(u4, {
       suspense: !!e4.suspense,
       operations$: s2.source,
       reexecuteOperation(e5) {
@@ -47027,7 +47551,7 @@ ${operationTypes.join("\n")}
           ...o3,
           ...n4,
           requestPolicy: n4.requestPolicy || o3.requestPolicy,
-          suspense: n4.suspense || false !== n4.suspense && p3.suspense
+          suspense: n4.suspense || false !== n4.suspense && d4.suspense
         });
       },
       executeRequestOperation(e5) {
@@ -47051,44 +47575,44 @@ ${operationTypes.join("\n")}
         })));
       },
       executeQuery(e5, r4) {
-        var t4 = p3.createRequestOperation("query", e5, r4);
-        return p3.executeRequestOperation(t4);
+        var t4 = d4.createRequestOperation("query", e5, r4);
+        return d4.executeRequestOperation(t4);
       },
       executeSubscription(e5, r4) {
-        var t4 = p3.createRequestOperation("subscription", e5, r4);
-        return p3.executeRequestOperation(t4);
+        var t4 = d4.createRequestOperation("subscription", e5, r4);
+        return d4.executeRequestOperation(t4);
       },
       executeMutation(e5, r4) {
-        var t4 = p3.createRequestOperation("mutation", e5, r4);
-        return p3.executeRequestOperation(t4);
+        var t4 = d4.createRequestOperation("mutation", e5, r4);
+        return d4.executeRequestOperation(t4);
       },
       readQuery(e5, r4, t4) {
         var n4 = null;
         subscribe(((e6) => {
           n4 = e6;
-        }))(p3.query(e5, r4, t4)).unsubscribe();
+        }))(d4.query(e5, r4, t4)).unsubscribe();
         return n4;
       },
-      query: (e5, r4, t4) => p3.executeQuery(createRequest(e5, r4), t4),
-      subscription: (e5, r4, t4) => p3.executeSubscription(createRequest(e5, r4), t4),
-      mutation: (e5, r4, t4) => p3.executeMutation(createRequest(e5, r4), t4)
+      query: (e5, r4, t4) => d4.executeQuery(createRequest(e5, r4), t4),
+      subscription: (e5, r4, t4) => d4.executeSubscription(createRequest(e5, r4), t4),
+      mutation: (e5, r4, t4) => d4.executeMutation(createRequest(e5, r4), t4)
     });
-    var d4 = noop;
+    var p3 = noop;
     {
       var { next: f3, source: x2 } = makeSubject();
-      p3.subscribeToDebugTarget = (e5) => subscribe(e5)(x2);
-      d4 = f3;
+      d4.subscribeToDebugTarget = (e5) => subscribe(e5)(x2);
+      p3 = f3;
     }
     var w2 = composeExchanges(e4.exchanges);
     var E2 = share(w2({
-      client: p3,
-      dispatchDebug: d4,
+      client: d4,
+      dispatchDebug: p3,
       forward: fallbackExchange({
-        dispatchDebug: d4
+        dispatchDebug: p3
       })
     })(s2.source));
     publish(E2);
-    return p3;
+    return d4;
   };
   var Q3 = C2;
 
@@ -47147,16 +47671,27 @@ ${operationTypes.join("\n")}
       return Q3({
         url: serverUri,
         exchanges,
-        // PQ-transport Phase E: when encryption is on, route fetch through the CipherHash wrapper
-        // (encrypt the request body to the validator's ML-KEM pubkey, decrypt the response).
-        // Omitted → urql uses the global fetch (plaintext).
-        ...this.cipherLink ? { fetch: ((input2, init) => this.cipherFetch(input2, init)) } : {},
+        // urql 5 had no default and always POSTed; urql 6 defaults to 'within-url-limit', which
+        // URL-encodes short queries and sends NO body. That would silently disable the CipherHash
+        // envelope below — cipherFetch's `typeof init.body === 'string'` guard fails on a GET, so
+        // the query would leave as plaintext URL parameters with no error. Pin POST explicitly.
+        preferGetMethod: false,
+        // Always route through our own fetch. Two reasons: (1) PQ-transport Phase E — when
+        // encryption is on, cipherFetch wraps the request body in the CipherHash envelope and
+        // decrypts the response; (2) the 60s timeout. urql's makeFetchSource unconditionally
+        // overwrites init.signal with its own AbortController, so a signal returned from
+        // fetchOptions() is discarded and never fired. Combining it here is the only place it
+        // survives.
+        fetch: ((input2, init) => {
+          const timeoutSignal = AbortSignal.timeout(6e4);
+          const signal = init?.signal && typeof AbortSignal.any === "function" ? AbortSignal.any([init.signal, timeoutSignal]) : init?.signal ?? timeoutSignal;
+          const timedInit = { ...init, signal };
+          return this.cipherLink ? this.cipherFetch(input2, timedInit) : fetch(input2, timedInit);
+        }),
         fetchOptions: () => ({
           headers: {
             "X-Auth-Token": this.$__authToken
-          },
-          // Add 60 second timeout
-          signal: AbortSignal.timeout(6e4)
+          }
         })
       });
     }
@@ -47672,12 +48207,12 @@ ${operationTypes.join("\n")}
   );
   var BatchIdSchema2 = createBrandedSchema(
     "BatchId",
-    // v3's `.uuid()` regex, inlined verbatim. Zod 4's `z.uuid()` additionally enforces the
-    // RFC 9562 version/variant nibbles and would reject batch IDs v3 accepted.
-    external_exports.string().regex(
-      /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
-      "Invalid batch ID format"
-    )
+    // 64 hex characters. generateBatchId (src/libraries/crypto.ts) returns either
+    // shake256(molecularHash + index, 256) — 256 bits, 64 hex chars — or randomString(64) over the
+    // alphabet 'abcdef0123456789'. A UUID shape matches nothing this SDK can produce, so the
+    // previous 8-4-4-4-12 regex rejected every real batch ID. Agrees with isBatchId in
+    // src/types/guards.ts.
+    external_exports.string().regex(/^[0-9a-fA-F]{64}$/, "Invalid batch ID format")
   );
   var CellSlugSchema2 = createBrandedSchema(
     "CellSlug",
@@ -47767,7 +48302,9 @@ ${operationTypes.join("\n")}
     // Optional default urql request policy for reads (server/sync clients pass
     // 'network-only'). Permitted by the strict schema so the constructor option
     // isn't rejected.
-    defaultRequestPolicy: external_exports.enum(["cache-first", "cache-only", "network-only", "cache-and-network"]).nullable().optional()
+    defaultRequestPolicy: external_exports.enum(["cache-first", "cache-only", "network-only", "cache-and-network"]).nullable().optional(),
+    // Pluggable hardware envelope encryption secret storage provider
+    secretStorage: external_exports.unknown().optional()
   }).strict();
   var EnvironmentConfigSchema = external_exports.object({
     NODE_ENV: external_exports.enum(["development", "production", "test"]).optional(),
@@ -48580,89 +49117,6 @@ ${operationTypes.join("\n")}
 
   // src/response/ResponseBalance.ts
   init_Response();
-
-  // src/core/TokenUnit.ts
-  var TokenUnit = class _TokenUnit {
-    id;
-    name;
-    metas;
-    /**
-     * Create new TokenUnit instance
-     * Matches JavaScript SDK constructor signature exactly
-     */
-    constructor(id, name2, metas) {
-      this.id = id;
-      this.name = name2;
-      this.metas = metas || {};
-    }
-    /**
-     * Create TokenUnit from GraphQL response data
-     * Matches JavaScript SDK createFromGraphQL method exactly
-     */
-    static createFromGraphQL(data) {
-      let metas = data.metas || {};
-      if (Array.isArray(metas) && metas.length) {
-        try {
-          metas = JSON.parse(metas);
-          if (!metas) {
-            metas = {};
-          }
-        } catch (error62) {
-          metas = {};
-        }
-      }
-      return new _TokenUnit(
-        data.id,
-        data.name,
-        metas
-      );
-    }
-    /**
-     * Create TokenUnit from database array data
-     * Matches JavaScript SDK createFromDB method exactly
-     */
-    static createFromDB(data) {
-      return new _TokenUnit(
-        data[0],
-        data[1],
-        data.length > 2 ? data[2] : {}
-      );
-    }
-    /**
-     * Get fragment zone from metadata
-     * Matches JavaScript SDK getFragmentZone method exactly
-     */
-    getFragmentZone() {
-      return this.metas.fragmentZone || null;
-    }
-    /**
-     * Get fused token units from metadata
-     * Matches JavaScript SDK getFusedTokenUnits method exactly
-     */
-    getFusedTokenUnits() {
-      return this.metas.fusedTokenUnits || null;
-    }
-    /**
-     * Convert to data array format
-     * Matches JavaScript SDK toData method exactly
-     */
-    toData() {
-      return [this.id, this.name, this.metas];
-    }
-    /**
-     * Convert to GraphQL response format
-     * Matches JavaScript SDK toGraphQLResponse method exactly
-     */
-    toGraphQLResponse() {
-      return {
-        id: this.id,
-        name: this.name,
-        metas: JSON.stringify(this.metas)
-      };
-    }
-  };
-
-  // src/response/ResponseBalance.ts
   var ResponseBalance = class _ResponseBalance extends exports.Response {
     /**
      * Class constructor
@@ -51201,6 +51655,12 @@ ${operationTypes.join("\n")}
     }
   };
 
+  // src/mutation/MutationReplenishToken.ts
+  var MutationReplenishToken = class extends MutationProposeMolecule {
+    fillMolecule() {
+    }
+  };
+
   // src/subscribe/Subscribe.ts
   init_exception();
   var Subscribe = class {
@@ -51420,9 +51880,134 @@ ${operationTypes.join("\n")}
 
   // src/KnishIOClient.ts
   init_exception();
+
+  // src/storage/MemorySecretStorageProvider.ts
+  init_SecretStorageException();
+
+  // src/libraries/secureMemory.ts
+  var textEncoder = new TextEncoder();
+  function zeroizeBytes(buffer) {
+    if (buffer instanceof Uint8Array) {
+      buffer.fill(0);
+    } else if (Array.isArray(buffer)) {
+      for (let i4 = 0; i4 < buffer.length; i4++) {
+        buffer[i4] = 0;
+      }
+    }
+  }
+  async function withSecureBytes(bytes, fn) {
+    try {
+      return await fn(bytes);
+    } finally {
+      zeroizeBytes(bytes);
+    }
+  }
+  async function withSecureString(secret, fn) {
+    const bytes = textEncoder.encode(secret);
+    try {
+      return await fn(secret);
+    } finally {
+      zeroizeBytes(bytes);
+    }
+  }
+  function constantTimeCompare(a3, b2) {
+    const bytesA = typeof a3 === "string" ? textEncoder.encode(a3) : a3;
+    const bytesB = typeof b2 === "string" ? textEncoder.encode(b2) : b2;
+    let result = bytesA.length === bytesB.length ? 0 : 1;
+    const len = Math.min(bytesA.length, bytesB.length);
+    for (let i4 = 0; i4 < len; i4++) {
+      const byteA = bytesA[i4] ?? 0;
+      const byteB = bytesB[i4] ?? 0;
+      result |= byteA ^ byteB;
+    }
+    if (typeof a3 === "string") zeroizeBytes(bytesA);
+    if (typeof b2 === "string") zeroizeBytes(bytesB);
+    return result === 0;
+  }
+
+  // src/storage/MemorySecretStorageProvider.ts
+  var MemorySecretStorageProvider = class {
+    providerType = "memory";
+    secrets = /* @__PURE__ */ new Map();
+    /**
+     * Memory storage is not hardware backed
+     */
+    isHardwareBacked() {
+      return false;
+    }
+    /**
+     * Memory storage is always available
+     */
+    async isAvailable() {
+      return true;
+    }
+    /**
+     * Store a secret in memory
+     */
+    async storeSecret(bundleHash, secret, options) {
+      if (!bundleHash) {
+        throw new exports.SecretStorageException("Bundle hash cannot be empty");
+      }
+      if (!secret) {
+        throw new exports.SecretStorageException("Secret cannot be empty");
+      }
+      const metadata = {
+        bundleHash,
+        label: options?.label,
+        createdAt: Date.now(),
+        hardwareBacked: false,
+        providerType: this.providerType
+      };
+      this.secrets.set(bundleHash, { secret, metadata });
+    }
+    /**
+     * Retrieve a secret from memory
+     */
+    async retrieveSecret(bundleHash) {
+      const entry = this.secrets.get(bundleHash);
+      return entry ? entry.secret : null;
+    }
+    /**
+     * Delete a stored secret
+     */
+    async deleteSecret(bundleHash) {
+      return this.secrets.delete(bundleHash);
+    }
+    /**
+     * Check if a secret exists
+     */
+    async hasSecret(bundleHash) {
+      return this.secrets.has(bundleHash);
+    }
+    /**
+     * List all stored secret metadata
+     */
+    async listSecrets() {
+      return Array.from(this.secrets.values()).map((entry) => ({ ...entry.metadata }));
+    }
+    /**
+     * Execute callback with unwrapped secret and ensure cleanup
+     */
+    async withSecret(bundleHash, fn) {
+      const entry = this.secrets.get(bundleHash);
+      if (!entry) {
+        throw exports.SecretStorageException.notFound(bundleHash);
+      }
+      return withSecureString(entry.secret, fn);
+    }
+    /**
+     * Clear all secrets from memory
+     */
+    clear() {
+      this.secrets.clear();
+    }
+  };
+
+  // src/KnishIOClient.ts
   var KnishIOClient = class {
     $__secret = "";
     $__bundle = "";
+    $__secretStorage = null;
     $__cellSlug = null;
     $__encrypt = false;
     $__uris = [];
@@ -51482,6 +52067,9 @@ ${operationTypes.join("\n")}
         logging,
         defaultRequestPolicy
       });
+      if (config2.secretStorage) {
+        this.$__secretStorage = config2.secretStorage;
+      }
     }
     /**
      * Initializes a new Knish.IO client session
@@ -51583,6 +52171,7 @@ ${operationTypes.join("\n")}
     reset() {
       this.$__secret = "";
       this.$__bundle = "";
+      this.$__secretStorage = null;
       this.$__encrypt = false;
       this.$__cellSlug = null;
       this.$__authToken = null;
@@ -51644,7 +52233,7 @@ ${operationTypes.join("\n")}
      * Returns whether a secret is stored for this session
      */
     hasSecret() {
-      return !!this.$__secret && this.$__secret.length > 0;
+      return !!this.$__secret && this.$__secret.length > 0 || !!this.$__secretStorage && !!this.$__bundle && this.$__bundle.length > 0;
     }
     /**
      * Returns the stored secret
@@ -51655,6 +52244,33 @@ ${operationTypes.join("\n")}
       }
       return this.$__secret;
     }
+    /**
+     * Sets the secret storage provider and optionally sets the bundle hash
+     */
+    setSecretStorage(storage, bundleHash) {
+      this.$__secretStorage = storage;
+      if (bundleHash) {
+        this.$__bundle = bundleHash;
+      }
+    }
+    /**
+     * Returns current secret storage provider
+     */
+    getSecretStorage() {
+      return this.$__secretStorage;
+    }
+    /**
+     * Asynchronously retrieves the secret from storage or returns in-memory secret
+     */
+    async retrieveSecret(options) {
+      if (this.$__secret && this.$__secret.length > 0) {
+        return this.$__secret;
+      }
+      if (this.$__secretStorage && this.$__bundle && this.$__bundle.length > 0) {
+        return await this.$__secretStorage.retrieveSecret(this.$__bundle, options);
+      }
+      return null;
+    }
     /**
      * Returns whether a bundle hash is being stored for this session
      */
@@ -51693,6 +52309,13 @@ ${operationTypes.join("\n")}
       remainderWallet = null
     } = {}) {
       this.log("info", "KnishIOClient::createMolecule() - Creating a new molecule...");
+      if (!secret) {
+        if (this.$__secret && this.$__secret.length > 0) {
+          secret = this.getSecret();
+        } else if (this.$__secretStorage && this.$__bundle && this.$__bundle.length > 0) {
+          secret = await this.$__secretStorage.retrieveSecret(this.$__bundle);
+        }
+      }
       secret = secret || this.getSecret();
       bundle = bundle || this.getBundle();
       let continuIdPosition = null;
@@ -51722,6 +52345,7 @@ ${operationTypes.join("\n")}
       }));
       return new Molecule({
         secret,
+        bundle,
         sourceWallet,
         remainderWallet: this.getRemainderWallet(),
         cellSlug: this.getCellSlug(),
@@ -51768,8 +52392,9 @@ ${operationTypes.join("\n")}
     async executeQuery(query, variables = null, context = {}) {
       if (this.$__authToken && this.$__authToken.isExpired() && !this.$__authInProcess) {
         this.log("info", "KnishIOClient::executeQuery() - Access token is expired. Getting new one...");
+        const authSecret = this.$__secret || await this.retrieveSecret() || "";
         await this.requestAuthToken({
-          secret: this.$__secret,
+          secret: authSecret,
           cellSlug: this.$__cellSlug,
           encrypt: this.$__encrypt
         });
@@ -51809,6 +52434,13 @@ ${operationTypes.join("\n")}
     setSecret(secret) {
       this.$__secret = secret;
       this.$__bundle = generateBundleHash(secret);
+      if (!this.$__secretStorage) {
+        const memStorage = new MemorySecretStorageProvider();
+        memStorage.storeSecret(this.$__bundle, secret);
+        this.$__secretStorage = memStorage;
+      } else {
+        this.$__secretStorage.storeSecret(this.$__bundle, secret);
+      }
     }
     /**
      * Sets the auth token for this session
@@ -51992,6 +52624,9 @@ ${operationTypes.join("\n")}
       if (secret === null && seed) {
         secret = generateSecret(seed);
       }
+      if (secret === null && this.$__secretStorage && this.$__bundle) {
+        secret = await this.$__secretStorage.retrieveSecret(this.$__bundle);
+      }
       if (cellSlug) {
         this.setCellSlug(cellSlug);
       }
@@ -52642,20 +53277,42 @@ ${operationTypes.join("\n")}
       return response;
     }
     /**
-     * Replenish tokens
+     * Replenish a non-finite token supply.
+     * Matches JS SDK KnishIOClient.replenishToken (KnishIOClient.js:2195-2231).
      */
     async replenishToken({
       token,
       amount = null,
       units = null,
-      sourceWallet: _sourceWallet = null
+      sourceWallet = null
     }) {
       this.log("info", `KnishIOClient::replenishToken() - Replenishing ${amount || "units"} of ${token}...`);
-      return this.requestTokens({
-        token,
-        amount,
-        units
+      if (!sourceWallet) {
+        sourceWallet = (await this.queryBalance({ token }))?.payload();
+      }
+      if (!sourceWallet) {
+        throw new exports.TransferBalanceException("Source wallet is missing or invalid.");
+      }
+      const remainderWallet = sourceWallet.createRemainder(this.getSecret());
+      const molecule = await this.createMolecule({
+        sourceWallet,
+        remainderWallet
+      });
+      molecule.replenishToken({
+        amount: Number(amount ?? 0),
+        units: units ?? []
+      });
+      molecule.sign({ bundle: this.getBundle() });
+      molecule.check();
+      const mutation = await this.createMoleculeMutation({
+        mutationClass: MutationReplenishToken,
+        molecule
       });
+      const response = await this.executeQuery(mutation);
+      if (!response) {
+        throw new CodeException("Token replenishment failed");
+      }
+      return response;
     }
     /**
      * Fuse token units
@@ -53106,75 +53763,298 @@ ${operationTypes.join("\n")}
 
   // src/index.ts
   init_Response();
+  init_exception();
 
-  // src/core/PolicyMeta.ts
-  var PolicyMeta = class _PolicyMeta {
-    policy;
+  // src/storage/WebCryptoSecretStorageProvider.ts
+  init_SecretStorageException();
+  var MemoryStorageBackend = class {
+    store = /* @__PURE__ */ new Map();
+    getItem(key) {
+      return this.store.get(key) ?? null;
+    }
+    setItem(key, value2) {
+      this.store.set(key, value2);
+    }
+    removeItem(key) {
+      return this.store.delete(key);
+    }
+    keys() {
+      return Array.from(this.store.keys());
+    }
+  };
+  function uint8ArrayToBase642(bytes) {
+    let binary = "";
+    const len = bytes.byteLength;
+    for (let i4 = 0; i4 < len; i4++) {
+      const byte = bytes[i4];
+      if (byte !== void 0) {
+        binary += String.fromCharCode(byte);
+      }
+    }
+    return btoa(binary);
+  }
+  function base64ToUint8Array2(base643) {
+    const binary = atob(base643);
+    const len = binary.length;
+    const bytes = new Uint8Array(len);
+    for (let i4 = 0; i4 < len; i4++) {
+      bytes[i4] = binary.charCodeAt(i4);
+    }
+    return bytes;
+  }
+  var textEncoder2 = new TextEncoder();
+  var textDecoder = new TextDecoder();
+  var KEY_PREFIX = "knishio:secret:";
+  var DEFAULT_ITERATIONS = 1e5;
+  var WebCryptoSecretStorageProvider = class {
+    providerType = "webcrypto-aes-gcm";
+    backend;
+    defaultPassphrase;
+    hardwareBacked;
+    constructor(options = {}) {
+      this.backend = options.backend ?? new MemoryStorageBackend();
+      this.defaultPassphrase = options.defaultPassphrase;
+      this.hardwareBacked = options.hardwareBacked ?? false;
+    }
     /**
-     * Create new PolicyMeta instance
-     * Matches JavaScript SDK constructor signature exactly
+     * Whether this provider is backed by hardware (e.g. WebAuthn PRF wrapping)
      */
-    constructor(policy = {}, metaKeys = []) {
-      this.policy = _PolicyMeta.normalizePolicy(policy);
-      this.fillDefault(metaKeys);
+    isHardwareBacked() {
+      return this.hardwareBacked;
     }
     /**
-     * Normalize policy object structure
-     * Matches JavaScript SDK normalizePolicy method exactly
+     * Check if WebCrypto subtle API is available
      */
-    static normalizePolicy(policy = {}) {
-      const policyMeta = {};
-      for (const [policyKey, value2] of Object.entries(policy)) {
-        if (value2 !== null && ["read", "write"].includes(policyKey)) {
-          policyMeta[policyKey] = {};
-          for (const [key, content] of Object.entries(value2)) {
-            policyMeta[policyKey][key] = content;
-          }
-        }
+    async isAvailable() {
+      return typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.subtle !== "undefined";
+    }
+    /**
+     * Derive an AES-GCM CryptoKey from a passphrase and salt using PBKDF2
+     */
+    async deriveKey(passphrase, salt, iterations = DEFAULT_ITERATIONS) {
+      if (!await this.isAvailable()) {
+        throw exports.SecretStorageException.unavailable(this.providerType, "WebCrypto API is not available");
+      }
+      const passphraseBytes = textEncoder2.encode(passphrase);
+      try {
+        const baseKey = await globalThis.crypto.subtle.importKey(
+          "raw",
+          passphraseBytes,
+          "PBKDF2",
+          false,
+          ["deriveKey"]
+        );
+        return await globalThis.crypto.subtle.deriveKey(
+          {
+            name: "PBKDF2",
+            salt,
+            iterations,
+            hash: "SHA-256"
+          },
+          baseKey,
+          { name: "AES-GCM", length: 256 },
+          false,
+          ["encrypt", "decrypt"]
+        );
+      } finally {
+        zeroizeBytes(passphraseBytes);
       }
-      return policyMeta;
     }
     /**
-     * Fill default policy values for metadata keys
-     * Matches JavaScript SDK fillDefault method exactly
+     * Store and encrypt a master secret
      */
-    fillDefault(metaKeys = []) {
-      const readPolicy = Array.from(this.policy).filter((item) => item.action === "read");
-      const writePolicy = Array.from(this.policy).filter((item) => item.action === "write");
-      for (const [type2, value2] of Object.entries({
-        read: readPolicy,
-        write: writePolicy
-      })) {
-        const policyKey = value2.map((item) => item.key);
-        if (!this.policy[type2]) {
-          this.policy[type2] = {};
-        }
-        for (const key of diff(metaKeys, policyKey)) {
-          if (!this.policy[type2][key]) {
-            this.policy[type2][key] = type2 === "write" && !["characters", "pubkey"].includes(key) ? ["self"] : ["all"];
-          }
+    async storeSecret(bundleHash, secret, options) {
+      if (!bundleHash) {
+        throw new exports.SecretStorageException("Bundle hash cannot be empty");
+      }
+      if (!secret) {
+        throw new exports.SecretStorageException("Secret cannot be empty");
+      }
+      const passphrase = options?.passphrase ?? this.defaultPassphrase;
+      if (!passphrase) {
+        throw new exports.SecretStorageException("Passphrase required for envelope encryption");
+      }
+      const salt = new Uint8Array(16);
+      const iv = new Uint8Array(12);
+      globalThis.crypto.getRandomValues(salt);
+      globalThis.crypto.getRandomValues(iv);
+      const key = await this.deriveKey(passphrase, salt, DEFAULT_ITERATIONS);
+      const secretBytes = textEncoder2.encode(secret);
+      try {
+        const encryptedBuffer = await globalThis.crypto.subtle.encrypt(
+          {
+            name: "AES-GCM",
+            iv
+          },
+          key,
+          secretBytes
+        );
+        const ciphertext = uint8ArrayToBase642(new Uint8Array(encryptedBuffer));
+        const metadata = {
+          bundleHash,
+          label: options?.label,
+          createdAt: Date.now(),
+          hardwareBacked: this.hardwareBacked,
+          providerType: this.providerType
+        };
+        const payload = {
+          version: 1,
+          ciphertext,
+          iv: uint8ArrayToBase642(iv),
+          salt: uint8ArrayToBase642(salt),
+          algorithm: "AES-GCM",
+          iterations: DEFAULT_ITERATIONS,
+          metadata
+        };
+        await this.backend.setItem(`${KEY_PREFIX}${bundleHash}`, JSON.stringify(payload));
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new exports.SecretStorageException(`Encryption failed: ${msg}`);
+      } finally {
+        zeroizeBytes(secretBytes);
+      }
+    }
+    /**
+     * Retrieve and decrypt the master secret
+     */
+    async retrieveSecret(bundleHash, options) {
+      const raw = await this.backend.getItem(`${KEY_PREFIX}${bundleHash}`);
+      if (!raw) {
+        return null;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        throw exports.SecretStorageException.decryptionFailed("Corrupted payload format");
+      }
+      const passphrase = options?.passphrase ?? this.defaultPassphrase;
+      if (!passphrase) {
+        throw new exports.SecretStorageException("Passphrase required for secret decryption");
+      }
+      const salt = base64ToUint8Array2(payload.salt);
+      const iv = base64ToUint8Array2(payload.iv);
+      const ciphertext = base64ToUint8Array2(payload.ciphertext);
+      try {
+        const key = await this.deriveKey(passphrase, salt, payload.iterations ?? DEFAULT_ITERATIONS);
+        const decryptedBuffer = await globalThis.crypto.subtle.decrypt(
+          {
+            name: "AES-GCM",
+            iv
+          },
+          key,
+          ciphertext
+        );
+        const decryptedBytes = new Uint8Array(decryptedBuffer);
+        try {
+          return textDecoder.decode(decryptedBytes);
+        } finally {
+          zeroizeBytes(decryptedBytes);
         }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw exports.SecretStorageException.decryptionFailed(msg);
       }
     }
     /**
-     * Get the policy object
-     * Matches JavaScript SDK get method exactly
+     * Delete a stored secret
      */
-    get() {
-      return this.policy;
+    async deleteSecret(bundleHash) {
+      const key = `${KEY_PREFIX}${bundleHash}`;
+      const result = await this.backend.removeItem(key);
+      return result !== false;
     }
     /**
-     * Convert policy to JSON string
-     * Matches JavaScript SDK toJson method exactly
+     * Check if a secret exists
      */
-    toJson() {
-      return JSON.stringify(this.get());
+    async hasSecret(bundleHash) {
+      const raw = await this.backend.getItem(`${KEY_PREFIX}${bundleHash}`);
+      return raw !== null;
+    }
+    /**
+     * List all stored secret metadata
+     */
+    async listSecrets() {
+      const keys = await this.backend.keys();
+      const matchingKeys = keys.filter((k2) => k2.startsWith(KEY_PREFIX));
+      const results = [];
+      for (const key of matchingKeys) {
+        const raw = await this.backend.getItem(key);
+        if (raw) {
+          try {
+            const payload = JSON.parse(raw);
+            if (payload.metadata) {
+              results.push(payload.metadata);
+            }
+          } catch {
+          }
+        }
+      }
+      return results;
+    }
+    /**
+     * Execute callback with unwrapped secret, zeroizing the decrypted buffer upon completion
+     */
+    async withSecret(bundleHash, fn, options) {
+      const raw = await this.backend.getItem(`${KEY_PREFIX}${bundleHash}`);
+      if (!raw) {
+        throw exports.SecretStorageException.notFound(bundleHash);
+      }
+      let payload;
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        throw exports.SecretStorageException.decryptionFailed("Corrupted payload format");
+      }
+      const passphrase = options?.passphrase ?? this.defaultPassphrase;
+      if (!passphrase) {
+        throw new exports.SecretStorageException("Passphrase required for secret decryption");
+      }
+      const salt = base64ToUint8Array2(payload.salt);
+      const iv = base64ToUint8Array2(payload.iv);
+      const ciphertext = base64ToUint8Array2(payload.ciphertext);
+      try {
+        const key = await this.deriveKey(passphrase, salt, payload.iterations ?? DEFAULT_ITERATIONS);
+        const decryptedBuffer = await globalThis.crypto.subtle.decrypt(
+          {
+            name: "AES-GCM",
+            iv
+          },
+          key,
+          ciphertext
+        );
+        const decryptedBytes = new Uint8Array(decryptedBuffer);
+        return await withSecureBytes(decryptedBytes, async (bytes) => {
+          const secretString = textDecoder.decode(bytes);
+          return await fn(secretString);
+        });
+      } catch (err) {
+        if (err instanceof exports.SecretStorageException) {
+          throw err;
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        throw exports.SecretStorageException.decryptionFailed(msg);
+      }
     }
   };
 
+  // src/storage/index.ts
+  function createDefaultSecretStorage(options = {}) {
+    if (options.type === "memory") {
+      return new MemorySecretStorageProvider();
+    }
+    if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.subtle !== "undefined") {
+      return new WebCryptoSecretStorageProvider({
+        backend: options.backend,
+        defaultPassphrase: options.defaultPassphrase,
+        hardwareBacked: options.hardwareBacked
+      });
+    }
+    return new MemorySecretStorageProvider();
+  }
+
   // src/index.ts
-  init_exception();
-  var SDK_VERSION = "0.9.5";
+  var SDK_VERSION = "0.9.7";
   var SDK_NAME = "KnishIO-Client-TS";
   var COMPATIBLE_SERVER_VERSIONS = [4, 5];
   var SDK_INFO = {
@@ -53265,8 +54145,8 @@ ${operationTypes.join("\n")}
   };
   /*! Bundled license information:
 
-  @noble/hashes/utils.js:
-    (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+  @noble/curves/utils.js:
+    (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
   @noble/post-quantum/utils.js:
   @noble/post-quantum/_crystals.js:
@@ -53285,6 +54165,8 @@ ${operationTypes.join("\n")}
   exports.GraphQLClient = GraphQLClient;
   exports.KnishIO = KnishIO;
   exports.KnishIOClient = KnishIOClient;
+  exports.MemorySecretStorageProvider = MemorySecretStorageProvider;
+  exports.MemoryStorageBackend = MemoryStorageBackend;
   exports.Meta = Meta;
   exports.Molecule = Molecule;
   exports.Mutation = Mutation;
@@ -53330,6 +54212,7 @@ ${operationTypes.join("\n")}
   exports.SDK_VERSION = SDK_VERSION;
   exports.TokenUnit = TokenUnit;
   exports.Wallet = Wallet;
+  exports.WebCryptoSecretStorageProvider = WebCryptoSecretStorageProvider;
   exports.base64ToHex = base64ToHex;
   exports.bufferToHexString = bufferToHexString;
   exports.capitalize = capitalize;
@@ -53337,8 +54220,10 @@ ${operationTypes.join("\n")}
   exports.chunkArray = chunkArray;
   exports.chunkSubstr = chunkSubstr;
   exports.configureSDK = configureSDK;
+  exports.constantTimeCompare = constantTimeCompare;
   exports.convertToBase17 = convertToBase17;
   exports.createBundleHash = createBundleHash;
+  exports.createDefaultSecretStorage = createDefaultSecretStorage;
   exports.createMolecularHash = createMolecularHash;
   exports.createPosition = createPosition;
   exports.createTokenSlug = createTokenSlug;
@@ -53380,6 +54265,9 @@ ${operationTypes.join("\n")}
   exports.validateSecret = validateSecret;
   exports.validateWalletAddress = validateWalletAddress;
   exports.verifyOTSSignature = verifyOTSSignature;
+  exports.withSecureBytes = withSecureBytes;
+  exports.withSecureString = withSecureString;
+  exports.zeroizeBytes = zeroizeBytes;
 
   return exports;