@katlux/providers 0.1.1-alpha.126 → 0.1.1-alpha.128

package/dist/index.cjs

@@ -18,6 +18,8 @@ function _interopNamespaceCompat(e) {
 
 const crypto__namespace = /*#__PURE__*/_interopNamespaceCompat(crypto$1);
 
+const DECRYPT_ERROR_SENTINEL = Symbol.for("katlux.decrypt_error");
+
 var EDataFilterOperator = /* @__PURE__ */ ((EDataFilterOperator2) => {
   EDataFilterOperator2["Equal"] = "==";
   EDataFilterOperator2["NotEqual"] = "!=";
@@ -672,878 +674,1725 @@ function isAuthOrDecryptionError(err) {
   const msg = String(err.message || "").toLowerCase();
   return msg.includes("operationerror") || msg.includes("decrypt") || msg.includes("tag") || msg.includes("aad") || msg.includes("authenticated additional data") || msg.includes("authenticate data") || msg.includes("mac");
 }
-
-class AEncryptionProvider {
-  defaultKey;
-  constructor(key) {
-    if (key !== void 0) {
-      this.defaultKey = key;
+function canonicalizeJson(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === void 0) {
+    return "";
+  }
+  if (value === null || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return "null";
+    if (Object.is(value, -0)) return "0";
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("Do not know how to serialize a BigInt");
+  }
+  if (typeof value === "symbol" || typeof value === "function") {
+    return "";
+  }
+  if (typeof value === "object") {
+    if (typeof value.toJSON === "function") {
+      return canonicalizeJson(value.toJSON(), seen);
+    }
+    if (seen.has(value)) {
+      throw new TypeError("Converting circular structure to JSON");
+    }
+    seen.add(value);
+    try {
+      if (Array.isArray(value)) {
+        const items = value.map((item) => {
+          if (item === void 0 || typeof item === "function" || typeof item === "symbol") {
+            return "null";
+          }
+          const res = canonicalizeJson(item, seen);
+          return res === "" ? "null" : res;
+        });
+        return `[${items.join(",")}]`;
+      }
+      const keys = Object.keys(value).sort();
+      const entries = [];
+      for (const key of keys) {
+        const val = value[key];
+        if (val === void 0 || typeof val === "function" || typeof val === "symbol") {
+          continue;
+        }
+        const serialized = canonicalizeJson(val, seen);
+        if (serialized !== "") {
+          entries.push(`${JSON.stringify(key)}:${serialized}`);
+        }
+      }
+      return `{${entries.join(",")}}`;
+    } finally {
+      seen.delete(value);
     }
   }
+  return JSON.stringify(value);
+}
+
+class CKeyManager {
+  // ── Binary & Encoding Utilities ──────────────────────────────────────────
   /**
-   * Sets or updates the default secret key, CryptoKey, or async key provider function.
+   * Generates a cryptographically secure random byte buffer of the specified length.
    */
-  setDefaultKey(key) {
-    this.defaultKey = key || void 0;
+  static randomBytes(length) {
+    const bytes = new Uint8Array(length);
+    return getRandomValues(bytes);
   }
   /**
-   * Retrieves the currently configured default key or key provider callback.
+   * Converts an ArrayBuffer or Uint8Array into a Base64-encoded string.
    */
-  getDefaultKey() {
-    return this.defaultKey;
+  static toBase64(buffer) {
+    return toBase64(buffer);
   }
   /**
-   * Pre-derives and caches the native CryptoKey for subsequent cryptographic operations.
-   * Subclasses should override this with a dedicated, non-side-effecting implementation.
+   * Converts a Base64 or Base64URL-encoded string back into a Uint8Array.
+   * Normalizes URL-safe characters and padding, strictly validating against the Base64 alphabet.
    */
-  async warmupKey(_options) {
+  static fromBase64(base64) {
+    if (typeof base64 !== "string") {
+      throw new Error("[CKeyManager] Invalid base64 input: expected string");
+    }
+    const cleaned = base64.replace(/\s+/g, "");
+    if (!cleaned) return new Uint8Array(0);
+    const normalized = cleaned.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized.padEnd(normalized.length + (4 - normalized.length % 4) % 4, "=");
+    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(padded)) {
+      throw new Error("[CKeyManager] Invalid base64 string");
+    }
+    if (typeof Buffer !== "undefined") {
+      const buf = Buffer.from(padded, "base64");
+      const arrayBuf = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+      return new Uint8Array(arrayBuf);
+    }
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
   }
   /**
-   * Resolves raw key from keyProvider callback or defaultKey.
+   * Deterministically resolves a salt from Uint8Array, ArrayBuffer, Base64/Base64URL string, or raw text string.
+   * Guarantees 100% identical salt byte resolution between Node.js and Browser environments.
    */
-  async resolveRawKey(keyProvider) {
-    const target = keyProvider || this.defaultKey;
-    if (!target) {
-      throw new Error(
-        `[${this.constructor.name}] No encryption key or keyProvider was supplied. Key cannot be empty or undefined. A valid key must be supplied from your authentication or secret management system.`
-      );
+  static resolveSalt(salt) {
+    if (!salt) return CKeyManager.randomBytes(16);
+    if (ArrayBuffer.isView(salt)) {
+      return salt.byteLength > 0 ? new Uint8Array(salt.buffer.slice(salt.byteOffset, salt.byteOffset + salt.byteLength)) : CKeyManager.randomBytes(16);
     }
-    const rawKey = typeof target === "function" ? await target() : target;
-    if (!rawKey || typeof rawKey === "string" && rawKey.trim().length === 0 || typeof rawKey === "object" && "byteLength" in rawKey && rawKey.byteLength === 0) {
-      throw new Error(
-        `[${this.constructor.name}] No encryption key or keyProvider was supplied. Key provider resolved to empty or undefined key.`
-      );
+    if (salt instanceof ArrayBuffer) {
+      return salt.byteLength > 0 ? new Uint8Array(salt.slice(0)) : CKeyManager.randomBytes(16);
     }
-    return rawKey;
+    if (typeof salt === "string") {
+      const trimmed = salt.trim();
+      if (!trimmed) return CKeyManager.randomBytes(16);
+      if (trimmed.startsWith("base64:")) {
+        return CKeyManager.fromBase64(trimmed.slice(7));
+      }
+      if (trimmed.endsWith("=") && /^[A-Za-z0-9+/]+={1,2}$/.test(trimmed)) {
+        try {
+          const decoded = CKeyManager.fromBase64(trimmed);
+          if (decoded.byteLength > 0) return decoded;
+        } catch {
+        }
+      }
+      const encoded = textEncoder$1.encode(trimmed);
+      return encoded.byteLength > 0 ? encoded : CKeyManager.randomBytes(16);
+    }
+    return CKeyManager.randomBytes(16);
   }
+  // ── Symmetric Key Management ─────────────────────────────────────────────
   /**
-   * Checks whether the given payload is an encrypted envelope.
+   * Generates a random AES CryptoKey suitable for AES-GCM or AES-CBC.
+   *
+   * E2EE Threat Model Note: Focuses on protecting GDPR/tenant data against database and
+   * server-side leaks. Keys remain extractable by default to enable role-based key sharing,
+   * wrapping, and transfer between authorized client sessions in multi-user SaaS apps.
+   * Client-side malware/trojan protection is out of scope.
    */
-  static isEncrypted(payload) {
-    if (!payload || typeof payload !== "object") return false;
-    return payload.__encrypted === true && typeof payload.ciphertext === "string" && typeof payload.iv === "string";
+  static async generateAESKey(length = 256, algorithm = "AES-GCM", extractable = true) {
+    const subtle = getSubtleCrypto();
+    const usages = algorithm === "AES-KW" ? ["wrapKey", "unwrapKey"] : ["encrypt", "decrypt"];
+    return await subtle.generateKey(
+      { name: algorithm, length },
+      extractable,
+      usages
+    );
   }
   /**
-   * Checks whether the given payload is an encrypted envelope.
+   * Exports an AES CryptoKey as a raw base64 string.
    */
-  isEncrypted(payload) {
-    return AEncryptionProvider.isEncrypted(payload);
+  static async exportAESKey(key) {
+    const subtle = getSubtleCrypto();
+    const raw = await subtle.exportKey("raw", key);
+    try {
+      return CKeyManager.toBase64(raw);
+    } finally {
+      new Uint8Array(raw).fill(0);
+    }
   }
   /**
-   * Clears configured keys and cached cryptographic material from memory.
+   * Imports an AES CryptoKey from a raw base64 string.
    */
-  clearKeys() {
-    this.defaultKey = void 0;
+  static async importAESKey(base64, algorithm = "AES-GCM", extractable = false) {
+    const subtle = getSubtleCrypto();
+    const rawBytes = CKeyManager.fromBase64(base64);
+    if (rawBytes.length !== 16 && rawBytes.length !== 24 && rawBytes.length !== 32) {
+      rawBytes.fill(0);
+      throw new Error(`[CKeyManager] Invalid AES key length: expected 16, 24, or 32 bytes (128, 192, or 256 bits), got ${rawBytes.length} bytes.`);
+    }
+    const usages = algorithm === "AES-KW" ? ["wrapKey", "unwrapKey"] : ["encrypt", "decrypt"];
+    try {
+      return await subtle.importKey(
+        "raw",
+        rawBytes,
+        { name: algorithm },
+        extractable,
+        usages
+      );
+    } finally {
+      rawBytes.fill(0);
+    }
   }
+  // ── Asymmetric Key Pair Management ───────────────────────────────────────
   /**
-   * Alias for clearKeys() to conform with standard disposal patterns.
+   * Generates an RSA-OAEP public/private key pair (2048 or 4096 bits).
    */
-  dispose() {
-    this.clearKeys();
+  static async generateRSAKeyPair(bits = 4096, hash = "SHA-256", extractable = true) {
+    const subtle = getSubtleCrypto();
+    const pair = await subtle.generateKey(
+      {
+        name: "RSA-OAEP",
+        modulusLength: bits,
+        publicExponent: new Uint8Array([1, 0, 1]),
+        hash
+      },
+      extractable,
+      ["encrypt", "decrypt", "wrapKey", "unwrapKey"]
+    );
+    return {
+      publicKey: pair.publicKey,
+      privateKey: pair.privateKey
+    };
   }
   /**
-   * ECMAScript Explicit Resource Management protocol (using / await using declarations).
+   * Generates an ECDH public/private key pair for elliptic curve Diffie-Hellman.
    */
-  [Symbol.dispose]() {
-    this.dispose();
-  }
-  async [Symbol.asyncDispose]() {
-    this.dispose();
+  static async generateECDHKeyPair(curve = "P-256", extractable = true) {
+    const subtle = getSubtleCrypto();
+    const pair = await subtle.generateKey(
+      {
+        name: "ECDH",
+        namedCurve: curve
+      },
+      extractable,
+      ["deriveKey", "deriveBits"]
+    );
+    return {
+      publicKey: pair.publicKey,
+      privateKey: pair.privateKey
+    };
   }
   /**
-   * Resolves effective Authenticated Additional Data (AAD) for the operation:
-   * 1. If options.bindRequestContextAad is explicitly false, returns options.aad directly without context binding.
-   * 2. When encrypting (isDecrypt=false): binds request context `req:${method}:${url}` only if options.bindRequestContextAad === true.
-   * 3. When decrypting (isDecrypt=true): derives request context `req:${method}:${url}` if url or method is provided.
-   * 4. If explicit options.aad is provided: combines with request context if bound, or returns options.aad directly.
-   * 5. Otherwise returns undefined.
+   * Exports a public CryptoKey to a portable JsonWebKey (JWK).
    */
-  _resolveEffectiveAad(options, isDecrypt = false) {
-    if (!options) return void 0;
-    if (options.bindRequestContextAad === false) return options.aad;
-    const hasReqContext = Boolean(options.url || options.method);
-    if (options.aad) {
-      if (options.bindRequestContextAad === true && hasReqContext) {
-        const m = (options.method || "POST").toUpperCase();
-        const u = options.url || "";
-        const baseAad = typeof options.aad === "string" ? options.aad : options.aad instanceof Uint8Array || options.aad instanceof ArrayBuffer ? textDecoder.decode(options.aad) : String(options.aad);
-        return `${baseAad}|req:${m}:${u}`;
-      }
-      return options.aad;
-    }
-    const shouldBindReq = isDecrypt ? hasReqContext : options.bindRequestContextAad === true && hasReqContext;
-    if (shouldBindReq) {
-      const m = (options.method || "POST").toUpperCase();
-      const u = options.url || "";
-      return `req:${m}:${u}`;
-    }
-    return void 0;
+  static async exportPublicKey(key) {
+    const subtle = getSubtleCrypto();
+    return await subtle.exportKey("jwk", key);
   }
   /**
-   * Helper to deterministically bind record ID and field name into the AAD
-   * to prevent ciphertext swapping between fields or records.
+   * Exports a private CryptoKey to a portable JsonWebKey (JWK).
    */
-  _bindFieldAad(data, field, options) {
-    let baseAad = "";
-    if (options?.aad) {
-      if (typeof options.aad === "string") baseAad = options.aad;
-      else if (options.aad instanceof Uint8Array || options.aad instanceof ArrayBuffer) {
-        baseAad = textDecoder.decode(options.aad);
-      } else {
-        baseAad = String(options.aad);
-      }
-    }
-    const recordId = data && typeof data === "object" && (data.id !== void 0 || data._id !== void 0) ? String(data.id ?? data._id) : "";
-    const recordPart = recordId ? `|record:${recordId}` : "";
-    const reqPart = options?.bindRequestContextAad === true && (options?.url || options?.method) ? `|req:${(options.method || "POST").toUpperCase()}:${options.url || ""}` : "";
-    return {
-      ...options,
-      aad: `aad:${baseAad}${recordPart}${reqPart}|field:${field}`
-    };
+  static async exportPrivateKey(key) {
+    const subtle = getSubtleCrypto();
+    return await subtle.exportKey("jwk", key);
   }
   /**
-   * Top-level polymorphic encryption method.
-   * Automatically performs value-level encryption:
-   * - If data is an array of objects: recursively encrypts each row.
-   * - If data is an object: encrypts specified fields (or all values if valueEncryption is true),
-   *   preserving JSON object keys so backend APIs and ORMs can parse keys and perform upserts.
-   * - If data is a primitive or whole-payload envelope: encrypts as a single value.
+   * Imports a public key from a JsonWebKey (JWK).
    */
-  async encrypt(data, options) {
-    if (data === void 0 || data === null) return data;
-    if (this.isEncrypted(data)) return data;
-    if (options?.valueEncryption === false && (!options.fields || options.fields.length === 0)) {
-      return this.encryptValue(data, options);
-    }
-    if (Array.isArray(data)) {
-      if (data.length === 0) return data;
-      if (options?.fields && options.fields.length > 0) {
-        const fields = options.fields;
-        let hasUnencrypted = false;
-        for (let i = 0; i < data.length; i++) {
-          const item = data[i];
-          if (item && typeof item === "object") {
-            for (let f = 0; f < fields.length; f++) {
-              const val = item[fields[f]];
-              if (val !== void 0 && val !== null && !this.isEncrypted(val)) {
-                hasUnencrypted = true;
-                break;
-              }
-            }
-            if (hasUnencrypted) break;
-          }
+  static async importPublicKey(jwk, algorithm) {
+    const subtle = getSubtleCrypto();
+    let importAlgorithm = algorithm;
+    let usages;
+    const isEC = jwk.kty === "EC" || typeof algorithm === "object" && algorithm?.name === "ECDH" || algorithm === "ECDH";
+    if (isEC) {
+      usages = [];
+      if (!importAlgorithm || importAlgorithm === "ECDH") {
+        importAlgorithm = { name: "ECDH", namedCurve: jwk.crv || "P-256" };
+      }
+    } else {
+      usages = ["encrypt", "wrapKey"];
+      if (!importAlgorithm || importAlgorithm === "RSA-OAEP") {
+        if (jwk.kty === "RSA") {
+          const hash = jwk.alg === "RSA-OAEP-512" ? "SHA-512" : "SHA-256";
+          importAlgorithm = { name: "RSA-OAEP", hash };
+        } else {
+          throw new Error(`[CKeyManager] Unsupported JWK kty: ${jwk.kty}`);
         }
-        if (!hasUnencrypted) {
-          return data;
+      }
+    }
+    return await subtle.importKey("jwk", jwk, importAlgorithm, true, usages);
+  }
+  /**
+   * Imports a private key from a JsonWebKey (JWK).
+   */
+  static async importPrivateKey(jwk, algorithm) {
+    const subtle = getSubtleCrypto();
+    let importAlgorithm = algorithm;
+    let usages;
+    const isEC = jwk.kty === "EC" || typeof algorithm === "object" && algorithm?.name === "ECDH" || algorithm === "ECDH";
+    if (isEC) {
+      usages = ["deriveKey", "deriveBits"];
+      if (!importAlgorithm || importAlgorithm === "ECDH") {
+        importAlgorithm = { name: "ECDH", namedCurve: jwk.crv || "P-256" };
+      }
+    } else {
+      usages = ["decrypt", "unwrapKey"];
+      if (!importAlgorithm || importAlgorithm === "RSA-OAEP") {
+        if (jwk.kty === "RSA") {
+          const hash = jwk.alg === "RSA-OAEP-512" ? "SHA-512" : "SHA-256";
+          importAlgorithm = { name: "RSA-OAEP", hash };
+        } else {
+          throw new Error(`[CKeyManager] Unsupported JWK kty: ${jwk.kty}`);
         }
-        await this.warmupKey(options);
-        const itemOptions = { ...options, _warmed: true };
-        return Promise.all(data.map((item) => this.encrypt(item, itemOptions)));
       }
-      if (options?.valueEncryption === true) {
-        await this.warmupKey(options);
-        const itemOptions = { ...options, _warmed: true };
-        return Promise.all(data.map((item) => this.encrypt(item, itemOptions)));
+    }
+    return await subtle.importKey("jwk", jwk, importAlgorithm, true, usages);
+  }
+  /**
+   * Imports a public key from a PEM (SPKI) or base64 SPKI string.
+   */
+  static async importPublicKeyFromPEM(pem, algorithm = "RSA-OAEP", curve = "P-256", hash = "SHA-256") {
+    const subtle = getSubtleCrypto();
+    const cleaned = pem.replace(/-----BEGIN[ A-Z0-9_-]+-----/g, "").replace(/-----END[ A-Z0-9_-]+-----/g, "").replace(/\s+/g, "");
+    const spkiBytes = CKeyManager.fromBase64(cleaned);
+    let importAlgorithm;
+    let usages;
+    if (algorithm === "ECDH") {
+      importAlgorithm = { name: "ECDH", namedCurve: curve };
+      usages = [];
+    } else if (algorithm === "ECDSA") {
+      importAlgorithm = { name: "ECDSA", namedCurve: curve };
+      usages = ["verify"];
+    } else {
+      importAlgorithm = { name: "RSA-OAEP", hash };
+      usages = ["encrypt", "wrapKey"];
+    }
+    try {
+      return await subtle.importKey("spki", spkiBytes, importAlgorithm, true, usages);
+    } finally {
+      spkiBytes.fill(0);
+    }
+  }
+  /**
+   * Imports an ECDSA public key from PEM (SPKI) or base64 SPKI string for signature verification.
+   */
+  static async importECDSAPublicKeyFromPEM(pem, curve = "P-256") {
+    return CKeyManager.importPublicKeyFromPEM(pem, "ECDSA", curve);
+  }
+  /**
+   * Imports a private key from a PEM (PKCS#8) or base64 PKCS#8 string.
+   */
+  static async importPrivateKeyFromPEM(pem, algorithm = "RSA-OAEP", curve = "P-256", hash = "SHA-256") {
+    if (/BEGIN\s+(RSA|EC)\s+PRIVATE\s+KEY/i.test(pem)) {
+      throw new Error(
+        `[CKeyManager] Failed to import private key. The provided PEM appears to be in PKCS#1 or SEC1 format. Web Crypto requires PKCS#8 format. Convert your key using: openssl pkcs8 -topk8 -nocrypt -in private.pem -out private_pkcs8.pem.`
+      );
+    }
+    const subtle = getSubtleCrypto();
+    const cleaned = pem.replace(/-----BEGIN[ A-Z0-9_-]+-----/g, "").replace(/-----END[ A-Z0-9_-]+-----/g, "").replace(/\s+/g, "");
+    const pkcs8Bytes = CKeyManager.fromBase64(cleaned);
+    let importAlgorithm;
+    let usages;
+    if (algorithm === "ECDH") {
+      importAlgorithm = { name: "ECDH", namedCurve: curve };
+      usages = ["deriveKey", "deriveBits"];
+    } else if (algorithm === "ECDSA") {
+      importAlgorithm = { name: "ECDSA", namedCurve: curve };
+      usages = ["sign"];
+    } else {
+      importAlgorithm = { name: "RSA-OAEP", hash };
+      usages = ["decrypt", "unwrapKey"];
+    }
+    try {
+      return await subtle.importKey("pkcs8", pkcs8Bytes, importAlgorithm, true, usages);
+    } finally {
+      pkcs8Bytes.fill(0);
+    }
+  }
+  /**
+   * Imports an ECDSA private key from PEM (PKCS#8) or base64 PKCS#8 string for signing.
+   */
+  static async importECDSAPrivateKeyFromPEM(pem, curve = "P-256") {
+    return CKeyManager.importPrivateKeyFromPEM(pem, "ECDSA", curve);
+  }
+  /**
+   * Exports a public CryptoKey to a standard PEM (SPKI) string.
+   */
+  static async exportPublicKeyToPEM(key) {
+    const subtle = getSubtleCrypto();
+    const spki = await subtle.exportKey("spki", key);
+    let b64;
+    try {
+      b64 = CKeyManager.toBase64(spki);
+    } finally {
+      new Uint8Array(spki).fill(0);
+    }
+    const lines = b64.match(/.{1,64}/g) || [b64];
+    return `-----BEGIN PUBLIC KEY-----
+${lines.join("\n")}
+-----END PUBLIC KEY-----`;
+  }
+  /**
+   * Exports a private CryptoKey to a standard PEM (PKCS#8) string.
+   */
+  static async exportPrivateKeyToPEM(key) {
+    const subtle = getSubtleCrypto();
+    const pkcs8 = await subtle.exportKey("pkcs8", key);
+    let b64;
+    try {
+      b64 = CKeyManager.toBase64(pkcs8);
+    } finally {
+      new Uint8Array(pkcs8).fill(0);
+    }
+    const lines = b64.match(/.{1,64}/g) || [b64];
+    return `-----BEGIN PRIVATE KEY-----
+${lines.join("\n")}
+-----END PRIVATE KEY-----`;
+  }
+  // ── Key Wrapping & Unwrapping ────────────────────────────────────────────
+  /**
+   * Wraps a target CryptoKey (e.g. an Account Symmetric Key) using a wrapping key
+   * (AES-KW or RSA-OAEP).
+   */
+  static async wrapKey(keyToWrap, wrappingKey, format = "raw") {
+    const subtle = getSubtleCrypto();
+    let wrapAlgorithm;
+    if (wrappingKey.algorithm.name === "RSA-OAEP") {
+      wrapAlgorithm = { name: "RSA-OAEP" };
+    } else if (wrappingKey.algorithm.name === "AES-KW") {
+      wrapAlgorithm = "AES-KW";
+    } else {
+      wrapAlgorithm = "AES-KW";
+    }
+    const wrappedBuffer = await subtle.wrapKey(format, keyToWrap, wrappingKey, wrapAlgorithm);
+    return CKeyManager.toBase64(wrappedBuffer);
+  }
+  /**
+   * Unwraps a base64-encoded wrapped key using an unwrapping key (AES-KW or RSA-OAEP).
+   */
+  static async unwrapKey(wrappedBase64, unwrappingKey, unwrappedKeyAlgorithm = { name: "AES-GCM", length: 256 }, extractable = true, keyUsages = ["encrypt", "decrypt"], format = "raw") {
+    const subtle = getSubtleCrypto();
+    const wrappedBytes = CKeyManager.fromBase64(wrappedBase64);
+    let unwrapAlgorithm;
+    if (unwrappingKey.algorithm.name === "RSA-OAEP") {
+      unwrapAlgorithm = { name: "RSA-OAEP" };
+    } else {
+      unwrapAlgorithm = "AES-KW";
+    }
+    try {
+      return await subtle.unwrapKey(
+        format,
+        wrappedBytes,
+        unwrappingKey,
+        unwrapAlgorithm,
+        unwrappedKeyAlgorithm,
+        extractable,
+        keyUsages
+      );
+    } finally {
+      wrappedBytes.fill(0);
+    }
+  }
+  /**
+   * Generates a high-entropy symmetric AES-GCM Account Data Encryption Key (ADEK).
+   * Designed for multi-user table and field-level encryption.
+   */
+  static async generateAccountDataKey(length = 256, extractable = false) {
+    const subtle = getSubtleCrypto();
+    return await subtle.generateKey(
+      { name: "AES-GCM", length },
+      extractable,
+      ["encrypt", "decrypt"]
+    );
+  }
+  /**
+   * Wraps an Account Data Encryption Key (ADEK) for a specific user using the user's public key (RSA-OAEP).
+   * Returns a Base64-encoded wrapped key string suitable for storage in role-map / access tables.
+   */
+  static async wrapAccountKeyForUser(adek, userPublicKey) {
+    const subtle = getSubtleCrypto();
+    if (userPublicKey.algorithm.name === "RSA-OAEP") {
+      const rawKey = await subtle.exportKey("raw", adek);
+      try {
+        const wrappedBuffer = await subtle.encrypt(
+          { name: "RSA-OAEP" },
+          userPublicKey,
+          rawKey
+        );
+        return CKeyManager.toBase64(wrappedBuffer);
+      } finally {
+        new Uint8Array(rawKey).fill(0);
       }
-      return this.encryptValue(data, options);
     }
-    if (typeof data === "object" && !ArrayBuffer.isView(data) && !(data instanceof ArrayBuffer)) {
-      if (options?.fields && options.fields.length > 0) {
-        const fieldsToEncrypt = options.fields.filter(
-          (field) => Object.prototype.hasOwnProperty.call(data, field) && data[field] !== void 0 && data[field] !== null && !this.isEncrypted(data[field])
+    throw new Error(
+      `[CKeyManager] Unsupported user key algorithm for wrapAccountKeyForUser: '${userPublicKey.algorithm.name}'. Expected 'RSA-OAEP'.`
+    );
+  }
+  /**
+   * Unwraps a Base64-encoded Account Data Encryption Key (ADEK) using the user's private key (RSA-OAEP).
+   * Returns the restored AES-GCM CryptoKey ready for use in CWebCryptoEncryptionProvider.
+   */
+  static async unwrapAccountKeyForUser(wrappedKeyBase64, userPrivateKey, unwrappedKeyAlgorithm = { name: "AES-GCM", length: 256 }, extractable = false) {
+    const subtle = getSubtleCrypto();
+    if (userPrivateKey.algorithm.name === "RSA-OAEP") {
+      const wrappedBytes = CKeyManager.fromBase64(wrappedKeyBase64);
+      let unwrappedRawKey;
+      try {
+        unwrappedRawKey = await subtle.decrypt(
+          { name: "RSA-OAEP" },
+          userPrivateKey,
+          wrappedBytes
         );
-        if (fieldsToEncrypt.length === 0) {
-          return data;
-        }
-        if (!options?._warmed) {
-          await this.warmupKey(options);
-        }
-        const result = { ...data };
-        const entries = await Promise.all(
-          fieldsToEncrypt.map(async (field) => {
-            const fieldOptions = this._bindFieldAad(data, field, options);
-            return [field, await this.encryptValue(result[field], fieldOptions)];
-          })
+      } finally {
+        wrappedBytes.fill(0);
+      }
+      try {
+        return await subtle.importKey(
+          "raw",
+          unwrappedRawKey,
+          unwrappedKeyAlgorithm,
+          extractable,
+          ["encrypt", "decrypt"]
         );
-        for (const [field, encryptedVal] of entries) {
-          safeSetProperty(result, field, encryptedVal);
-        }
-        return result;
+      } finally {
+        new Uint8Array(unwrappedRawKey).fill(0);
+      }
+    }
+    throw new Error(
+      `[CKeyManager] Unsupported user key algorithm for unwrapAccountKeyForUser: '${userPrivateKey.algorithm.name}'. Expected 'RSA-OAEP'.`
+    );
+  }
+  /**
+   * Wraps an HMAC blind indexing key for a specific recipient user using their RSA-OAEP public key.
+   * Returns a Base64-encoded wrapped key string suitable for storage in role-map / access tables.
+   */
+  static async wrapHMACKeyForUser(hmacKey, userPublicKey) {
+    const subtle = getSubtleCrypto();
+    if (userPublicKey.algorithm.name === "RSA-OAEP") {
+      const rawKey = await subtle.exportKey("raw", hmacKey);
+      try {
+        const wrappedBuffer = await subtle.encrypt(
+          { name: "RSA-OAEP" },
+          userPublicKey,
+          rawKey
+        );
+        return CKeyManager.toBase64(wrappedBuffer);
+      } finally {
+        new Uint8Array(rawKey).fill(0);
+      }
+    }
+    throw new Error(
+      `[CKeyManager] Unsupported user key algorithm for wrapHMACKeyForUser: '${userPublicKey.algorithm.name}'. Expected 'RSA-OAEP'.`
+    );
+  }
+  /**
+   * Unwraps a Base64-encoded HMAC key using a recipient's RSA-OAEP private key.
+   * Restores the CryptoKey configured for HMAC signing and verification in search indexing.
+   */
+  static async unwrapHMACKeyForUser(wrappedKeyBase64, userPrivateKey, hash = "SHA-256", extractable = false) {
+    const subtle = getSubtleCrypto();
+    if (userPrivateKey.algorithm.name === "RSA-OAEP") {
+      const wrappedBytes = CKeyManager.fromBase64(wrappedKeyBase64);
+      let unwrappedRawKey;
+      try {
+        unwrappedRawKey = await subtle.decrypt(
+          { name: "RSA-OAEP" },
+          userPrivateKey,
+          wrappedBytes
+        );
+      } finally {
+        wrappedBytes.fill(0);
+      }
+      try {
+        return await subtle.importKey(
+          "raw",
+          unwrappedRawKey,
+          { name: "HMAC", hash: { name: hash } },
+          extractable,
+          ["sign", "verify"]
+        );
+      } finally {
+        new Uint8Array(unwrappedRawKey).fill(0);
+      }
+    }
+    throw new Error(
+      `[CKeyManager] Unsupported user key algorithm for unwrapHMACKeyForUser: '${userPrivateKey.algorithm.name}'. Expected 'RSA-OAEP'.`
+    );
+  }
+  /**
+   * Atomically re-wraps an Account Data Encryption Key (ADEK) for a new recipient
+   * without exposing the raw extractable symmetric key to caller application code.
+   *
+   * @param wrappedKeyBase64 - The existing ADEK envelope wrapped with current user's public key
+   * @param myPrivateKey - Current user's RSA-OAEP private key
+   * @param recipientPublicKey - New recipient's RSA-OAEP public key
+   * @returns Base64-encoded wrapped key envelope for the recipient
+   */
+  static async rewrapAccountKeyForUser(wrappedKeyBase64, myPrivateKey, recipientPublicKey) {
+    const subtle = getSubtleCrypto();
+    if (!myPrivateKey || !myPrivateKey.algorithm || myPrivateKey.algorithm.name !== "RSA-OAEP" || !recipientPublicKey || !recipientPublicKey.algorithm || recipientPublicKey.algorithm.name !== "RSA-OAEP") {
+      throw new Error(`[CKeyManager] rewrapAccountKeyForUser requires RSA-OAEP keys.`);
+    }
+    if (myPrivateKey.type === "public" || recipientPublicKey.type === "private") {
+      throw new Error(
+        `[CKeyManager] rewrapAccountKeyForUser requires an RSA-OAEP private key for decryption and an RSA-OAEP public key for encryption.`
+      );
+    }
+    const wrappedBytes = CKeyManager.fromBase64(wrappedKeyBase64);
+    let rawKeyBuffer;
+    try {
+      rawKeyBuffer = await subtle.decrypt(
+        { name: "RSA-OAEP" },
+        myPrivateKey,
+        wrappedBytes
+      );
+      const rewrappedBuffer = await subtle.encrypt(
+        { name: "RSA-OAEP" },
+        recipientPublicKey,
+        rawKeyBuffer
+      );
+      return CKeyManager.toBase64(rewrappedBuffer);
+    } finally {
+      wrappedBytes.fill(0);
+      if (rawKeyBuffer) {
+        new Uint8Array(rawKeyBuffer).fill(0);
+      }
+    }
+  }
+  // ── Key Derivation Functions (PBKDF2 & HKDF) ──────────────────────────────
+  /**
+   * Derives a symmetric AES-GCM CryptoKey from a passphrase using PBKDF2 or HKDF.
+   * Returns the derived CryptoKey and the base64-encoded salt.
+   */
+  static async deriveKey(passphrase, options) {
+    if (!passphrase || typeof passphrase === "string" && passphrase.trim().length === 0 || typeof passphrase === "object" && "byteLength" in passphrase && passphrase.byteLength === 0) {
+      throw new Error("[CKeyManager] Passphrase cannot be empty or undefined for key derivation.");
+    }
+    const subtle = getSubtleCrypto();
+    const saltBytes = CKeyManager.resolveSalt(options.salt);
+    const keyLength = options.keyLength || 256;
+    const hash = options.hash || "SHA-256";
+    const extractable = options.extractable === true;
+    const rawKeyBytes = typeof passphrase === "string" ? textEncoder$1.encode(passphrase) : passphrase instanceof Uint8Array ? passphrase : new Uint8Array(passphrase);
+    try {
+      if (options.kdf === "pbkdf2") {
+        const baseKey = await subtle.importKey(
+          "raw",
+          rawKeyBytes,
+          "PBKDF2",
+          false,
+          ["deriveKey"]
+        );
+        const derivedKey = await subtle.deriveKey(
+          {
+            name: "PBKDF2",
+            salt: saltBytes,
+            iterations: options.iterations || 31e4,
+            hash
+          },
+          baseKey,
+          { name: "AES-GCM", length: keyLength },
+          extractable,
+          ["encrypt", "decrypt"]
+        );
+        return {
+          key: derivedKey,
+          salt: CKeyManager.toBase64(saltBytes)
+        };
+      }
+      if (options.kdf === "hkdf") {
+        const baseKey = await subtle.importKey(
+          "raw",
+          rawKeyBytes,
+          "HKDF",
+          false,
+          ["deriveKey"]
+        );
+        const infoBytes = resolveInfoBytes(options.info, "katlux-derived-aes-key");
+        const derivedKey = await subtle.deriveKey(
+          {
+            name: "HKDF",
+            salt: saltBytes,
+            info: infoBytes,
+            hash
+          },
+          baseKey,
+          { name: "AES-GCM", length: keyLength },
+          extractable,
+          ["encrypt", "decrypt"]
+        );
+        return {
+          key: derivedKey,
+          salt: CKeyManager.toBase64(saltBytes)
+        };
+      }
+      throw new Error(`[CKeyManager] Unsupported KDF strategy: ${options.kdf}`);
+    } finally {
+      if (typeof passphrase === "string") {
+        rawKeyBytes.fill(0);
+      }
+    }
+  }
+  /**
+   * Derives an AES-GCM CryptoKey from a high-entropy secret (e.g. an ECDH shared secret key)
+   * using HKDF.
+   */
+  static async deriveKeyFromSecret(secretKey, options = {}) {
+    const subtle = getSubtleCrypto();
+    let saltBytes;
+    if (options.salt !== void 0) {
+      saltBytes = CKeyManager.resolveSalt(options.salt);
+    } else {
+      saltBytes = new Uint8Array(16);
+    }
+    const infoBytes = resolveInfoBytes(options.info, "katlux-ecdh-aes-gcm");
+    const hash = options.hash || "SHA-256";
+    const keyLength = options.keyLength || 256;
+    const extractable = options.extractable === true;
+    return await subtle.deriveKey(
+      {
+        name: "HKDF",
+        salt: saltBytes,
+        info: infoBytes,
+        hash
+      },
+      secretKey,
+      { name: "AES-GCM", length: keyLength },
+      extractable,
+      ["encrypt", "decrypt"]
+    );
+  }
+  /**
+   * Derives two domain-separated, cryptographically isolated keys from a user password and salt:
+   * 1. `authKey`: For client authentication, SRP, or server challenge proofs.
+   * 2. `encryptionKey`: For AES-GCM local and field-level data encryption.
+   *
+   * Stage 1 (Password Stretching): PBKDF2-HMAC-SHA256 stretches low-entropy password into master secret.
+   * Stage 2 (Domain Expansion): HKDF-Expand derives subkeys using domain-separated context info tags.
+   * Immediate memory zeroization of intermediate master secret buffer is guaranteed.
+   *
+   * @param password - Master user password or passphrase
+   * @param salt - Salt (or omitted to generate a secure random 16-byte salt)
+   * @param options - PBKDF2 and HKDF configuration options
+   */
+  static async deriveAuthAndEncryptionKeys(password, salt, options = {}) {
+    if (!password || typeof password === "string" && password.trim().length === 0 || typeof password === "object" && "byteLength" in password && password.byteLength === 0) {
+      throw new Error("[CKeyManager] Password cannot be empty or undefined for key derivation.");
+    }
+    const subtle = getSubtleCrypto();
+    let saltBytes;
+    if (salt !== void 0) {
+      saltBytes = CKeyManager.resolveSalt(salt);
+    } else {
+      saltBytes = CKeyManager.randomBytes(16);
+    }
+    const saltBase64 = CKeyManager.toBase64(saltBytes);
+    const iterations = options.iterations || 31e4;
+    const hash = options.hash || "SHA-256";
+    const authKeyLength = options.authKeyLength || 256;
+    const encryptionKeyLength = options.encryptionKeyLength || 256;
+    const authAlgorithm = options.authAlgorithm || "HMAC";
+    const authInfo = resolveInfoBytes(options.authInfo, "katlux-auth-key-v1");
+    const encryptionInfo = resolveInfoBytes(options.encryptionInfo, "katlux-encryption-key-v1");
+    const extractable = options.extractable === true;
+    const rawPasswordBytes = typeof password === "string" ? textEncoder$1.encode(password) : password instanceof Uint8Array ? new Uint8Array(password.buffer, password.byteOffset, password.byteLength) : new Uint8Array(password);
+    let masterBits;
+    try {
+      const baseKey = await subtle.importKey(
+        "raw",
+        rawPasswordBytes,
+        "PBKDF2",
+        false,
+        ["deriveBits"]
+      );
+      const bitsLength = hash === "SHA-512" ? 512 : 256;
+      masterBits = await subtle.deriveBits(
+        {
+          name: "PBKDF2",
+          salt: saltBytes,
+          iterations,
+          hash
+        },
+        baseKey,
+        bitsLength
+      );
+      const hkdfKey = await subtle.importKey(
+        "raw",
+        masterBits,
+        "HKDF",
+        false,
+        ["deriveKey"]
+      );
+      const authDerivedAlgorithm = authAlgorithm === "AES-GCM" ? { name: "AES-GCM", length: authKeyLength } : { name: "HMAC", hash: { name: hash }, length: authKeyLength };
+      const authUsages = authAlgorithm === "AES-GCM" ? ["encrypt", "decrypt"] : ["sign", "verify"];
+      const authKey = await subtle.deriveKey(
+        {
+          name: "HKDF",
+          hash,
+          salt: new Uint8Array(0),
+          info: authInfo
+        },
+        hkdfKey,
+        authDerivedAlgorithm,
+        extractable,
+        authUsages
+      );
+      const encryptionKey = await subtle.deriveKey(
+        {
+          name: "HKDF",
+          hash,
+          salt: new Uint8Array(0),
+          info: encryptionInfo
+        },
+        hkdfKey,
+        { name: "AES-GCM", length: encryptionKeyLength },
+        extractable,
+        ["encrypt", "decrypt"]
+      );
+      return {
+        authKey,
+        encryptionKey,
+        salt: saltBase64
+      };
+    } finally {
+      if (typeof password === "string") {
+        rawPasswordBytes.fill(0);
       }
-      if (options?.valueEncryption === true) {
-        const result = { ...data };
-        const keysToEncrypt = Object.keys(result).filter(
-          (key) => result[key] !== void 0 && result[key] !== null && !this.isEncrypted(result[key])
-        );
-        if (keysToEncrypt.length === 0) {
-          return result;
-        }
-        if (!options?._warmed) {
-          await this.warmupKey(options);
-        }
-        const entries = await Promise.all(
-          keysToEncrypt.map(async (key) => {
-            const fieldOptions = this._bindFieldAad(data, key, options);
-            return [key, await this.encryptValue(result[key], fieldOptions)];
-          })
-        );
-        for (const [key, encryptedVal] of entries) {
-          safeSetProperty(result, key, encryptedVal);
-        }
-        return result;
+      if (masterBits) {
+        new Uint8Array(masterBits).fill(0);
       }
     }
-    return this.encryptValue(data, options);
   }
+  // ── Digital Signatures, Fingerprints & Access Grants ─────────────────────
   /**
-   * Top-level polymorphic decryption method.
-   * Automatically performs value-level decryption:
-   * - If payload is an encrypted envelope: decrypts directly via decryptValue.
-   * - If payload is an array of objects: decrypts each row.
-   * - If payload is an object: decrypts any encrypted value cells across fields.
+   * Generates an ECDSA P-256 signing key pair.
    */
+  static async generateSigningKeyPair(curve = "P-256", extractable = true) {
+    const subtle = getSubtleCrypto();
+    const pair = await subtle.generateKey(
+      {
+        name: "ECDSA",
+        namedCurve: curve
+      },
+      extractable,
+      ["sign", "verify"]
+    );
+    return {
+      publicKey: pair.publicKey,
+      privateKey: pair.privateKey
+    };
+  }
   /**
-   * Top-level polymorphic decryption method.
-   * Automatically performs value-level decryption:
-   * - If payload is an encrypted envelope: decrypts directly via decryptValue.
-   * - If payload is an array of objects: decrypts each row (batched with local memoization).
-   * - If payload is an object: decrypts any encrypted value cells across fields.
+   * Generates an ECDSA signing key pair. Alias for generateSigningKeyPair.
    */
-  async decrypt(payload, options) {
-    if (payload === void 0 || payload === null) return payload;
-    if (this.isEncrypted(payload)) {
-      return this.decryptValue(payload, options);
-    }
-    if (Array.isArray(payload)) {
-      if (payload.length === 0) return payload;
-      const localMemo = /* @__PURE__ */ new Map();
-      const decryptRow = async (item) => {
-        if (!item) return item;
-        if (this.isEncrypted(item)) {
-          const ct = item.ciphertext;
-          const iv = item.iv || "";
-          const aadPart = options?.aad ? typeof options.aad === "string" ? options.aad : "" : "";
-          const memoKey = `${ct}:${iv}:${aadPart}`;
-          if (!localMemo.has(memoKey)) {
-            localMemo.set(memoKey, this.decryptValue(item, options));
-          }
-          return localMemo.get(memoKey);
-        }
-        if (typeof item === "object" && !ArrayBuffer.isView(item) && !(item instanceof ArrayBuffer)) {
-          const targetKeys = options?.fields && options.fields.length > 0 ? options.fields.filter((f) => Object.prototype.hasOwnProperty.call(item, f)) : Object.keys(item);
-          const keysToDecrypt = targetKeys.filter((key) => this.isEncrypted(item[key]));
-          if (keysToDecrypt.length === 0) {
-            return item;
-          }
-          const proto = Object.getPrototypeOf(item);
-          const result = proto && proto !== Object.prototype ? Object.assign(Object.create(proto), item) : { ...item };
-          await Promise.all(
-            keysToDecrypt.map(async (key) => {
-              const env = item[key];
-              const boundOptions = this._bindFieldAad(item, key, options);
-              const hasBoundAad = boundOptions.aad !== options?.aad;
-              const ct = env.ciphertext;
-              const iv = env.iv || "";
-              const aadPart = boundOptions.aad ? typeof boundOptions.aad === "string" ? boundOptions.aad : "" : "";
-              const memoKey = `${ct}:${iv}:${aadPart}`;
-              if (!localMemo.has(memoKey)) {
-                const decryptPromise = this.decryptValue(env, boundOptions).catch((err) => {
-                  if (hasBoundAad && isAuthOrDecryptionError(err)) {
-                    return this.decryptValue(env, options);
-                  }
-                  throw err;
-                });
-                localMemo.set(memoKey, decryptPromise);
-              }
-              const decryptedVal = await localMemo.get(memoKey);
-              safeSetProperty(result, key, decryptedVal);
-            })
-          );
-          return result;
-        }
-        return item;
-      };
-      if (payload.length <= 100) {
-        return Promise.all(payload.map(decryptRow));
-      }
-      const batchSize = 1e3;
-      const results = new Array(payload.length);
-      for (let i = 0; i < payload.length; i += batchSize) {
-        const end = Math.min(i + batchSize, payload.length);
-        const chunk = payload.slice(i, end);
-        const chunkRes = await Promise.all(chunk.map(decryptRow));
-        for (let j = 0; j < chunkRes.length; j++) {
-          results[i + j] = chunkRes[j];
-        }
-        if (end < payload.length && (i > 0 && i % 5e3 === 0)) {
-          await new Promise((r) => setTimeout(r, 0));
+  static async generateECDSAKeyPair(curve = "P-256", extractable = true) {
+    return CKeyManager.generateSigningKeyPair(curve, extractable);
+  }
+  /**
+   * Generates a deterministic SHA-256 fingerprint for a public key (SPKI or raw).
+   * Formatted as `SHA256:<base64url>`.
+   */
+  static async getKeyFingerprint(publicKey) {
+    const subtle = getSubtleCrypto();
+    let rawBytes;
+    if (typeof publicKey === "object" && publicKey !== null && "algorithm" in publicKey) {
+      const cryptoKey = publicKey;
+      rawBytes = await subtle.exportKey("spki", cryptoKey);
+    } else if (publicKey instanceof Uint8Array) {
+      rawBytes = publicKey;
+    } else if (publicKey instanceof ArrayBuffer) {
+      rawBytes = publicKey;
+    } else if (typeof publicKey === "string") {
+      const trimmed = publicKey.trim();
+      if (trimmed.startsWith("-----BEGIN")) {
+        const b642 = trimmed.replace(/-----[^-]+-----/g, "").replace(/\s+/g, "");
+        rawBytes = CKeyManager.fromBase64(b642);
+      } else {
+        try {
+          rawBytes = CKeyManager.fromBase64(trimmed);
+        } catch {
+          rawBytes = textEncoder$1.encode(trimmed);
         }
       }
-      return results;
-    }
-    if (typeof payload === "object" && !ArrayBuffer.isView(payload) && !(payload instanceof ArrayBuffer)) {
-      const targetKeys = options?.fields && options.fields.length > 0 ? options.fields.filter((f) => Object.prototype.hasOwnProperty.call(payload, f)) : Object.keys(payload);
-      const keysToDecrypt = targetKeys.filter((key) => this.isEncrypted(payload[key]));
-      if (keysToDecrypt.length === 0) {
-        return payload;
-      }
-      const proto = Object.getPrototypeOf(payload);
-      const result = proto && proto !== Object.prototype ? Object.assign(Object.create(proto), payload) : { ...payload };
-      const entries = await Promise.all(
-        keysToDecrypt.map(async (key) => {
-          const boundOptions = this._bindFieldAad(payload, key, options);
-          const hasBoundAad = boundOptions.aad !== options?.aad;
-          try {
-            return [key, await this.decryptValue(result[key], boundOptions)];
-          } catch (err) {
-            if (hasBoundAad && isAuthOrDecryptionError(err)) {
-              try {
-                return [key, await this.decryptValue(result[key], options)];
-              } catch (fallbackErr) {
-                throw fallbackErr;
-              }
-            }
-            throw err;
-          }
-        })
+    } else {
+      throw new Error(
+        "[CKeyManager] Invalid key input for getKeyFingerprint: expected CryptoKey, Uint8Array, ArrayBuffer, or string."
       );
-      for (const [key, decryptedVal] of entries) {
-        safeSetProperty(result, key, decryptedVal);
-      }
-      return result;
     }
-    return payload;
+    const hashBuffer = await subtle.digest("SHA-256", rawBytes);
+    const b64 = CKeyManager.toBase64(hashBuffer);
+    const b64url = b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    return `SHA256:${b64url}`;
   }
-}
-
-class CKeyManager {
-  // ── Binary & Encoding Utilities ──────────────────────────────────────────
   /**
-   * Generates a cryptographically secure random byte buffer of the specified length.
+   * Signs arbitrary data or JSON objects using an ECDSA P-256 private key.
+   * Objects are automatically serialized via canonicalizeJson() before hashing.
    */
-  static randomBytes(length) {
-    const bytes = new Uint8Array(length);
-    return getRandomValues(bytes);
+  static async sign(data, privateKey) {
+    const subtle = getSubtleCrypto();
+    if (!privateKey || !privateKey.algorithm || privateKey.algorithm.name !== "ECDSA") {
+      throw new Error("[CKeyManager] sign requires an ECDSA private key.");
+    }
+    let dataBytes;
+    if (data instanceof Uint8Array) {
+      dataBytes = data;
+    } else if (ArrayBuffer.isView(data)) {
+      dataBytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    } else if (data instanceof ArrayBuffer) {
+      dataBytes = new Uint8Array(data);
+    } else if (typeof data === "string") {
+      dataBytes = textEncoder$1.encode(data);
+    } else {
+      const canonical = canonicalizeJson(data);
+      dataBytes = textEncoder$1.encode(canonical);
+    }
+    const namedCurve = privateKey.algorithm.namedCurve || "P-256";
+    const hashName = namedCurve === "P-384" ? "SHA-384" : namedCurve === "P-521" ? "SHA-512" : "SHA-256";
+    const signatureBuffer = await subtle.sign(
+      {
+        name: "ECDSA",
+        hash: { name: hashName }
+      },
+      privateKey,
+      dataBytes
+    );
+    return CKeyManager.toBase64(signatureBuffer);
   }
   /**
-   * Converts an ArrayBuffer or Uint8Array into a Base64-encoded string.
+   * Verifies an ECDSA P-256 signature against original data or JSON object.
    */
-  static toBase64(buffer) {
-    return toBase64(buffer);
+  static async verify(data, signature, publicKey) {
+    const subtle = getSubtleCrypto();
+    if (!publicKey || !publicKey.algorithm || publicKey.algorithm.name !== "ECDSA") {
+      throw new Error("[CKeyManager] verify requires an ECDSA public key.");
+    }
+    if (typeof signature !== "string" || !signature.trim()) {
+      return false;
+    }
+    try {
+      const signatureBytes = CKeyManager.fromBase64(signature);
+      let dataBytes;
+      if (data instanceof Uint8Array) {
+        dataBytes = data;
+      } else if (ArrayBuffer.isView(data)) {
+        dataBytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      } else if (data instanceof ArrayBuffer) {
+        dataBytes = new Uint8Array(data);
+      } else if (typeof data === "string") {
+        dataBytes = textEncoder$1.encode(data);
+      } else {
+        const canonical = canonicalizeJson(data);
+        dataBytes = textEncoder$1.encode(canonical);
+      }
+      const namedCurve = publicKey.algorithm.namedCurve || "P-256";
+      const hashName = namedCurve === "P-384" ? "SHA-384" : namedCurve === "P-521" ? "SHA-512" : "SHA-256";
+      return await subtle.verify(
+        {
+          name: "ECDSA",
+          hash: { name: hashName }
+        },
+        publicKey,
+        signatureBytes,
+        dataBytes
+      );
+    } catch {
+      return false;
+    }
   }
   /**
-   * Converts a Base64 or Base64URL-encoded string back into a Uint8Array.
-   * Normalizes URL-safe characters and padding, strictly validating against the Base64 alphabet.
+   * Computes a deterministic HMAC-SHA256 blind index hash for an arbitrary term using the supplied CryptoKey.
+   * Performs Unicode NFKC normalization, trimming, and lowercasing before computing the signature.
+   *
+   * @param value - The input string, number, or object to compute the blind index for.
+   * @param hmacKey - CryptoKey configured for HMAC signing.
+   * @returns Lowercase hexadecimal HMAC-SHA256 blind index hash.
    */
-  static fromBase64(base64) {
-    if (typeof base64 !== "string") {
-      throw new Error("[CKeyManager] Invalid base64 input: expected string");
-    }
-    const cleaned = base64.replace(/\s+/g, "");
-    if (!cleaned) return new Uint8Array(0);
-    const normalized = cleaned.replace(/-/g, "+").replace(/_/g, "/");
-    const padded = normalized.padEnd(normalized.length + (4 - normalized.length % 4) % 4, "=");
-    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(padded)) {
-      throw new Error("[CKeyManager] Invalid base64 string");
+  static async computeBlindIndex(value, hmacKey) {
+    if (value === null || value === void 0) return "";
+    const normalized = String(value).normalize("NFKC").trim().toLowerCase();
+    if (!normalized) return "";
+    if (!hmacKey || !hmacKey.algorithm || hmacKey.algorithm.name !== "HMAC") {
+      throw new Error("[CKeyManager] computeBlindIndex requires an HMAC CryptoKey.");
     }
-    if (typeof Buffer !== "undefined") {
-      const buf = Buffer.from(padded, "base64");
-      const arrayBuf = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-      return new Uint8Array(arrayBuf);
+    const subtle = getSubtleCrypto();
+    const signature = await subtle.sign("HMAC", hmacKey, textEncoder$1.encode(normalized));
+    return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Signs a structured access grant, embedding signature and granter key fingerprint.
+   */
+  static async signGrant(grant, granterPrivateKey, granterPublicKey) {
+    if (!grant || typeof grant !== "object") {
+      throw new Error("[CKeyManager] signGrant requires a valid grant object.");
     }
-    const binary = atob(padded);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
+    let fingerprint;
+    if (granterPublicKey) {
+      fingerprint = await CKeyManager.getKeyFingerprint(granterPublicKey);
+    } else {
+      const subtle = getSubtleCrypto();
+      try {
+        const jwk = await subtle.exportKey("jwk", granterPrivateKey);
+        const pubJwk = {
+          kty: jwk.kty,
+          crv: jwk.crv,
+          x: jwk.x,
+          y: jwk.y,
+          ext: true,
+          key_ops: ["verify"]
+        };
+        const pubKey = await subtle.importKey(
+          "jwk",
+          pubJwk,
+          { name: "ECDSA", namedCurve: jwk.crv || "P-256" },
+          true,
+          ["verify"]
+        );
+        fingerprint = await CKeyManager.getKeyFingerprint(pubKey);
+      } catch {
+        throw new Error(
+          "[CKeyManager] signGrant requires granterPublicKey when granterPrivateKey is non-extractable."
+        );
+      }
     }
-    return bytes;
+    const signature = await CKeyManager.sign(grant, granterPrivateKey);
+    return {
+      grant: { ...grant },
+      signature,
+      fingerprint
+    };
   }
   /**
-   * Deterministically resolves a salt from Uint8Array, ArrayBuffer, Base64/Base64URL string, or raw text string.
-   * Guarantees 100% identical salt byte resolution between Node.js and Browser environments.
+   * Verifies the authenticity and integrity of a signed access grant against granter public key.
    */
-  static resolveSalt(salt) {
-    if (!salt) return CKeyManager.randomBytes(16);
-    if (ArrayBuffer.isView(salt)) {
-      return salt.byteLength > 0 ? new Uint8Array(salt.buffer.slice(salt.byteOffset, salt.byteOffset + salt.byteLength)) : CKeyManager.randomBytes(16);
+  static async verifyGrant(signedGrant, granterPublicKey, options) {
+    if (!signedGrant || !signedGrant.grant || !signedGrant.signature || !signedGrant.fingerprint || !granterPublicKey) {
+      return false;
     }
-    if (salt instanceof ArrayBuffer) {
-      return salt.byteLength > 0 ? new Uint8Array(salt.slice(0)) : CKeyManager.randomBytes(16);
+    const expectedFingerprint = await CKeyManager.getKeyFingerprint(granterPublicKey);
+    if (signedGrant.fingerprint !== expectedFingerprint) {
+      return false;
     }
-    if (typeof salt === "string") {
-      const trimmed = salt.trim();
-      if (!trimmed) return CKeyManager.randomBytes(16);
-      if (trimmed.startsWith("base64:")) {
-        return CKeyManager.fromBase64(trimmed.slice(7));
-      }
-      if (trimmed.endsWith("=") && /^[A-Za-z0-9+/]+={1,2}$/.test(trimmed)) {
-        try {
-          const decoded = CKeyManager.fromBase64(trimmed);
-          if (decoded.byteLength > 0) return decoded;
-        } catch {
-        }
+    if (options?.checkExpiry && signedGrant.grant.expiresAt !== void 0) {
+      const now = options.now ?? Date.now();
+      if (now > signedGrant.grant.expiresAt) {
+        return false;
       }
-      const encoded = textEncoder$1.encode(trimmed);
-      return encoded.byteLength > 0 ? encoded : CKeyManager.randomBytes(16);
     }
-    return CKeyManager.randomBytes(16);
+    return await CKeyManager.verify(signedGrant.grant, signedGrant.signature, granterPublicKey);
+  }
+}
+
+class AEncryptionProvider {
+  defaultKey;
+  _hmacKey;
+  keys;
+  activeKid;
+  allowedKids;
+  constructor(key, options) {
+    if (key !== void 0) {
+      this.defaultKey = key;
+    }
+    if (options?.keys) {
+      this.keys = options.keys;
+    }
+    if (options?.activeKid) {
+      this.activeKid = options.activeKid;
+    }
+    if (options?.allowedKids) {
+      this.allowedKids = options.allowedKids;
+    }
+    if (options?.hmacKey) {
+      this._hmacKey = options.hmacKey;
+    }
+  }
+  /**
+   * Sets or updates the default secret key, CryptoKey, or async key provider function.
+   */
+  setDefaultKey(key) {
+    this.defaultKey = key || void 0;
+  }
+  /**
+   * Retrieves the currently configured default key or key provider callback.
+   */
+  getDefaultKey() {
+    return this.defaultKey;
+  }
+  /**
+   * Configures a keyring dictionary of keys with an optional active key identifier.
+   */
+  setKeyring(keys, activeKid) {
+    this.keys = keys;
+    if (activeKid !== void 0) {
+      this.activeKid = activeKid;
+    }
+  }
+  /**
+   * Retrieves the currently configured keyring dictionary.
+   */
+  getKeyring() {
+    return this.keys;
+  }
+  /**
+   * Sets the active Key Identifier (kid) to use for outbound encryption.
+   */
+  setActiveKid(kid) {
+    this.activeKid = kid;
+  }
+  /**
+   * Retrieves the active Key Identifier (kid).
+   */
+  getActiveKid() {
+    return this.activeKid;
+  }
+  /**
+   * Sets or updates the dedicated HMAC key or key provider callback for blind indexing.
+   */
+  setHmacKey(key) {
+    this._hmacKey = key || void 0;
+  }
+  /**
+   * Retrieves the currently configured HMAC key or key provider callback.
+   */
+  getHmacKey() {
+    return this._hmacKey;
   }
-  // ── Symmetric Key Management ─────────────────────────────────────────────
   /**
-   * Generates a random AES CryptoKey suitable for AES-GCM or AES-CBC.
-   *
-   * E2EE Threat Model Note: Focuses on protecting GDPR/tenant data against database and
-   * server-side leaks. Keys remain extractable by default to enable role-based key sharing,
-   * wrapping, and transfer between authorized client sessions in multi-user SaaS apps.
-   * Client-side malware/trojan protection is out of scope.
+   * Computes a deterministic HMAC-SHA256 blind index hash for an arbitrary term.
+   * If no hmacKey is explicitly provided, uses the provider's configured hmacKey or default key.
    */
-  static async generateAESKey(length = 256, algorithm = "AES-GCM", extractable = true) {
+  async computeBlindIndex(value, hmacKey) {
+    if (value === null || value === void 0) return "";
+    const keyMaterial = hmacKey || this._hmacKey || this.defaultKey;
+    if (!keyMaterial) {
+      throw new Error("[AEncryptionProvider] computeBlindIndex requires an HMAC key. Configure hmacKey or pass a key directly.");
+    }
+    const resolvedKey = typeof keyMaterial === "function" ? await keyMaterial() : keyMaterial;
+    if (resolvedKey && typeof resolvedKey !== "string" && resolvedKey.algorithm) {
+      return CKeyManager.computeBlindIndex(value, resolvedKey);
+    }
     const subtle = getSubtleCrypto();
-    const usages = algorithm === "AES-KW" ? ["wrapKey", "unwrapKey"] : ["encrypt", "decrypt"];
-    return await subtle.generateKey(
-      { name: algorithm, length },
-      extractable,
-      usages
+    const keyBytes = typeof resolvedKey === "string" ? new TextEncoder().encode(resolvedKey) : resolvedKey instanceof Uint8Array ? resolvedKey : new Uint8Array(resolvedKey);
+    const importedHmacKey = await subtle.importKey(
+      "raw",
+      keyBytes,
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
     );
+    return CKeyManager.computeBlindIndex(value, importedHmacKey);
   }
   /**
-   * Exports an AES CryptoKey as a raw base64 string.
+   * Pre-derives and caches the native CryptoKey for subsequent cryptographic operations.
+   * Subclasses should override this with a dedicated, non-side-effecting implementation.
    */
-  static async exportAESKey(key) {
-    const subtle = getSubtleCrypto();
-    const raw = await subtle.exportKey("raw", key);
-    try {
-      return CKeyManager.toBase64(raw);
-    } finally {
-      new Uint8Array(raw).fill(0);
-    }
+  async warmupKey(_options) {
   }
   /**
-   * Imports an AES CryptoKey from a raw base64 string.
+   * Resolves raw key from keyProvider callback or defaultKey.
    */
-  static async importAESKey(base64, algorithm = "AES-GCM", extractable = false) {
-    const subtle = getSubtleCrypto();
-    const rawBytes = CKeyManager.fromBase64(base64);
-    if (rawBytes.length !== 16 && rawBytes.length !== 24 && rawBytes.length !== 32) {
-      rawBytes.fill(0);
-      throw new Error(`[CKeyManager] Invalid AES key length: expected 16, 24, or 32 bytes (128, 192, or 256 bits), got ${rawBytes.length} bytes.`);
+  async resolveRawKey(keyProvider) {
+    const target = keyProvider || (this.keys && this.activeKid ? this.keys[this.activeKid] : void 0) || this.defaultKey;
+    if (!target) {
+      throw new Error(
+        `[${this.constructor.name}] No encryption key or keyProvider was supplied. Key cannot be empty or undefined. A valid key must be supplied from your authentication or secret management system.`
+      );
     }
-    const usages = algorithm === "AES-KW" ? ["wrapKey", "unwrapKey"] : ["encrypt", "decrypt"];
-    try {
-      return await subtle.importKey(
-        "raw",
-        rawBytes,
-        { name: algorithm },
-        extractable,
-        usages
+    const rawKey = typeof target === "function" ? await target() : target;
+    if (!rawKey || typeof rawKey === "string" && rawKey.trim().length === 0 || typeof rawKey === "object" && "byteLength" in rawKey && rawKey.byteLength === 0) {
+      throw new Error(
+        `[${this.constructor.name}] No encryption key or keyProvider was supplied. Key provider resolved to empty or undefined key.`
       );
-    } finally {
-      rawBytes.fill(0);
     }
+    return rawKey;
   }
-  // ── Asymmetric Key Pair Management ───────────────────────────────────────
   /**
-   * Generates an RSA-OAEP public/private key pair (2048 or 4096 bits).
+   * Checks whether the given payload is an encrypted envelope.
    */
-  static async generateRSAKeyPair(bits = 4096, hash = "SHA-256", extractable = true) {
-    const subtle = getSubtleCrypto();
-    const pair = await subtle.generateKey(
-      {
-        name: "RSA-OAEP",
-        modulusLength: bits,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash
-      },
-      extractable,
-      ["encrypt", "decrypt", "wrapKey", "unwrapKey"]
-    );
-    return {
-      publicKey: pair.publicKey,
-      privateKey: pair.privateKey
-    };
+  static isEncrypted(payload) {
+    if (!payload || typeof payload !== "object") return false;
+    return payload.__encrypted === true && typeof payload.ciphertext === "string" && typeof payload.iv === "string";
   }
   /**
-   * Generates an ECDH public/private key pair for elliptic curve Diffie-Hellman.
+   * Checks whether the given payload is an encrypted envelope.
    */
-  static async generateECDHKeyPair(curve = "P-256", extractable = true) {
-    const subtle = getSubtleCrypto();
-    const pair = await subtle.generateKey(
-      {
-        name: "ECDH",
-        namedCurve: curve
-      },
-      extractable,
-      ["deriveKey", "deriveBits"]
-    );
-    return {
-      publicKey: pair.publicKey,
-      privateKey: pair.privateKey
-    };
+  isEncrypted(payload) {
+    return AEncryptionProvider.isEncrypted(payload);
   }
   /**
-   * Exports a public CryptoKey to a portable JsonWebKey (JWK).
+   * Clears configured keys and cached cryptographic material from memory.
    */
-  static async exportPublicKey(key) {
-    const subtle = getSubtleCrypto();
-    return await subtle.exportKey("jwk", key);
+  clearKeys() {
+    this.defaultKey = void 0;
+    this.keys = void 0;
+    this.activeKid = void 0;
+    this.allowedKids = void 0;
   }
   /**
-   * Exports a private CryptoKey to a portable JsonWebKey (JWK).
+   * Alias for clearKeys() to conform with standard disposal patterns.
    */
-  static async exportPrivateKey(key) {
-    const subtle = getSubtleCrypto();
-    return await subtle.exportKey("jwk", key);
+  dispose() {
+    this.clearKeys();
   }
   /**
-   * Imports a public key from a JsonWebKey (JWK).
+   * ECMAScript Explicit Resource Management protocol (using / await using declarations).
    */
-  static async importPublicKey(jwk, algorithm) {
-    const subtle = getSubtleCrypto();
-    let importAlgorithm = algorithm;
-    let usages;
-    const isEC = jwk.kty === "EC" || typeof algorithm === "object" && algorithm?.name === "ECDH" || algorithm === "ECDH";
-    if (isEC) {
-      usages = [];
-      if (!importAlgorithm || importAlgorithm === "ECDH") {
-        importAlgorithm = { name: "ECDH", namedCurve: jwk.crv || "P-256" };
-      }
-    } else {
-      usages = ["encrypt", "wrapKey"];
-      if (!importAlgorithm || importAlgorithm === "RSA-OAEP") {
-        if (jwk.kty === "RSA") {
-          const hash = jwk.alg === "RSA-OAEP-512" ? "SHA-512" : "SHA-256";
-          importAlgorithm = { name: "RSA-OAEP", hash };
-        } else {
-          throw new Error(`[CKeyManager] Unsupported JWK kty: ${jwk.kty}`);
-        }
-      }
-    }
-    return await subtle.importKey("jwk", jwk, importAlgorithm, true, usages);
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  async [Symbol.asyncDispose]() {
+    this.dispose();
   }
   /**
-   * Imports a private key from a JsonWebKey (JWK).
+   * Resolves effective Authenticated Additional Data (AAD) for the operation:
+   * 1. If options.bindRequestContextAad is explicitly false, returns options.aad directly without context binding.
+   * 2. When encrypting (isDecrypt=false): binds request context `req:${method}:${url}` only if options.bindRequestContextAad === true.
+   * 3. When decrypting (isDecrypt=true): derives request context `req:${method}:${url}` if url or method is provided.
+   * 4. If explicit options.aad is provided: combines with request context if bound, or returns options.aad directly.
+   * 5. Otherwise returns undefined.
    */
-  static async importPrivateKey(jwk, algorithm) {
-    const subtle = getSubtleCrypto();
-    let importAlgorithm = algorithm;
-    let usages;
-    const isEC = jwk.kty === "EC" || typeof algorithm === "object" && algorithm?.name === "ECDH" || algorithm === "ECDH";
-    if (isEC) {
-      usages = ["deriveKey", "deriveBits"];
-      if (!importAlgorithm || importAlgorithm === "ECDH") {
-        importAlgorithm = { name: "ECDH", namedCurve: jwk.crv || "P-256" };
-      }
-    } else {
-      usages = ["decrypt", "unwrapKey"];
-      if (!importAlgorithm || importAlgorithm === "RSA-OAEP") {
-        if (jwk.kty === "RSA") {
-          const hash = jwk.alg === "RSA-OAEP-512" ? "SHA-512" : "SHA-256";
-          importAlgorithm = { name: "RSA-OAEP", hash };
-        } else {
-          throw new Error(`[CKeyManager] Unsupported JWK kty: ${jwk.kty}`);
+  _resolveEffectiveAad(options, isDecrypt = false) {
+    if (!options) return void 0;
+    let rawAad = options.aad;
+    if (typeof rawAad === "function") {
+      rawAad = rawAad(void 0, "");
+    }
+    if (rawAad === void 0 && options.baseAad) {
+      rawAad = options.baseAad;
+    }
+    if (options.bindRequestContextAad === false) return rawAad;
+    const hasReqContext = Boolean(options.url || options.method);
+    if (rawAad) {
+      if (options.bindRequestContextAad === true && hasReqContext) {
+        const m = (options.method || "POST").toUpperCase();
+        const u = options.url || "";
+        const baseAad = typeof rawAad === "string" ? rawAad : rawAad instanceof Uint8Array || rawAad instanceof ArrayBuffer ? textDecoder.decode(rawAad) : String(rawAad);
+        if (baseAad.includes(`|req:${m}:${u}`)) {
+          return baseAad;
         }
+        return `${baseAad}|req:${m}:${u}`;
       }
+      return rawAad;
     }
-    return await subtle.importKey("jwk", jwk, importAlgorithm, true, usages);
-  }
-  /**
-   * Imports a public key from a PEM (SPKI) or base64 SPKI string.
-   */
-  static async importPublicKeyFromPEM(pem, algorithm = "RSA-OAEP", curve = "P-256", hash = "SHA-256") {
-    const subtle = getSubtleCrypto();
-    const cleaned = pem.replace(/-----BEGIN[ A-Z0-9_-]+-----/g, "").replace(/-----END[ A-Z0-9_-]+-----/g, "").replace(/\s+/g, "");
-    const spkiBytes = CKeyManager.fromBase64(cleaned);
-    let importAlgorithm;
-    let usages;
-    if (algorithm === "ECDH") {
-      importAlgorithm = { name: "ECDH", namedCurve: curve };
-      usages = [];
-    } else {
-      importAlgorithm = { name: "RSA-OAEP", hash };
-      usages = ["encrypt", "wrapKey"];
-    }
-    try {
-      return await subtle.importKey("spki", spkiBytes, importAlgorithm, true, usages);
-    } finally {
-      spkiBytes.fill(0);
+    const shouldBindReq = isDecrypt ? hasReqContext : options.bindRequestContextAad === true && hasReqContext;
+    if (shouldBindReq) {
+      const m = (options.method || "POST").toUpperCase();
+      const u = options.url || "";
+      return `req:${m}:${u}`;
     }
+    return void 0;
   }
   /**
-   * Imports a private key from a PEM (PKCS#8) or base64 PKCS#8 string.
+   * Helper to deterministically bind record ID, contextual sibling fields (aadFields),
+   * dynamic AAD callbacks, and field name into the AAD to prevent ciphertext swapping
+   * between fields, records, or parent entities.
    */
-  static async importPrivateKeyFromPEM(pem, algorithm = "RSA-OAEP", curve = "P-256", hash = "SHA-256") {
-    if (/BEGIN\s+(RSA|EC)\s+PRIVATE\s+KEY/i.test(pem)) {
-      throw new Error(
-        `[CKeyManager] Failed to import private key. The provided PEM appears to be in PKCS#1 or SEC1 format. Web Crypto requires PKCS#8 format. Convert your key using: openssl pkcs8 -topk8 -nocrypt -in private.pem -out private_pkcs8.pem.`
-      );
-    }
-    const subtle = getSubtleCrypto();
-    const cleaned = pem.replace(/-----BEGIN[ A-Z0-9_-]+-----/g, "").replace(/-----END[ A-Z0-9_-]+-----/g, "").replace(/\s+/g, "");
-    const pkcs8Bytes = CKeyManager.fromBase64(cleaned);
-    let importAlgorithm;
-    let usages;
-    if (algorithm === "ECDH") {
-      importAlgorithm = { name: "ECDH", namedCurve: curve };
-      usages = ["deriveKey", "deriveBits"];
-    } else {
-      importAlgorithm = { name: "RSA-OAEP", hash };
-      usages = ["decrypt", "unwrapKey"];
+  _bindFieldAad(data, field, options) {
+    let baseAad = "";
+    if (options?.baseAad) {
+      baseAad = options.baseAad;
     }
-    try {
-      return await subtle.importKey("pkcs8", pkcs8Bytes, importAlgorithm, true, usages);
-    } finally {
-      pkcs8Bytes.fill(0);
+    if (options?.aad) {
+      if (typeof options.aad === "function") {
+        const dynamicRes = options.aad(data, field);
+        if (typeof dynamicRes === "string") {
+          baseAad = baseAad ? `${baseAad}|${dynamicRes}` : dynamicRes;
+        } else if (dynamicRes instanceof Uint8Array || dynamicRes instanceof ArrayBuffer) {
+          const decoded = textDecoder.decode(dynamicRes);
+          baseAad = baseAad ? `${baseAad}|${decoded}` : decoded;
+        } else if (dynamicRes !== void 0 && dynamicRes !== null) {
+          const str = String(dynamicRes);
+          baseAad = baseAad ? `${baseAad}|${str}` : str;
+        }
+      } else if (typeof options.aad === "string") {
+        baseAad = baseAad ? `${baseAad}|${options.aad}` : options.aad;
+      } else if (options.aad instanceof Uint8Array || options.aad instanceof ArrayBuffer) {
+        const decoded = textDecoder.decode(options.aad);
+        baseAad = baseAad ? `${baseAad}|${decoded}` : decoded;
+      } else {
+        const str = String(options.aad);
+        baseAad = baseAad ? `${baseAad}|${str}` : str;
+      }
     }
-  }
-  /**
-   * Exports a public CryptoKey to a standard PEM (SPKI) string.
-   */
-  static async exportPublicKeyToPEM(key) {
-    const subtle = getSubtleCrypto();
-    const spki = await subtle.exportKey("spki", key);
-    let b64;
-    try {
-      b64 = CKeyManager.toBase64(spki);
-    } finally {
-      new Uint8Array(spki).fill(0);
+    const recordId = data && typeof data === "object" && (data.id !== void 0 || data._id !== void 0) ? String(data.id ?? data._id) : "";
+    const recordPart = recordId ? `|record:${recordId}` : "";
+    let contextPart = "";
+    if (options?.aadFields && options.aadFields.length > 0 && data && typeof data === "object") {
+      const sortedFields = [...options.aadFields].sort();
+      const parts = [];
+      for (const f of sortedFields) {
+        const val = data[f];
+        let serializedVal = "";
+        if (val === null) {
+          serializedVal = "null";
+        } else if (val !== void 0) {
+          serializedVal = typeof val === "object" ? JSON.stringify(val) : String(val);
+        }
+        parts.push(`${f}=${serializedVal}`);
+      }
+      contextPart = `|ctx:${parts.join(",")}`;
     }
-    const lines = b64.match(/.{1,64}/g) || [b64];
-    return `-----BEGIN PUBLIC KEY-----
-${lines.join("\n")}
------END PUBLIC KEY-----`;
+    const reqPart = options?.bindRequestContextAad === true && (options?.url || options?.method) ? `|req:${(options.method || "POST").toUpperCase()}:${options.url || ""}` : "";
+    return {
+      ...options,
+      bindRequestContextAad: false,
+      aad: `aad:${baseAad}${recordPart}${contextPart}${reqPart}|field:${field}`
+    };
   }
   /**
-   * Exports a private CryptoKey to a standard PEM (PKCS#8) string.
+   * Validates envelope metadata against algorithm whitelists and key identifiers (kid).
+   * In strict mode, allowedAlgorithms defaults to ['AES-GCM'].
    */
-  static async exportPrivateKeyToPEM(key) {
-    const subtle = getSubtleCrypto();
-    const pkcs8 = await subtle.exportKey("pkcs8", key);
-    let b64;
-    try {
-      b64 = CKeyManager.toBase64(pkcs8);
-    } finally {
-      new Uint8Array(pkcs8).fill(0);
+  _validateEnvelopeMetadata(payload, options) {
+    if (!payload || typeof payload !== "object") return void 0;
+    const allowedAlgorithms = options?.allowedAlgorithms ?? (options?.strict ? ["AES-GCM"] : void 0);
+    if (allowedAlgorithms && allowedAlgorithms.length > 0) {
+      const alg = payload.alg;
+      if (!alg || !allowedAlgorithms.includes(alg)) {
+        return new Error(`[AEncryptionProvider] Algorithm mismatch: algorithm '${alg || "unknown"}' is not in allowedAlgorithms.`);
+      }
     }
-    const lines = b64.match(/.{1,64}/g) || [b64];
-    return `-----BEGIN PRIVATE KEY-----
-${lines.join("\n")}
------END PRIVATE KEY-----`;
+    const effectiveKeys = options?.keys || this.keys;
+    const effectiveAllowedKids = options?.allowedKids || this.allowedKids;
+    const allowedKids = effectiveAllowedKids ?? (effectiveKeys ? Object.keys(effectiveKeys) : void 0);
+    if (allowedKids && allowedKids.length > 0) {
+      if (payload.kid && !allowedKids.includes(payload.kid)) {
+        return new Error(`[AEncryptionProvider] Unauthorized key: kid '${payload.kid}' is not in allowedKids.`);
+      }
+    }
+    return void 0;
   }
-  // ── Key Wrapping & Unwrapping ────────────────────────────────────────────
   /**
-   * Wraps a target CryptoKey (e.g. an Account Symmetric Key) using a wrapping key
-   * (AES-KW or RSA-OAEP).
+   * Normalizes encryption options with active keyring parameters:
+   * If `keys` and `activeKid` are configured, selects `key = keys[activeKid]` and sets `kid = activeKid`.
    */
-  static async wrapKey(keyToWrap, wrappingKey, format = "raw") {
-    const subtle = getSubtleCrypto();
-    let wrapAlgorithm;
-    if (wrappingKey.algorithm.name === "RSA-OAEP") {
-      wrapAlgorithm = { name: "RSA-OAEP" };
-    } else if (wrappingKey.algorithm.name === "AES-KW") {
-      wrapAlgorithm = "AES-KW";
-    } else {
-      wrapAlgorithm = "AES-KW";
+  _resolveOutboundKeyringOptions(options) {
+    const effectiveKeys = options?.keys || this.keys;
+    const effectiveActiveKid = options?.activeKid || (options?.kid ? options.kid : this.activeKid);
+    let effectiveKey = options?.key;
+    let effectiveKid = options?.kid || effectiveActiveKid;
+    if (effectiveKeys && effectiveActiveKid) {
+      if (effectiveKeys[effectiveActiveKid]) {
+        effectiveKey = options?.key || effectiveKeys[effectiveActiveKid];
+        effectiveKid = effectiveActiveKid;
+      } else if (!options?.key) {
+        throw new Error(`[${this.constructor.name}] Active kid '${effectiveActiveKid}' not found in keyring keys.`);
+      }
+    } else if (effectiveKeys && !effectiveKey) {
+      const kids = Object.keys(effectiveKeys);
+      if (kids.length > 0) {
+        effectiveKid = kids[0];
+        effectiveKey = effectiveKeys[kids[0]];
+      }
+    }
+    if (effectiveKeys || effectiveActiveKid || effectiveKey !== options?.key || effectiveKid !== options?.kid) {
+      return {
+        ...options,
+        ...effectiveKeys ? { keys: effectiveKeys } : {},
+        ...effectiveActiveKid ? { activeKid: effectiveActiveKid } : {},
+        ...effectiveKey !== void 0 ? { key: effectiveKey } : {},
+        ...effectiveKid !== void 0 ? { kid: effectiveKid } : {}
+      };
     }
-    const wrappedBuffer = await subtle.wrapKey(format, keyToWrap, wrappingKey, wrapAlgorithm);
-    return CKeyManager.toBase64(wrappedBuffer);
+    return options || {};
   }
   /**
-   * Unwraps a base64-encoded wrapped key using an unwrapping key (AES-KW or RSA-OAEP).
+   * Resolves the appropriate decryption key for a specific payload envelope based on its `kid`
+   * and the configured keyring (`keys`, `activeKid`, or fallback `key`).
    */
-  static async unwrapKey(wrappedBase64, unwrappingKey, unwrappedKeyAlgorithm = { name: "AES-GCM", length: 256 }, extractable = true, keyUsages = ["encrypt", "decrypt"], format = "raw") {
-    const subtle = getSubtleCrypto();
-    const wrappedBytes = CKeyManager.fromBase64(wrappedBase64);
-    let unwrapAlgorithm;
-    if (unwrappingKey.algorithm.name === "RSA-OAEP") {
-      unwrapAlgorithm = { name: "RSA-OAEP" };
-    } else {
-      unwrapAlgorithm = "AES-KW";
+  _resolveDecryptionKeyForEnvelope(payload, options) {
+    const effectiveKeys = options?.keys || this.keys;
+    const effectiveActiveKid = options?.activeKid || this.activeKid;
+    if (payload && typeof payload === "object" && payload.kid && effectiveKeys) {
+      if (effectiveKeys[payload.kid]) {
+        return effectiveKeys[payload.kid];
+      }
     }
-    try {
-      return await subtle.unwrapKey(
-        format,
-        wrappedBytes,
-        unwrappingKey,
-        unwrapAlgorithm,
-        unwrappedKeyAlgorithm,
-        extractable,
-        keyUsages
-      );
-    } finally {
-      wrappedBytes.fill(0);
+    if (effectiveKeys && effectiveActiveKid && effectiveKeys[effectiveActiveKid]) {
+      return effectiveKeys[effectiveActiveKid];
     }
+    return options?.key || this.defaultKey;
   }
   /**
-   * Generates a high-entropy symmetric AES-GCM Account Data Encryption Key (ADEK).
-   * Designed for multi-user table and field-level encryption.
+   * Handles a per-field or per-payload decryption error according to configured options:
+   * - Invokes onDecryptError callback if provided
+   * - Attaches error metadata (__decryptErrors) to the record object
+   * - Returns fallback cell placeholder ('[⚠ Decryption Error]') or rethrows
    */
-  static async generateAccountDataKey(length = 256, extractable = false) {
-    const subtle = getSubtleCrypto();
-    return await subtle.generateKey(
-      { name: "AES-GCM", length },
-      extractable,
-      ["encrypt", "decrypt"]
-    );
+  _handleDecryptError(err, record, field, value, index, options) {
+    if (record && typeof record === "object" && record !== value) {
+      record.__decryptErrors = {
+        ...record.__decryptErrors || {},
+        [field || "__payload"]: err
+      };
+    }
+    if (options?.onDecryptError === false || options?.onDecryptError === void 0) {
+      throw err;
+    }
+    if (typeof options.onDecryptError === "function") {
+      return options.onDecryptError({
+        record,
+        field,
+        value,
+        error: err,
+        index
+      });
+    }
+    if (typeof options.onDecryptError === "string") {
+      return options.onDecryptError;
+    }
+    if (options.onDecryptError === true) {
+      return "[\u26A0 Decryption Error]";
+    }
+    throw err;
   }
   /**
-   * Wraps an Account Data Encryption Key (ADEK) for a specific user using the user's public key (RSA-OAEP).
-   * Returns a Base64-encoded wrapped key string suitable for storage in role-map / access tables.
+   * Encrypts a single scalar value with contextual AAD binding into an IEncryptedPayload envelope.
+   * Binds recordId, fieldName, and sibling aadFields deterministically to protect against ciphertext swapping.
+   *
+   * @param value - Scalar value (string, number, boolean, object) to encrypt.
+   * @param context - Field encryption context with recordId, fieldName, and optional sibling aadFields.
    */
-  static async wrapAccountKeyForUser(adek, userPublicKey) {
-    const subtle = getSubtleCrypto();
-    if (userPublicKey.algorithm.name === "RSA-OAEP") {
-      const rawKey = await subtle.exportKey("raw", adek);
-      try {
-        const wrappedBuffer = await subtle.encrypt(
-          { name: "RSA-OAEP" },
-          userPublicKey,
-          rawKey
-        );
-        return CKeyManager.toBase64(wrappedBuffer);
-      } finally {
-        new Uint8Array(rawKey).fill(0);
-      }
-    }
-    throw new Error(
-      `[CKeyManager] Unsupported user key algorithm for wrapAccountKeyForUser: '${userPublicKey.algorithm.name}'. Expected 'RSA-OAEP'.`
-    );
+  async encryptField(value, context) {
+    if (value === void 0 || value === null) return value;
+    if (this.isEncrypted(value)) return value;
+    const field = context?.fieldName || "field";
+    const dummyData = {};
+    if (context?.recordId !== void 0) {
+      dummyData.id = context.recordId;
+    }
+    const { aadFields, ...restContext } = context || {};
+    let boundOptions = { ...restContext };
+    if (aadFields) {
+      if (!Array.isArray(aadFields) && typeof aadFields === "object") {
+        Object.assign(dummyData, aadFields);
+        boundOptions.aadFields = Object.keys(aadFields);
+      } else if (Array.isArray(aadFields)) {
+        boundOptions.aadFields = aadFields;
+        if (context?.record) {
+          Object.assign(dummyData, context.record);
+        }
+      }
+    }
+    const resolvedOptions = this._bindFieldAad(dummyData, field, boundOptions);
+    return this.encryptValue(value, resolvedOptions);
   }
   /**
-   * Unwraps a Base64-encoded Account Data Encryption Key (ADEK) using the user's private key (RSA-OAEP).
-   * Returns the restored AES-GCM CryptoKey ready for use in CWebCryptoEncryptionProvider.
+   * Decrypts a single IEncryptedPayload envelope back into its scalar plaintext value using contextual AAD.
+   * Validates recordId, fieldName, and sibling aadFields integrity.
+   *
+   * @param envelope - The IEncryptedPayload envelope to decrypt.
+   * @param context - Field encryption context matching the encryption parameters.
    */
-  static async unwrapAccountKeyForUser(wrappedKeyBase64, userPrivateKey, unwrappedKeyAlgorithm = { name: "AES-GCM", length: 256 }, extractable = false) {
-    const subtle = getSubtleCrypto();
-    if (userPrivateKey.algorithm.name === "RSA-OAEP") {
-      const wrappedBytes = CKeyManager.fromBase64(wrappedKeyBase64);
-      let unwrappedRawKey;
-      try {
-        unwrappedRawKey = await subtle.decrypt(
-          { name: "RSA-OAEP" },
-          userPrivateKey,
-          wrappedBytes
-        );
-      } finally {
-        wrappedBytes.fill(0);
-      }
-      try {
-        return await subtle.importKey(
-          "raw",
-          unwrappedRawKey,
-          unwrappedKeyAlgorithm,
-          extractable,
-          ["encrypt", "decrypt"]
-        );
-      } finally {
-        new Uint8Array(unwrappedRawKey).fill(0);
+  async decryptField(envelope, context) {
+    if (!this.isEncrypted(envelope)) return envelope;
+    const field = context?.fieldName || "field";
+    const dummyData = {};
+    if (context?.recordId !== void 0) {
+      dummyData.id = context.recordId;
+    }
+    const { aadFields, ...restContext } = context || {};
+    let boundOptions = { ...restContext };
+    if (aadFields) {
+      if (!Array.isArray(aadFields) && typeof aadFields === "object") {
+        Object.assign(dummyData, aadFields);
+        boundOptions.aadFields = Object.keys(aadFields);
+      } else if (Array.isArray(aadFields)) {
+        boundOptions.aadFields = aadFields;
+        if (context?.record) {
+          Object.assign(dummyData, context.record);
+        }
       }
     }
-    throw new Error(
-      `[CKeyManager] Unsupported user key algorithm for unwrapAccountKeyForUser: '${userPrivateKey.algorithm.name}'. Expected 'RSA-OAEP'.`
-    );
+    const resolvedOptions = this._bindFieldAad(dummyData, field, boundOptions);
+    return this.decryptValue(envelope, resolvedOptions);
   }
-  // ── Key Derivation Functions (PBKDF2 & HKDF) ──────────────────────────────
   /**
-   * Derives a symmetric AES-GCM CryptoKey from a passphrase using PBKDF2 or HKDF.
-   * Returns the derived CryptoKey and the base64-encoded salt.
+   * Top-level polymorphic encryption method.
+   * Automatically performs value-level encryption:
+   * - If data is an array of objects: recursively encrypts each row.
+   * - If data is an object: encrypts specified fields (or all values if valueEncryption is true),
+   *   preserving JSON object keys so backend APIs and ORMs can parse keys and perform upserts.
+   * - If data is a primitive or whole-payload envelope: encrypts as a single value.
    */
-  static async deriveKey(passphrase, options) {
-    if (!passphrase || typeof passphrase === "string" && passphrase.trim().length === 0 || typeof passphrase === "object" && "byteLength" in passphrase && passphrase.byteLength === 0) {
-      throw new Error("[CKeyManager] Passphrase cannot be empty or undefined for key derivation.");
+  async encrypt(data, options) {
+    if (data === void 0 || data === null) return data;
+    if (this.isEncrypted(data)) return data;
+    options = this._resolveOutboundKeyringOptions(options);
+    if (options?.valueEncryption === false && (!options.fields || options.fields.length === 0)) {
+      return this.encryptValue(data, options);
     }
-    const subtle = getSubtleCrypto();
-    const saltBytes = CKeyManager.resolveSalt(options.salt);
-    const keyLength = options.keyLength || 256;
-    const hash = options.hash || "SHA-256";
-    const extractable = options.extractable === true;
-    const rawKeyBytes = typeof passphrase === "string" ? textEncoder$1.encode(passphrase) : passphrase instanceof Uint8Array ? passphrase : new Uint8Array(passphrase);
-    try {
-      if (options.kdf === "pbkdf2") {
-        const baseKey = await subtle.importKey(
-          "raw",
-          rawKeyBytes,
-          "PBKDF2",
-          false,
-          ["deriveKey"]
+    if (Array.isArray(data)) {
+      if (data.length === 0) return data;
+      if (options?.fields && options.fields.length > 0) {
+        const fields = options.fields;
+        let hasUnencrypted = false;
+        for (let i = 0; i < data.length; i++) {
+          const item = data[i];
+          if (item && typeof item === "object") {
+            for (let f = 0; f < fields.length; f++) {
+              const val = item[fields[f]];
+              if (val !== void 0 && val !== null && !this.isEncrypted(val)) {
+                hasUnencrypted = true;
+                break;
+              }
+            }
+            if (hasUnencrypted) break;
+          }
+        }
+        if (!hasUnencrypted) {
+          return data;
+        }
+        await this.warmupKey(options);
+        const itemOptions = { ...options, _warmed: true };
+        return Promise.all(data.map((item) => this.encrypt(item, itemOptions)));
+      }
+      if (options?.valueEncryption === true) {
+        await this.warmupKey(options);
+        const itemOptions = { ...options, _warmed: true };
+        return Promise.all(data.map((item) => this.encrypt(item, itemOptions)));
+      }
+      return this.encryptValue(data, options);
+    }
+    if (typeof data === "object" && !ArrayBuffer.isView(data) && !(data instanceof ArrayBuffer)) {
+      if (options?.fields && options.fields.length > 0) {
+        const fieldsToEncrypt = options.fields.filter(
+          (field) => Object.prototype.hasOwnProperty.call(data, field) && data[field] !== void 0 && data[field] !== null && !this.isEncrypted(data[field])
         );
-        const derivedKey = await subtle.deriveKey(
-          {
-            name: "PBKDF2",
-            salt: saltBytes,
-            iterations: options.iterations || 31e4,
-            hash
-          },
-          baseKey,
-          { name: "AES-GCM", length: keyLength },
-          extractable,
-          ["encrypt", "decrypt"]
+        if (fieldsToEncrypt.length === 0) {
+          return data;
+        }
+        if (!options?._warmed) {
+          await this.warmupKey(options);
+        }
+        const result = { ...data };
+        const entries = await Promise.all(
+          fieldsToEncrypt.map(async (field) => {
+            const fieldOptions = this._bindFieldAad(data, field, options);
+            return [field, await this.encryptValue(result[field], fieldOptions)];
+          })
         );
-        return {
-          key: derivedKey,
-          salt: CKeyManager.toBase64(saltBytes)
-        };
+        for (const [field, encryptedVal] of entries) {
+          safeSetProperty(result, field, encryptedVal);
+        }
+        return result;
       }
-      if (options.kdf === "hkdf") {
-        const baseKey = await subtle.importKey(
-          "raw",
-          rawKeyBytes,
-          "HKDF",
-          false,
-          ["deriveKey"]
+      if (options?.valueEncryption === true) {
+        const result = { ...data };
+        const keysToEncrypt = Object.keys(result).filter(
+          (key) => result[key] !== void 0 && result[key] !== null && !this.isEncrypted(result[key])
         );
-        const infoBytes = resolveInfoBytes(options.info, "katlux-derived-aes-key");
-        const derivedKey = await subtle.deriveKey(
-          {
-            name: "HKDF",
-            salt: saltBytes,
-            info: infoBytes,
-            hash
-          },
-          baseKey,
-          { name: "AES-GCM", length: keyLength },
-          extractable,
-          ["encrypt", "decrypt"]
+        if (keysToEncrypt.length === 0) {
+          return result;
+        }
+        if (!options?._warmed) {
+          await this.warmupKey(options);
+        }
+        const entries = await Promise.all(
+          keysToEncrypt.map(async (key) => {
+            const fieldOptions = this._bindFieldAad(data, key, options);
+            return [key, await this.encryptValue(result[key], fieldOptions)];
+          })
         );
-        return {
-          key: derivedKey,
-          salt: CKeyManager.toBase64(saltBytes)
-        };
-      }
-      throw new Error(`[CKeyManager] Unsupported KDF strategy: ${options.kdf}`);
-    } finally {
-      if (typeof passphrase === "string") {
-        rawKeyBytes.fill(0);
+        for (const [key, encryptedVal] of entries) {
+          safeSetProperty(result, key, encryptedVal);
+        }
+        return result;
       }
     }
+    return this.encryptValue(data, options);
   }
   /**
-   * Derives an AES-GCM CryptoKey from a high-entropy secret (e.g. an ECDH shared secret key)
-   * using HKDF.
+   * Top-level polymorphic decryption method.
+   * Automatically performs value-level decryption:
+   * - If payload is an encrypted envelope: validates metadata and decrypts directly via decryptValue.
+   * - If payload is an array of objects: decrypts each row (batched with local memoization).
+   * - If payload is an object: decrypts any encrypted value cells across fields.
+   * In strict mode:
+   * - Unencrypted plaintext in configured `fields` triggers a decryption error.
+   * - Envelopes are validated against `allowedAlgorithms` and `allowedKids`.
+   * - Errors are routed through `onDecryptError` or populated into `__decryptErrors`.
    */
-  static async deriveKeyFromSecret(secretKey, options = {}) {
-    const subtle = getSubtleCrypto();
-    let saltBytes;
-    if (options.salt !== void 0) {
-      saltBytes = CKeyManager.resolveSalt(options.salt);
-    } else {
-      saltBytes = new Uint8Array(16);
+  async decrypt(payload, options) {
+    if (payload === void 0 || payload === null) return payload;
+    if (this.isEncrypted(payload)) {
+      const envelopeKey = this._resolveDecryptionKeyForEnvelope(payload, options);
+      const envelopeOptions = envelopeKey !== options?.key ? { ...options, key: envelopeKey } : options;
+      const metaErr = this._validateEnvelopeMetadata(payload, envelopeOptions);
+      if (metaErr) {
+        return this._handleDecryptError(metaErr, payload, "", payload, void 0, envelopeOptions);
+      }
+      try {
+        return await this.decryptValue(payload, envelopeOptions);
+      } catch (err) {
+        return this._handleDecryptError(err, payload, "", payload, void 0, envelopeOptions);
+      }
     }
-    const infoBytes = resolveInfoBytes(options.info, "katlux-ecdh-aes-gcm");
-    const hash = options.hash || "SHA-256";
-    const keyLength = options.keyLength || 256;
-    const extractable = options.extractable === true;
-    return await subtle.deriveKey(
-      {
-        name: "HKDF",
-        salt: saltBytes,
-        info: infoBytes,
-        hash
-      },
-      secretKey,
-      { name: "AES-GCM", length: keyLength },
-      extractable,
-      ["encrypt", "decrypt"]
-    );
+    if (Array.isArray(payload)) {
+      if (payload.length === 0) return payload;
+      const localMemo = /* @__PURE__ */ new Map();
+      const decryptRow = async (item, rowIndex) => {
+        if (!item) return item;
+        if (this.isEncrypted(item)) {
+          const envelopeKey = this._resolveDecryptionKeyForEnvelope(item, options);
+          const envelopeOptions = envelopeKey !== options?.key ? { ...options, key: envelopeKey } : options;
+          const metaErr = this._validateEnvelopeMetadata(item, envelopeOptions);
+          if (metaErr) {
+            return this._handleDecryptError(metaErr, item, "", item, rowIndex, envelopeOptions);
+          }
+          const ct = item.ciphertext;
+          const iv = item.iv || "";
+          const aadPart = options?.aad ? typeof options.aad === "string" ? options.aad : "" : "";
+          const memoKey = `${ct}:${iv}:${aadPart}:${item.kid || ""}`;
+          try {
+            if (!localMemo.has(memoKey)) {
+              localMemo.set(memoKey, this.decryptValue(item, envelopeOptions));
+            }
+            return await localMemo.get(memoKey);
+          } catch (err) {
+            return this._handleDecryptError(err, item, "", item, rowIndex, envelopeOptions);
+          }
+        }
+        if (typeof item === "object" && !ArrayBuffer.isView(item) && !(item instanceof ArrayBuffer)) {
+          const targetKeys = options?.fields && options.fields.length > 0 ? options.fields.filter((f) => Object.prototype.hasOwnProperty.call(item, f)) : Object.keys(item);
+          const keysToDecrypt = targetKeys.filter((key) => this.isEncrypted(item[key]));
+          const strictViolationKeys = options?.strict === true && options?.fields && options.fields.length > 0 ? targetKeys.filter((key) => item[key] !== void 0 && item[key] !== null && !this.isEncrypted(item[key])) : [];
+          if (keysToDecrypt.length === 0 && strictViolationKeys.length === 0) {
+            return item;
+          }
+          const proto = Object.getPrototypeOf(item);
+          const result = proto && proto !== Object.prototype ? Object.assign(Object.create(proto), item) : { ...item };
+          for (const key of strictViolationKeys) {
+            const err = new Error(`[AEncryptionProvider] Strict decryption violation: field '${key}' contains unencrypted plaintext.`);
+            const fallbackVal = this._handleDecryptError(err, result, key, item[key], rowIndex, options);
+            safeSetProperty(result, key, fallbackVal);
+          }
+          await Promise.all(
+            keysToDecrypt.map(async (key) => {
+              const env = item[key];
+              const envelopeKey = this._resolveDecryptionKeyForEnvelope(env, options);
+              const baseOptions = envelopeKey !== options?.key ? { ...options, key: envelopeKey } : options;
+              const boundOptions = this._bindFieldAad(item, key, baseOptions);
+              const hasBoundAad = boundOptions.aad !== baseOptions?.aad;
+              const metaErr = this._validateEnvelopeMetadata(env, boundOptions);
+              if (metaErr) {
+                const fallbackVal = this._handleDecryptError(metaErr, result, key, env, rowIndex, boundOptions);
+                safeSetProperty(result, key, fallbackVal);
+                return;
+              }
+              const ct = env.ciphertext;
+              const iv = env.iv || "";
+              const aadPart = boundOptions.aad ? typeof boundOptions.aad === "string" ? boundOptions.aad : "" : "";
+              const memoKey = `${ct}:${iv}:${aadPart}:${env.kid || ""}`;
+              try {
+                if (!localMemo.has(memoKey)) {
+                  const decryptPromise = (async () => {
+                    try {
+                      return await this.decryptValue(env, boundOptions);
+                    } catch (err) {
+                      const canFallback = hasBoundAad && (!options?.aadFields || options.aadFields.length === 0) && typeof options?.aad !== "function";
+                      if (canFallback && isAuthOrDecryptionError(err)) {
+                        return await this.decryptValue(env, baseOptions);
+                      }
+                      throw err;
+                    }
+                  })();
+                  localMemo.set(memoKey, decryptPromise);
+                }
+                const decryptedVal = await localMemo.get(memoKey);
+                safeSetProperty(result, key, decryptedVal);
+              } catch (err) {
+                const fallbackVal = this._handleDecryptError(err, result, key, env, rowIndex, boundOptions);
+                safeSetProperty(result, key, fallbackVal);
+              }
+            })
+          );
+          return result;
+        }
+        return item;
+      };
+      if (payload.length <= 100) {
+        return Promise.all(payload.map((item, index) => decryptRow(item, index)));
+      }
+      const batchSize = 1e3;
+      const results = new Array(payload.length);
+      for (let i = 0; i < payload.length; i += batchSize) {
+        const end = Math.min(i + batchSize, payload.length);
+        const chunk = payload.slice(i, end);
+        const chunkRes = await Promise.all(chunk.map((item, localIdx) => decryptRow(item, i + localIdx)));
+        for (let j = 0; j < chunkRes.length; j++) {
+          results[i + j] = chunkRes[j];
+        }
+        if (end < payload.length && (i > 0 && i % 5e3 === 0)) {
+          await new Promise((r) => setTimeout(r, 0));
+        }
+      }
+      return results;
+    }
+    if (typeof payload === "object" && !ArrayBuffer.isView(payload) && !(payload instanceof ArrayBuffer)) {
+      const targetKeys = options?.fields && options.fields.length > 0 ? options.fields.filter((f) => Object.prototype.hasOwnProperty.call(payload, f)) : Object.keys(payload);
+      const keysToDecrypt = targetKeys.filter((key) => this.isEncrypted(payload[key]));
+      const strictViolationKeys = options?.strict === true && options?.fields && options.fields.length > 0 ? targetKeys.filter((key) => payload[key] !== void 0 && payload[key] !== null && !this.isEncrypted(payload[key])) : [];
+      if (keysToDecrypt.length === 0 && strictViolationKeys.length === 0) {
+        return payload;
+      }
+      const proto = Object.getPrototypeOf(payload);
+      const result = proto && proto !== Object.prototype ? Object.assign(Object.create(proto), payload) : { ...payload };
+      for (const key of strictViolationKeys) {
+        const err = new Error(`[AEncryptionProvider] Strict decryption violation: field '${key}' contains unencrypted plaintext.`);
+        const fallbackVal = this._handleDecryptError(err, result, key, payload[key], void 0, options);
+        safeSetProperty(result, key, fallbackVal);
+      }
+      await Promise.all(
+        keysToDecrypt.map(async (key) => {
+          const env = payload[key];
+          const envelopeKey = this._resolveDecryptionKeyForEnvelope(env, options);
+          const baseOptions = envelopeKey !== options?.key ? { ...options, key: envelopeKey } : options;
+          const boundOptions = this._bindFieldAad(payload, key, baseOptions);
+          const hasBoundAad = boundOptions.aad !== baseOptions?.aad;
+          const metaErr = this._validateEnvelopeMetadata(env, boundOptions);
+          if (metaErr) {
+            const fallbackVal = this._handleDecryptError(metaErr, result, key, env, void 0, boundOptions);
+            safeSetProperty(result, key, fallbackVal);
+            return;
+          }
+          try {
+            let decryptedVal;
+            try {
+              decryptedVal = await this.decryptValue(env, boundOptions);
+            } catch (err) {
+              const canFallback = hasBoundAad && (!options?.aadFields || options.aadFields.length === 0) && typeof options?.aad !== "function";
+              if (canFallback && isAuthOrDecryptionError(err)) {
+                decryptedVal = await this.decryptValue(env, baseOptions);
+              } else {
+                throw err;
+              }
+            }
+            safeSetProperty(result, key, decryptedVal);
+          } catch (err) {
+            const fallbackVal = this._handleDecryptError(err, result, key, env, void 0, boundOptions);
+            safeSetProperty(result, key, fallbackVal);
+          }
+        })
+      );
+      return result;
+    }
+    return payload;
   }
 }
 
@@ -1558,6 +2407,7 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
   _cachedKeyId;
   _configuredKid;
   _decryptSaltCache = /* @__PURE__ */ new Map();
+  _keyringCache = /* @__PURE__ */ new Map();
   setDefaultKey(key) {
     super.setDefaultKey(key);
     this._cachedKey = void 0;
@@ -1567,6 +2417,7 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
     this._cachedHash = void 0;
     this._cachedKeyId = void 0;
     this._decryptSaltCache.clear();
+    this._keyringCache.clear();
   }
   clearKeys() {
     super.clearKeys();
@@ -1577,9 +2428,10 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
     this._cachedHash = void 0;
     this._cachedKeyId = void 0;
     this._decryptSaltCache.clear();
+    this._keyringCache.clear();
   }
   constructor(key, options) {
-    super(key);
+    super(key, options);
     if (options) {
       if (options.kid || options.keyId) {
         this._configuredKid = options.kid || options.keyId;
@@ -1629,14 +2481,21 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
   }
   async _resolveCryptoKeyInternal(keyProvider, kdfOverride, saltOverride, options, iterationsOverride) {
     const rawKey = await this.resolveRawKey(keyProvider);
+    const currentKeyId = getSafeKeyIdentifier(rawKey);
     if (typeof rawKey !== "string" && rawKey.algorithm) {
-      if (!keyProvider) {
+      const res2 = { cryptoKey: rawKey, kdf: "direct" };
+      this._keyringCache.set(currentKeyId, res2);
+      if (!keyProvider || keyProvider === this.defaultKey) {
         this._cachedKey = rawKey;
         this._cachedKdf = "direct";
       }
-      return { cryptoKey: rawKey, kdf: "direct" };
+      return res2;
     }
     if (rawKey instanceof Uint8Array || rawKey instanceof ArrayBuffer) {
+      const cached = this._keyringCache.get(currentKeyId);
+      if (cached) {
+        return cached;
+      }
       if (!keyProvider && this._cachedKey && this._cachedKdf === "raw") {
         return { cryptoKey: this._cachedKey, kdf: "raw" };
       }
@@ -1653,11 +2512,13 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
         false,
         ["encrypt", "decrypt"]
       );
-      if (!keyProvider) {
+      const res2 = { cryptoKey: cryptoKey2, kdf: "raw" };
+      this._keyringCache.set(currentKeyId, res2);
+      if (!keyProvider || keyProvider === this.defaultKey) {
         this._cachedKey = cryptoKey2;
         this._cachedKdf = "raw";
       }
-      return { cryptoKey: cryptoKey2, kdf: "raw" };
+      return res2;
     }
     const passphrase = rawKey;
     const kdf = (kdfOverride || options?.kdf || this._defaultKdf || "pbkdf2").toLowerCase();
@@ -1667,12 +2528,21 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
     const matchesHash = !targetHash || this._cachedHash !== void 0 && targetHash.toLowerCase() === this._cachedHash.toLowerCase();
     const matchesKdf = this._cachedKdf !== void 0 && kdf === this._cachedKdf.toLowerCase();
     const matchesSalt = !saltOverride || this._cachedSalt !== void 0 && saltOverride === this._cachedSalt;
-    const currentKeyId = getSafeKeyIdentifier(rawKey);
     if (this._cachedKey && matchesSalt && !options?.kdfSalt && matchesKdf && matchesIter && matchesHash) {
       if (this._cachedKeyId === currentKeyId) {
         return { cryptoKey: this._cachedKey, salt: this._cachedSalt, kdf: this._cachedKdf, iter: this._cachedIter };
       }
     }
+    if (!saltOverride && !options?.kdfSalt) {
+      const cached = this._keyringCache.get(currentKeyId);
+      if (cached) {
+        const cMatchesKdf = !cached.kdf || cached.kdf.toLowerCase() === kdf;
+        const cMatchesIter = !targetIter || cached.iter === targetIter;
+        if (cMatchesKdf && cMatchesIter) {
+          return cached;
+        }
+      }
+    }
     if (kdf === "pbkdf2") {
       const salt = saltOverride || options?.kdfSalt || this._kdfOptions?.salt;
       const rawIterations = iterationsOverride || options?.kdfIterations || this._kdfOptions?.iterations || 31e4;
@@ -1684,15 +2554,19 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
         iterations,
         hash
       });
+      const res2 = { cryptoKey: derived.key, salt: derived.salt, kdf: "PBKDF2", iter: iterations };
       if (!saltOverride && !options?.kdfSalt) {
-        this._cachedKey = derived.key;
-        this._cachedSalt = derived.salt;
-        this._cachedKdf = "PBKDF2";
-        this._cachedIter = iterations;
-        this._cachedHash = hash;
-        this._cachedKeyId = currentKeyId;
+        this._keyringCache.set(currentKeyId, res2);
+        if (!keyProvider || keyProvider === this.defaultKey) {
+          this._cachedKey = derived.key;
+          this._cachedSalt = derived.salt;
+          this._cachedKdf = "PBKDF2";
+          this._cachedIter = iterations;
+          this._cachedHash = hash;
+          this._cachedKeyId = currentKeyId;
+        }
       }
-      return { cryptoKey: derived.key, salt: derived.salt, kdf: "PBKDF2", iter: iterations };
+      return res2;
     }
     if (kdf === "hkdf") {
       if (typeof rawKey === "string") {
@@ -1709,14 +2583,18 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
         hash,
         info
       });
+      const res2 = { cryptoKey: derived.key, salt: derived.salt, kdf: "HKDF" };
       if (!saltOverride && !options?.kdfSalt) {
-        this._cachedKey = derived.key;
-        this._cachedSalt = derived.salt;
-        this._cachedKdf = "HKDF";
-        this._cachedHash = hash;
-        this._cachedKeyId = currentKeyId;
+        this._keyringCache.set(currentKeyId, res2);
+        if (!keyProvider || keyProvider === this.defaultKey) {
+          this._cachedKey = derived.key;
+          this._cachedSalt = derived.salt;
+          this._cachedKdf = "HKDF";
+          this._cachedHash = hash;
+          this._cachedKeyId = currentKeyId;
+        }
       }
-      return { cryptoKey: derived.key, salt: derived.salt, kdf: "HKDF" };
+      return res2;
     }
     if (kdf === "none") {
       if (saltOverride) {
@@ -1748,11 +2626,13 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
     } finally {
       new Uint8Array(keyHash).fill(0);
     }
-    if (!keyProvider) {
+    const res = { cryptoKey, kdf: "none" };
+    this._keyringCache.set(currentKeyId, res);
+    if (!keyProvider || keyProvider === this.defaultKey) {
       this._cachedKey = cryptoKey;
       this._cachedKdf = "none";
     }
-    return { cryptoKey, kdf: "none" };
+    return res;
   }
   static isEncrypted(payload) {
     if (!payload || typeof payload !== "object") return false;
@@ -1762,6 +2642,29 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
     return CWebCryptoEncryptionProvider.isEncrypted(payload);
   }
   async warmupKey(options) {
+    const effectiveKeys = options?.keys || this.keys;
+    if (effectiveKeys && Object.keys(effectiveKeys).length > 0) {
+      const promises = Object.entries(effectiveKeys).map(async ([kid, keyProv]) => {
+        const res2 = await this.resolveCryptoKey(keyProv, void 0, void 0, { ...options, key: keyProv, kid });
+        const rawKey = await this.resolveRawKey(keyProv);
+        const keyId = getSafeKeyIdentifier(rawKey);
+        this._keyringCache.set(keyId, res2);
+        this._keyringCache.set(`kid:${kid}`, res2);
+        return { kid, res: res2 };
+      });
+      const results = await Promise.all(promises);
+      const effectiveActiveKid = options?.activeKid || this.activeKid;
+      const primary = effectiveActiveKid && results.find((r) => r.kid === effectiveActiveKid)?.res || results[0]?.res;
+      if (primary) {
+        this._cachedKey = primary.cryptoKey;
+        this._cachedSalt = primary.salt;
+        this._cachedKdf = primary.kdf;
+        this._cachedIter = primary.iter;
+        this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
+        this._cachedKeyId = getKeyIdentifier(options?.key, this.defaultKey);
+      }
+      return;
+    }
     const res = await this.resolveCryptoKey(options?.key, void 0, void 0, options);
     this._cachedKey = res.cryptoKey;
     this._cachedSalt = res.salt;
@@ -1804,7 +2707,7 @@ class CWebCryptoEncryptionProvider extends AEncryptionProvider {
       cryptoKey,
       textEncoder$1.encode(jsonString)
     );
-    const kid = options?.kid || options?.keyId || this._configuredKid;
+    const kid = options?.kid || options?.keyId || this.activeKid || this._configuredKid;
     return {
       __encrypted: true,
       ciphertext: CKeyManager.toBase64(ciphertextBuffer),
@@ -3127,12 +4030,26 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
   _cachedHash;
   _cachedKeyId;
   _configuredKid;
+  _keyringCache = /* @__PURE__ */ new Map();
+  isKeyRetained(key) {
+    if (key === this._cachedKey) return true;
+    for (const entry of this._keyringCache.values()) {
+      if (entry.key === key) return true;
+    }
+    return false;
+  }
   setDefaultKey(key) {
     super.setDefaultKey(key);
     if (this._cachedKey) {
       this._cachedKey.fill(0);
       this._cachedKey = void 0;
     }
+    for (const entry of this._keyringCache.values()) {
+      if (entry.key !== this._cachedKey) {
+        entry.key.fill(0);
+      }
+    }
+    this._keyringCache.clear();
     this._cachedSalt = void 0;
     this._cachedKdf = void 0;
     this._cachedIter = void 0;
@@ -3145,6 +4062,12 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
       this._cachedKey.fill(0);
       this._cachedKey = void 0;
     }
+    for (const entry of this._keyringCache.values()) {
+      if (entry.key !== this._cachedKey) {
+        entry.key.fill(0);
+      }
+    }
+    this._keyringCache.clear();
     this._cachedSalt = void 0;
     this._cachedKdf = void 0;
     this._cachedIter = void 0;
@@ -3152,6 +4075,29 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
     this._cachedKeyId = void 0;
   }
   async warmupKey(options) {
+    const effectiveKeys = options?.keys || this.keys;
+    if (effectiveKeys && Object.keys(effectiveKeys).length > 0) {
+      const promises = Object.entries(effectiveKeys).map(async ([kid, keyProv]) => {
+        const res2 = await this.deriveKeyAsync(keyProv, void 0, void 0, { ...options, key: keyProv, kid });
+        const raw = await this.resolveRawKeyAsync(keyProv);
+        const keyId = getSafeKeyIdentifier(raw);
+        this._keyringCache.set(keyId, res2);
+        this._keyringCache.set(`kid:${kid}`, res2);
+        return { kid, res: res2 };
+      });
+      const results = await Promise.all(promises);
+      const effectiveActiveKid = options?.activeKid || this.activeKid;
+      const primary = effectiveActiveKid && results.find((r) => r.kid === effectiveActiveKid)?.res || results[0]?.res;
+      if (primary) {
+        this._cachedKey = primary.key;
+        this._cachedSalt = primary.salt;
+        this._cachedKdf = primary.kdf;
+        this._cachedIter = primary.iter;
+        this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
+        this._cachedKeyId = getSafeKeyIdentifier(await this.resolveRawKeyAsync(options?.key));
+      }
+      return;
+    }
     const res = await this.deriveKeyAsync(options?.key, void 0, void 0, options);
     if (!options?.key) {
       this._cachedKey = res.key;
@@ -3166,6 +4112,30 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
    * Synchronously pre-derives and caches the encryption key for subsequent synchronous operations.
    */
   warmupKeySync(options) {
+    const effectiveKeys = options?.keys || this.keys;
+    if (effectiveKeys && Object.keys(effectiveKeys).length > 0) {
+      const entries = Object.entries(effectiveKeys);
+      const results = [];
+      for (const [kid, keyProv] of entries) {
+        const res2 = this.deriveKeySync(keyProv, void 0, void 0, { ...options, key: keyProv, kid });
+        const raw = this.resolveRawKeySync(keyProv);
+        const keyId = getSafeKeyIdentifier(raw);
+        this._keyringCache.set(keyId, res2);
+        this._keyringCache.set(`kid:${kid}`, res2);
+        results.push({ kid, res: res2 });
+      }
+      const effectiveActiveKid = options?.activeKid || this.activeKid;
+      const primary = effectiveActiveKid && results.find((r) => r.kid === effectiveActiveKid)?.res || results[0]?.res;
+      if (primary) {
+        this._cachedKey = primary.key;
+        this._cachedSalt = primary.salt;
+        this._cachedKdf = primary.kdf;
+        this._cachedIter = primary.iter;
+        this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
+        this._cachedKeyId = getSafeKeyIdentifier(this.resolveRawKeySync(options?.key));
+      }
+      return;
+    }
     const res = this.deriveKeySync(options?.key, void 0, void 0, options);
     if (!options?.key) {
       this._cachedKey = res.key;
@@ -3184,7 +4154,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
     return Buffer.from(infoRaw);
   }
   constructor(key, options) {
-    super(key);
+    super(key, options);
     if (options) {
       if (options.kid || options.keyId) {
         this._configuredKid = options.kid || options.keyId;
@@ -3202,7 +4172,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
     }
   }
   resolveRawKeySync(keyProvider) {
-    const target = keyProvider || this.defaultKey;
+    const target = keyProvider || (this.activeKid && this.keys ? this.keys[this.activeKid] : void 0) || this.defaultKey;
     if (!target) {
       throw new Error("[CNodeCryptoEncryptionProvider] No encryption key or keyProvider was supplied.");
     }
@@ -3232,7 +4202,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
     return rawKey;
   }
   async resolveRawKeyAsync(keyProvider) {
-    const target = keyProvider || this.defaultKey;
+    const target = keyProvider || (this.activeKid && this.keys ? this.keys[this.activeKid] : void 0) || this.defaultKey;
     if (!target) {
       throw new Error("[CNodeCryptoEncryptionProvider] No encryption key or keyProvider was supplied.");
     }
@@ -3263,15 +4233,16 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
     const currentKeyId = getSafeKeyIdentifier(raw);
     if (Buffer.isBuffer(raw)) {
       if (raw.length === 32) {
-        if (!keyProvider) {
-          if (!this._cachedKey || this._cachedKeyId !== currentKeyId) {
-            this._cachedKey = Buffer.from(raw);
-            this._cachedKdf = "raw";
-            this._cachedKeyId = currentKeyId;
-          }
-          return { key: this._cachedKey, kdf: "raw" };
+        const cached = this._keyringCache.get(currentKeyId);
+        if (cached) return cached;
+        const res2 = { key: Buffer.from(raw), kdf: "raw" };
+        this._keyringCache.set(currentKeyId, res2);
+        if (!keyProvider || keyProvider === this.defaultKey) {
+          this._cachedKey = res2.key;
+          this._cachedKdf = "raw";
+          this._cachedKeyId = currentKeyId;
         }
-        return { key: Buffer.from(raw), kdf: "raw" };
+        return res2;
       }
       throw new Error(
         `[CNodeCryptoEncryptionProvider] AES-GCM-256 requires a 32-byte key. Received a Buffer of ${raw.length} bytes. Provide exactly 32 bytes or a string passphrase.`
@@ -3290,6 +4261,16 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
         return { key: this._cachedKey, salt: this._cachedSalt, kdf: this._cachedKdf, iter: this._cachedIter };
       }
     }
+    if (!saltOverride && !options?.kdfSalt) {
+      const cached = this._keyringCache.get(currentKeyId);
+      if (cached) {
+        const cMatchesKdf = !cached.kdf || cached.kdf.toLowerCase() === kdf;
+        const cMatchesIter = !targetIter || cached.iter === targetIter;
+        if (cMatchesKdf && cMatchesIter) {
+          return cached;
+        }
+      }
+    }
     if (kdf === "pbkdf2") {
       const s = saltOverride || options?.kdfSalt || this._kdfOptions?.salt;
       const saltBytes = CKeyManager.resolveSalt(s);
@@ -3298,20 +4279,24 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
       const iterations = Math.min(Math.max(rawIter, 1e3), 6e5);
       const hash = (options?.kdfHash || this._kdfOptions?.hash || "SHA-256").toLowerCase().replace("-", "");
       const key2 = crypto__namespace.pbkdf2Sync(passphrase, saltBuf, iterations, 32, hash);
-      if (!keyProvider && !saltOverride && !options?.kdfSalt) {
-        this._cachedKey = key2;
-        this._cachedSalt = saltBuf.toString("base64");
-        this._cachedKdf = "PBKDF2";
-        this._cachedIter = iterations;
-        this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
-        this._cachedKeyId = currentKeyId;
-      }
-      return {
+      const res2 = {
         key: key2,
         salt: saltBuf.toString("base64"),
         kdf: "PBKDF2",
         iter: iterations
       };
+      if (!saltOverride && !options?.kdfSalt) {
+        this._keyringCache.set(currentKeyId, res2);
+        if (!keyProvider || keyProvider === this.defaultKey) {
+          this._cachedKey = key2;
+          this._cachedSalt = saltBuf.toString("base64");
+          this._cachedKdf = "PBKDF2";
+          this._cachedIter = iterations;
+          this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
+          this._cachedKeyId = currentKeyId;
+        }
+      }
+      return res2;
     }
     if (kdf === "hkdf") {
       if (typeof raw === "string") {
@@ -3325,49 +4310,56 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
       const hash = (options?.kdfHash || this._kdfOptions?.hash || "SHA-256").toLowerCase().replace("-", "");
       const info = this.resolveInfoBuffer(options?.info || this._kdfOptions?.info);
       const key2 = Buffer.from(crypto__namespace.hkdfSync(hash, passphrase, saltBuf, info, 32));
-      if (!keyProvider && !saltOverride && !options?.kdfSalt) {
-        this._cachedKey = key2;
-        this._cachedSalt = saltBuf.toString("base64");
-        this._cachedKdf = "HKDF";
-        this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
-        this._cachedKeyId = currentKeyId;
-      }
-      return {
+      const res2 = {
         key: key2,
         salt: saltBuf.toString("base64"),
         kdf: "HKDF"
       };
+      if (!saltOverride && !options?.kdfSalt) {
+        this._keyringCache.set(currentKeyId, res2);
+        if (!keyProvider || keyProvider === this.defaultKey) {
+          this._cachedKey = key2;
+          this._cachedSalt = saltBuf.toString("base64");
+          this._cachedKdf = "HKDF";
+          this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
+          this._cachedKeyId = currentKeyId;
+        }
+      }
+      return res2;
     }
     if (kdf === "none") {
       console.warn(
         "[CNodeCryptoEncryptionProvider] WARNING: Decrypting a legacy envelope with no KDF (raw SHA-256 key derivation). This is cryptographically weak. Migrate to pbkdf2 or hkdf."
       );
     }
-    if (!keyProvider && this._cachedKey && this._cachedKdf === "none" && this._cachedKeyId === currentKeyId) {
+    if ((!keyProvider || keyProvider === this.defaultKey) && this._cachedKey && this._cachedKdf === "none" && this._cachedKeyId === currentKeyId) {
       return { key: this._cachedKey, kdf: "none" };
     }
     const key = crypto__namespace.createHash("sha256").update(passphrase, "utf8").digest();
-    if (!keyProvider) {
+    const res = { key, kdf: "none" };
+    this._keyringCache.set(currentKeyId, res);
+    if (!keyProvider || keyProvider === this.defaultKey) {
       this._cachedKey = key;
       this._cachedKdf = "none";
       this._cachedKeyId = currentKeyId;
     }
-    return { key, kdf: "none" };
+    return res;
   }
   async deriveKeyAsync(keyProvider, kdfOverride, saltOverride, options, iterationsOverride) {
     const raw = await this.resolveRawKeyAsync(keyProvider);
     const currentKeyId = getSafeKeyIdentifier(raw);
     if (Buffer.isBuffer(raw)) {
       if (raw.length === 32) {
-        if (!keyProvider) {
-          if (!this._cachedKey || this._cachedKeyId !== currentKeyId) {
-            this._cachedKey = Buffer.from(raw);
-            this._cachedKdf = "raw";
-            this._cachedKeyId = currentKeyId;
-          }
-          return { key: this._cachedKey, kdf: "raw" };
+        const cached = this._keyringCache.get(currentKeyId);
+        if (cached) return cached;
+        const res2 = { key: Buffer.from(raw), kdf: "raw" };
+        this._keyringCache.set(currentKeyId, res2);
+        if (!keyProvider || keyProvider === this.defaultKey) {
+          this._cachedKey = res2.key;
+          this._cachedKdf = "raw";
+          this._cachedKeyId = currentKeyId;
         }
-        return { key: Buffer.from(raw), kdf: "raw" };
+        return res2;
       }
       throw new Error(
         `[CNodeCryptoEncryptionProvider] AES-GCM-256 requires a 32-byte key. Received a Buffer of ${raw.length} bytes. Provide exactly 32 bytes or a string passphrase.`
@@ -3386,6 +4378,16 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
         return { key: this._cachedKey, salt: this._cachedSalt, kdf: this._cachedKdf, iter: this._cachedIter };
       }
     }
+    if (!saltOverride && !options?.kdfSalt) {
+      const cached = this._keyringCache.get(currentKeyId);
+      if (cached) {
+        const cMatchesKdf = !cached.kdf || cached.kdf.toLowerCase() === kdf;
+        const cMatchesIter = !targetIter || cached.iter === targetIter;
+        if (cMatchesKdf && cMatchesIter) {
+          return cached;
+        }
+      }
+    }
     if (kdf === "pbkdf2") {
       const s = saltOverride || options?.kdfSalt || this._kdfOptions?.salt;
       const saltBytes = CKeyManager.resolveSalt(s);
@@ -3399,20 +4401,24 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
           else resolve(derived);
         });
       });
-      if (!keyProvider && !saltOverride && !options?.kdfSalt) {
-        this._cachedKey = key2;
-        this._cachedSalt = saltBuf.toString("base64");
-        this._cachedKdf = "PBKDF2";
-        this._cachedIter = iterations;
-        this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
-        this._cachedKeyId = currentKeyId;
-      }
-      return {
+      const res2 = {
         key: key2,
         salt: saltBuf.toString("base64"),
         kdf: "PBKDF2",
         iter: iterations
       };
+      if (!saltOverride && !options?.kdfSalt) {
+        this._keyringCache.set(currentKeyId, res2);
+        if (!keyProvider || keyProvider === this.defaultKey) {
+          this._cachedKey = key2;
+          this._cachedSalt = saltBuf.toString("base64");
+          this._cachedKdf = "PBKDF2";
+          this._cachedIter = iterations;
+          this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
+          this._cachedKeyId = currentKeyId;
+        }
+      }
+      return res2;
     }
     if (kdf === "hkdf") {
       if (typeof raw === "string") {
@@ -3431,34 +4437,40 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
           else resolve(Buffer.from(derived));
         });
       });
-      if (!keyProvider && !saltOverride && !options?.kdfSalt) {
-        this._cachedKey = key2;
-        this._cachedSalt = saltBuf.toString("base64");
-        this._cachedKdf = "HKDF";
-        this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
-        this._cachedKeyId = currentKeyId;
-      }
-      return {
+      const res2 = {
         key: key2,
         salt: saltBuf.toString("base64"),
         kdf: "HKDF"
       };
+      if (!saltOverride && !options?.kdfSalt) {
+        this._keyringCache.set(currentKeyId, res2);
+        if (!keyProvider || keyProvider === this.defaultKey) {
+          this._cachedKey = key2;
+          this._cachedSalt = saltBuf.toString("base64");
+          this._cachedKdf = "HKDF";
+          this._cachedHash = options?.kdfHash || this._kdfOptions?.hash || "SHA-256";
+          this._cachedKeyId = currentKeyId;
+        }
+      }
+      return res2;
     }
     if (kdf === "none") {
       console.warn(
         "[CNodeCryptoEncryptionProvider] WARNING: Decrypting a legacy envelope with no KDF (raw SHA-256 key derivation). This is cryptographically weak. Migrate to pbkdf2 or hkdf."
       );
     }
-    if (!keyProvider && this._cachedKey && this._cachedKdf === "none" && this._cachedKeyId === currentKeyId) {
+    if ((!keyProvider || keyProvider === this.defaultKey) && this._cachedKey && this._cachedKdf === "none" && this._cachedKeyId === currentKeyId) {
       return { key: this._cachedKey, kdf: "none" };
     }
     const key = crypto__namespace.createHash("sha256").update(passphrase, "utf8").digest();
-    if (!keyProvider) {
+    const res = { key, kdf: "none" };
+    this._keyringCache.set(currentKeyId, res);
+    if (!keyProvider || keyProvider === this.defaultKey) {
       this._cachedKey = key;
       this._cachedKdf = "none";
       this._cachedKeyId = currentKeyId;
     }
-    return { key, kdf: "none" };
+    return res;
   }
   static isEncrypted(payload) {
     if (!payload || typeof payload !== "object") return false;
@@ -3498,7 +4510,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
       ]);
       const authTag = cipher.getAuthTag();
       const combinedCiphertext = Buffer.concat([encryptedBuffer, authTag]);
-      const kid = options?.kid || options?.keyId || this._configuredKid;
+      const kid = options?.kid || options?.keyId || this.activeKid || this._configuredKid;
       return {
         __encrypted: true,
         ciphertext: combinedCiphertext.toString("base64"),
@@ -3511,7 +4523,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
         ...hasAad ? { aad: true } : {}
       };
     } finally {
-      if (key !== this._cachedKey) {
+      if (!this.isKeyRetained(key)) {
         key.fill(0);
       }
     }
@@ -3600,7 +4612,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
       if (err instanceof SyntaxError) throw err;
       throw new Error(`[CNodeCryptoEncryptionProvider] Decryption failed: ${err?.message || "Authentication tag mismatch or corrupted ciphertext"}`);
     } finally {
-      if (key !== this._cachedKey) {
+      if (!this.isKeyRetained(key)) {
         key.fill(0);
       }
     }
@@ -3609,6 +4621,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
   encryptSync(data, options) {
     if (data === void 0 || data === null) return data;
     if (this.isEncrypted(data)) return data;
+    options = this._resolveOutboundKeyringOptions(options);
     if (Array.isArray(data)) {
       if (options?.fields && options.fields.length > 0 || options?.valueEncryption === true) {
         return data.map((item) => this.encryptSync(item, options));
@@ -3644,7 +4657,12 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
   decryptSync(payload, options) {
     if (payload === void 0 || payload === null) return payload;
     if (this.isEncrypted(payload)) {
-      return this.decryptValueSync(payload, options);
+      const metaErr = this._validateEnvelopeMetadata(payload, options);
+      if (metaErr) {
+        return this._handleDecryptError(metaErr, payload, "", payload, void 0, options);
+      }
+      const envelopeKey = this._resolveDecryptionKeyForEnvelope(payload, options);
+      return this.decryptValueSync(payload, { ...options, key: envelopeKey });
     }
     if (Array.isArray(payload)) {
       return payload.map((item) => this.decryptSync(item, options));
@@ -3658,28 +4676,35 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
         for (const key of targetKeys) {
           if (this.isEncrypted(result[key])) {
             const fieldPayload = result[key];
+            const metaErr = this._validateEnvelopeMetadata(fieldPayload, options);
+            if (metaErr) {
+              return this._handleDecryptError(metaErr, result, key, fieldPayload, void 0, options);
+            }
+            const envelopeKey = this._resolveDecryptionKeyForEnvelope(fieldPayload, options);
             const salt = fieldPayload.salt || "__no_salt__";
-            let derivedKey = keyCache.get(salt);
+            const memoKey = `${salt}:${fieldPayload.kid || ""}`;
+            let derivedKey = keyCache.get(memoKey);
             if (!derivedKey) {
               const kdfFromEnvelope = fieldPayload.kdf ? fieldPayload.kdf.toLowerCase() : "none";
               const derived = this.deriveKeySync(
-                options?.key,
+                envelopeKey,
                 kdfFromEnvelope,
                 fieldPayload.salt,
                 options,
                 fieldPayload.iter
               );
               derivedKey = derived.key;
-              keyCache.set(salt, derivedKey);
+              keyCache.set(memoKey, derivedKey);
             }
-            const boundOptions = this._bindFieldAad(payload, key, options);
+            const boundOptions = this._bindFieldAad(payload, key, { ...options, key: envelopeKey });
             const hasBoundAad = boundOptions.aad !== options?.aad;
             try {
               safeSetProperty(result, key, this.decryptCiphertextWithKey(fieldPayload, derivedKey, boundOptions));
             } catch (err) {
-              if (hasBoundAad && isAuthOrDecryptionError(err)) {
+              const canFallback = hasBoundAad && (!options?.aadFields || options.aadFields.length === 0) && typeof options?.aad !== "function";
+              if (canFallback && isAuthOrDecryptionError(err)) {
                 try {
-                  safeSetProperty(result, key, this.decryptCiphertextWithKey(fieldPayload, derivedKey, options));
+                  safeSetProperty(result, key, this.decryptCiphertextWithKey(fieldPayload, derivedKey, { ...options, key: envelopeKey }));
                 } catch (fallbackErr) {
                   throw fallbackErr;
                 }
@@ -3693,7 +4718,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
         return mutated ? result : payload;
       } finally {
         for (const k of keyCache.values()) {
-          if (k !== this._cachedKey) {
+          if (!this.isKeyRetained(k)) {
             k.fill(0);
           }
         }
@@ -3741,7 +4766,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
       ]);
       const authTag = cipher.getAuthTag();
       const combined = Buffer.concat([ciphertext, authTag]);
-      const kid = options?.kid || options?.keyId || this._configuredKid;
+      const kid = options?.kid || options?.keyId || this.activeKid || this._configuredKid;
       return {
         __encrypted: true,
         ciphertext: combined.toString("base64"),
@@ -3754,7 +4779,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
         ...hasAad ? { aad: true } : {}
       };
     } finally {
-      if (key !== this._cachedKey) {
+      if (!this.isKeyRetained(key)) {
         key.fill(0);
       }
     }
@@ -3778,7 +4803,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
       if (err instanceof SyntaxError) throw err;
       throw new Error(`[CNodeCryptoEncryptionProvider] Decryption failed: ${err?.message || "Authentication tag mismatch or corrupted ciphertext"}`);
     } finally {
-      if (key !== this._cachedKey) {
+      if (!this.isKeyRetained(key)) {
         key.fill(0);
       }
     }
@@ -3786,7 +4811,12 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
   async decrypt(payload, options) {
     if (payload === void 0 || payload === null) return payload;
     if (this.isEncrypted(payload)) {
-      return this.decryptValue(payload, options);
+      const metaErr = this._validateEnvelopeMetadata(payload, options);
+      if (metaErr) {
+        return this._handleDecryptError(metaErr, payload, "", payload, void 0, options);
+      }
+      const envelopeKey = this._resolveDecryptionKeyForEnvelope(payload, options);
+      return this.decryptValue(payload, { ...options, key: envelopeKey });
     }
     if (Array.isArray(payload)) {
       return Promise.all(payload.map((item) => this.decrypt(item, options)));
@@ -3800,28 +4830,35 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
         for (const key of targetKeys) {
           if (this.isEncrypted(result[key])) {
             const fieldPayload = result[key];
+            const metaErr = this._validateEnvelopeMetadata(fieldPayload, options);
+            if (metaErr) {
+              return this._handleDecryptError(metaErr, result, key, fieldPayload, void 0, options);
+            }
+            const envelopeKey = this._resolveDecryptionKeyForEnvelope(fieldPayload, options);
             const salt = fieldPayload.salt || "__no_salt__";
-            let derivedKey = keyCache.get(salt);
+            const memoKey = `${salt}:${fieldPayload.kid || ""}`;
+            let derivedKey = keyCache.get(memoKey);
             if (!derivedKey) {
               const kdfFromEnvelope = fieldPayload.kdf ? fieldPayload.kdf.toLowerCase() : "none";
               const derived = await this.deriveKeyAsync(
-                options?.key,
+                envelopeKey,
                 kdfFromEnvelope,
                 fieldPayload.salt ? CKeyManager.fromBase64(fieldPayload.salt) : void 0,
                 options,
                 fieldPayload.iter
               );
               derivedKey = derived.key;
-              keyCache.set(salt, derivedKey);
+              keyCache.set(memoKey, derivedKey);
             }
-            const boundOptions = this._bindFieldAad(payload, key, options);
+            const boundOptions = this._bindFieldAad(payload, key, { ...options, key: envelopeKey });
             const hasBoundAad = boundOptions.aad !== options?.aad;
             try {
               safeSetProperty(result, key, this.decryptCiphertextWithKey(fieldPayload, derivedKey, boundOptions));
             } catch (err) {
-              if (hasBoundAad && isAuthOrDecryptionError(err)) {
+              const canFallback = hasBoundAad && (!options?.aadFields || options.aadFields.length === 0) && typeof options?.aad !== "function";
+              if (canFallback && isAuthOrDecryptionError(err)) {
                 try {
-                  safeSetProperty(result, key, this.decryptCiphertextWithKey(fieldPayload, derivedKey, options));
+                  safeSetProperty(result, key, this.decryptCiphertextWithKey(fieldPayload, derivedKey, { ...options, key: envelopeKey }));
                 } catch (fallbackErr) {
                   throw fallbackErr;
                 }
@@ -3835,7 +4872,7 @@ class CNodeCryptoEncryptionProvider extends AEncryptionProvider {
         return mutated ? result : payload;
       } finally {
         for (const k of keyCache.values()) {
-          if (k !== this._cachedKey) {
+          if (!this.isKeyRetained(k)) {
             k.fill(0);
           }
         }
@@ -3866,7 +4903,11 @@ function createEncryptionProvider(options = {}) {
       kdfIterations: options.kdfIterations,
       kdfHash: options.kdfHash,
       kdfSalt: options.kdfSalt,
-      info: options.info
+      info: options.info,
+      kid: options.kid || options.keyId,
+      keys: options.keys,
+      activeKid: options.activeKid,
+      allowedKids: options.allowedKids
     });
   }
   if (alg === "AES-CBC") {
@@ -3903,7 +4944,11 @@ function createEncryptionProvider(options = {}) {
       kdfIterations: options.kdfIterations,
       kdfHash: options.kdfHash,
       kdfSalt: options.kdfSalt,
-      info: options.info
+      info: options.info,
+      kid: options.kid || options.keyId,
+      keys: options.keys,
+      activeKid: options.activeKid,
+      allowedKids: options.allowedKids
     });
   }
   throw new Error(
@@ -3966,7 +5011,19 @@ function isDataEncrypted(provider, data) {
 function buildEncryptionContext(encryption, url, _defaultIdKey) {
   return {
     url,
+    aad: encryption?.aad,
+    aadFields: encryption?.aadFields,
+    baseAad: encryption?.baseAad,
+    bindRequestContextAad: encryption?.bindRequestContextAad,
+    strict: encryption?.strict,
+    allowedAlgorithms: encryption?.allowedAlgorithms,
+    allowedKids: encryption?.allowedKids,
+    onDecryptError: encryption?.onDecryptError,
     key: encryption?.key,
+    kid: encryption?.kid,
+    keyId: encryption?.keyId,
+    keys: encryption?.keys,
+    activeKid: encryption?.activeKid,
     valueEncryption: encryption?.valueEncryption,
     fields: encryption?.fields,
     publicKey: encryption?.publicKey,
@@ -3997,7 +5054,7 @@ async function decryptPageRows(rows, encryption, apiUrl, idKey) {
     }
     return isDataEncrypted(cipherProvider, row);
   });
-  if (!hasEncryptedRows) {
+  if (!hasEncryptedRows && !encryption?.strict) {
     return { rows, decrypted: false };
   }
   const ctx = buildEncryptionContext(encryption, apiUrl);
@@ -4160,6 +5217,13 @@ class CSearchIndex {
     const signature = await subtle.sign("HMAC", key, textEncoder.encode(normalized));
     return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
   }
+  /**
+   * Computes a deterministic HMAC-SHA256 blind index hash for a term using the configured HMAC key.
+   * Performs Unicode NFKC normalization, trimming, and lowercasing.
+   */
+  async computeBlindIndex(term) {
+    return this.computeToken(term);
+  }
   /**
    * Computes HMAC-SHA256 tokens for all trigrams of a term.
    */
@@ -4189,9 +5253,21 @@ class CSearchIndex {
         const token = await this.computeToken(rawVal);
         const trigrams = await this.computeTrigramTokens(rawVal);
         fieldMap.set(field, { token, trigrams });
+      } else if (rawVal && typeof rawVal === "object" && rawVal.__encrypted === true) {
+        const precomputedToken = row[`${field}_bidx`] || row[`${field}_token`];
+        if (typeof precomputedToken === "string" && precomputedToken) {
+          fieldMap.set(field, { token: precomputedToken, trigrams: /* @__PURE__ */ new Set() });
+        }
       }
     }
   }
+  /**
+   * Indexes a row using pre-decrypted plaintext field values.
+   * Allows indexing rows that contain pre-encrypted ciphertext envelopes in allData.
+   */
+  async indexRowDecrypted(row, decryptedPlaintext) {
+    return this.indexRow(row, decryptedPlaintext);
+  }
   /**
    * Indexes an array of rows.
    */
@@ -4240,7 +5316,7 @@ class CSearchIndex {
       }
       return true;
     }
-    if (operator === EDataFilterOperator.NotIn || operator === "notIn") {
+    if (operator === EDataFilterOperator.NotIn || operator === "notIn" || operator === "nin") {
       const queryTrigramTokens = await this.computeTrigramTokens(filterValue);
       if (queryTrigramTokens.size === 0) return false;
       for (const tok of queryTrigramTokens) {
@@ -4311,7 +5387,7 @@ class CSearchIndex {
             }
             return true;
           });
-        } else if (op === EDataFilterOperator.NotIn || op === "notIn") {
+        } else if (op === EDataFilterOperator.NotIn || op === "notIn" || op === "nin") {
           const queryTrigrams = await this.computeTrigramTokens(filterValue);
           checks.push((row) => {
             const entry = this.getEntry(row, key);
@@ -4430,6 +5506,36 @@ class AEncryptedClientProvider extends ADataProvider {
     } : void 0;
     return await encryptRowsChunked(rows, this.encryption, options, void 0, this.idKey, indexChunk);
   }
+  /**
+   * Indexes pre-encrypted rows by performing a transient in-memory decryption pass
+   * on search fields to populate CSearchIndex without mutating underlying encrypted records in allData.
+   */
+  async indexPreEncryptedRows(rows) {
+    if (!this.isEncryptionEnabled || !this._searchIndex || !rows || rows.length === 0) {
+      return;
+    }
+    const cipher = getCipherProvider(this.encryption);
+    if (!cipher) return;
+    const ctx = buildEncryptionContext(this.encryption, this.apiUrl, this.idKey);
+    let decryptedRows = [];
+    try {
+      const decResult = await cipher.decrypt(rows, ctx);
+      decryptedRows = Array.isArray(decResult) ? decResult : [decResult];
+    } catch (err) {
+      console.warn("[Katlux Providers] indexPreEncryptedRows: Decryption failed during search index build", err);
+      return;
+    }
+    await Promise.all(rows.map((row, idx) => {
+      const decRow = decryptedRows[idx];
+      const plainFields = {};
+      for (const f of this.encryption?.fields || Object.keys(decRow || {})) {
+        if (decRow && decRow[f] !== void 0) {
+          plainFields[f] = decRow[f];
+        }
+      }
+      return this._searchIndex.indexRow(row, plainFields);
+    }));
+  }
   async decryptRows(rows) {
     if (!this.isEncryptionEnabled || !rows || rows.length === 0) {
       return { rows, decrypted: false };
@@ -4738,6 +5844,15 @@ class CFlatClientDataProvider extends AEncryptedClientProvider {
     this.loading = true;
     try {
       const rows = Array.isArray(data) ? data : [];
+      const isPreEnc = this.encryption?.preEncrypted ?? isDataEncrypted(void 0, rows);
+      if (isPreEnc) {
+        this.allData = rows;
+        if (this.searchIndex) {
+          await this.indexPreEncryptedRows(rows);
+        }
+        await this.loadPageData();
+        return;
+      }
       const encryptedRows = await this.encryptRows(rows);
       this.allData = encryptedRows;
       await this.loadPageData();
@@ -4758,6 +5873,16 @@ class CFlatClientDataProvider extends AEncryptedClientProvider {
     this.loading = true;
     try {
       const rows = Array.isArray(data) ? data : [];
+      const isPreEnc = this.encryption?.preEncrypted ?? isDataEncrypted(void 0, rows);
+      if (isPreEnc) {
+        this.allData = rows;
+        if (this.searchIndex) {
+          await this.indexPreEncryptedRows(rows);
+        }
+        options?.onProgress?.({ processed: rows.length, total: rows.length, percent: 100 });
+        await this.loadPageData();
+        return;
+      }
       const encryptedRows = await this.encryptRowsChunked(rows, options);
       this.allData = encryptedRows;
       await this.loadPageData();
@@ -6704,8 +7829,18 @@ class RequestProvider {
       method,
       isServer,
       aad: encOptions.aad,
+      aadFields: encOptions.aadFields,
+      baseAad: encOptions.baseAad,
       bindRequestContextAad: encOptions.bindRequestContextAad,
+      strict: encOptions.strict,
+      allowedAlgorithms: encOptions.allowedAlgorithms,
+      allowedKids: encOptions.allowedKids,
+      onDecryptError: encOptions.onDecryptError,
       key: encOptions.key,
+      kid: encOptions.kid,
+      keyId: encOptions.keyId,
+      keys: encOptions.keys,
+      activeKid: encOptions.activeKid,
       valueEncryption: encOptions.valueEncryption,
       fields: encOptions.fields,
       publicKey: encOptions.publicKey,
@@ -6894,17 +8029,26 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
       if (data) {
         const normalized = normalizeDataResult(data);
         const rows = normalized ? normalized.rows : data.rows || data;
+        const incomingRows = Array.isArray(rows) ? rows : [];
         if (this._isAccumulating) {
-          this.allData = [...this.allData, ...rows];
+          this.allData = [...this.allData, ...incomingRows];
         } else {
-          this.allData = Array.isArray(rows) ? rows : [];
+          this.allData = incomingRows;
         }
         this._filterDirty = true;
         this._sortDirty = true;
         if (normalized?.rowCount !== void 0) {
           this.rowCount = normalized.rowCount;
         }
-        this._lastDataReceivedPromise = this.loadPageData();
+        this._lastDataReceivedPromise = (async () => {
+          if (this.isEncryptionEnabled && this.searchIndex && incomingRows.length > 0) {
+            const isPreEnc = this.encryption?.preEncrypted ?? isDataEncrypted(void 0, incomingRows);
+            if (isPreEnc) {
+              await this.indexPreEncryptedRows(incomingRows);
+            }
+          }
+          await this.loadPageData();
+        })();
       }
     });
   }
@@ -6990,6 +8134,12 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
           this.allData = normalized.rows;
           this._filterDirty = true;
           this._sortDirty = true;
+          if (this.isEncryptionEnabled && this.searchIndex && this.allData.length > 0) {
+            const isPreEnc = this.encryption?.preEncrypted ?? isDataEncrypted(void 0, this.allData);
+            if (isPreEnc) {
+              await this.indexPreEncryptedRows(this.allData);
+            }
+          }
           await this.loadPageData();
           this.initialLoad = false;
           this.loading = false;
@@ -10244,6 +11394,7 @@ exports.CTreeServerDataProvider = CTreeServerDataProvider;
 exports.CWebCryptoAESCBCProvider = CWebCryptoAESCBCProvider;
 exports.CWebCryptoEncryptionProvider = CWebCryptoEncryptionProvider;
 exports.CacheProviderFactory = CacheProviderFactory;
+exports.DECRYPT_ERROR_SENTINEL = DECRYPT_ERROR_SENTINEL;
 exports.DefaultHydrationAdapter = DefaultHydrationAdapter;
 exports.ECacheStrategy = ECacheStrategy;
 exports.EDataFilterOperator = EDataFilterOperator;
@@ -10256,6 +11407,7 @@ exports.RequestQueue = RequestQueue;
 exports.SENSITIVE_HEADER_KEYS = SENSITIVE_HEADER_KEYS;
 exports.applyOperator = applyOperator;
 exports.buildEncryptionContext = buildEncryptionContext;
+exports.canonicalizeJson = canonicalizeJson;
 exports.clearCachedCipherProvider = clearCachedCipherProvider;
 exports.clearSSRData = clearSSRData;
 exports.compareAnd = compareAnd;