@korajs/auth 0.1.0 → 0.3.0

package/dist/chunk-FSU4SK32.js

@@ -0,0 +1,786 @@
+// src/device/device-identity.ts
+import { KoraError } from "@korajs/core";
+var CryptoUnavailableError = class extends KoraError {
+  constructor() {
+    super(
+      "Web Crypto API (crypto.subtle) is not available in this environment. Device identity requires crypto.subtle, which is available in modern browsers and Node.js 20+. If running in SSR, ensure your runtime provides the Web Crypto API.",
+      "CRYPTO_UNAVAILABLE"
+    );
+    this.name = "CryptoUnavailableError";
+  }
+};
+var DeviceIdentityError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "DEVICE_IDENTITY_ERROR", context);
+    this.name = "DeviceIdentityError";
+  }
+};
+function toBase64Url(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const paddingNeeded = (4 - base64.length % 4) % 4;
+  base64 += "=".repeat(paddingNeeded);
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function assertCryptoAvailable() {
+  if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle === "undefined") {
+    throw new CryptoUnavailableError();
+  }
+}
+var ECDSA_ALGORITHM = {
+  name: "ECDSA",
+  namedCurve: "P-256"
+};
+var ECDSA_SIGN_ALGORITHM = {
+  name: "ECDSA",
+  hash: { name: "SHA-256" }
+};
+async function generateDeviceKeyPair() {
+  assertCryptoAvailable();
+  try {
+    const keyPair = await globalThis.crypto.subtle.generateKey(
+      ECDSA_ALGORITHM,
+      // extractable: false makes the private key non-extractable.
+      // The public key is always extractable regardless of this flag.
+      false,
+      ["sign", "verify"]
+    );
+    return keyPair;
+  } catch (cause) {
+    throw new DeviceIdentityError(
+      "Failed to generate ECDSA P-256 device key pair. Ensure the runtime supports the ECDSA algorithm with the P-256 curve.",
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+async function exportPublicKeyJwk(keyPair) {
+  assertCryptoAvailable();
+  try {
+    const jwk = await globalThis.crypto.subtle.exportKey("jwk", keyPair.publicKey);
+    return jwk;
+  } catch (cause) {
+    throw new DeviceIdentityError(
+      "Failed to export public key as JWK. The key pair may be invalid or the public key may not support JWK export.",
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+async function signChallenge(privateKey, challenge) {
+  assertCryptoAvailable();
+  try {
+    const encoded = new TextEncoder().encode(challenge);
+    const signatureBuffer = await globalThis.crypto.subtle.sign(
+      ECDSA_SIGN_ALGORITHM,
+      privateKey,
+      encoded
+    );
+    return toBase64Url(signatureBuffer);
+  } catch (cause) {
+    throw new DeviceIdentityError(
+      'Failed to sign challenge. Ensure the key is a valid ECDSA P-256 private key with "sign" usage.',
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+async function verifyChallenge(publicKeyJwk, challenge, signature) {
+  assertCryptoAvailable();
+  try {
+    const publicKey = await globalThis.crypto.subtle.importKey(
+      "jwk",
+      publicKeyJwk,
+      ECDSA_ALGORITHM,
+      true,
+      ["verify"]
+    );
+    const encoded = new TextEncoder().encode(challenge);
+    const signatureBytes = fromBase64Url(signature);
+    const isValid = await globalThis.crypto.subtle.verify(
+      ECDSA_SIGN_ALGORITHM,
+      publicKey,
+      signatureBytes,
+      encoded
+    );
+    return isValid;
+  } catch (cause) {
+    throw new DeviceIdentityError(
+      "Failed to verify challenge signature. The public key JWK or signature format may be invalid.",
+      {
+        cause: cause instanceof Error ? cause.message : String(cause),
+        publicKeyKty: publicKeyJwk.kty,
+        publicKeyCrv: publicKeyJwk.crv
+      }
+    );
+  }
+}
+async function computePublicKeyThumbprint(publicKeyJwk) {
+  assertCryptoAvailable();
+  if (publicKeyJwk.kty !== "EC") {
+    throw new DeviceIdentityError(
+      `Expected JWK key type "EC" but received "${publicKeyJwk.kty ?? "undefined"}". Only ECDSA public keys are supported for device identity.`,
+      { kty: publicKeyJwk.kty }
+    );
+  }
+  if (!publicKeyJwk.crv || !publicKeyJwk.x || !publicKeyJwk.y) {
+    throw new DeviceIdentityError(
+      'JWK is missing required EC fields. An EC public key JWK must include "crv", "x", and "y" members.',
+      {
+        hasCrv: Boolean(publicKeyJwk.crv),
+        hasX: Boolean(publicKeyJwk.x),
+        hasY: Boolean(publicKeyJwk.y)
+      }
+    );
+  }
+  const canonicalJson = JSON.stringify({
+    crv: publicKeyJwk.crv,
+    kty: publicKeyJwk.kty,
+    x: publicKeyJwk.x,
+    y: publicKeyJwk.y
+  });
+  try {
+    const encoded = new TextEncoder().encode(canonicalJson);
+    const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", encoded);
+    return toBase64Url(hashBuffer);
+  } catch (cause) {
+    throw new DeviceIdentityError(
+      "Failed to compute SHA-256 thumbprint of the public key JWK.",
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+
+// src/encryption/database-encryption.ts
+import { KoraError as KoraError2 } from "@korajs/core";
+var EncryptionError = class extends KoraError2 {
+  constructor(message, context) {
+    super(message, "ENCRYPTION_ERROR", context);
+    this.name = "EncryptionError";
+  }
+};
+var CryptoUnavailableError2 = class extends KoraError2 {
+  constructor() {
+    super(
+      "Web Crypto API (crypto.subtle) is not available in this environment. Database encryption requires crypto.subtle, which is available in modern browsers and Node.js 20+. If running in SSR, ensure your runtime provides the Web Crypto API.",
+      "CRYPTO_UNAVAILABLE"
+    );
+    this.name = "CryptoUnavailableError";
+  }
+};
+var AES_GCM = "AES-GCM";
+var AES_KEY_LENGTH = 256;
+var IV_LENGTH = 12;
+function assertCryptoAvailable2() {
+  if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle === "undefined") {
+    throw new CryptoUnavailableError2();
+  }
+}
+async function generateEncryptionKey() {
+  assertCryptoAvailable2();
+  try {
+    const key = await globalThis.crypto.subtle.generateKey(
+      { name: AES_GCM, length: AES_KEY_LENGTH },
+      // extractable: true so the key can be exported and persisted
+      true,
+      ["encrypt", "decrypt"]
+    );
+    return key;
+  } catch (cause) {
+    throw new EncryptionError(
+      "Failed to generate AES-256-GCM encryption key. Ensure the runtime supports the AES-GCM algorithm.",
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+async function encryptData(key, plaintext) {
+  assertCryptoAvailable2();
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+  try {
+    const ciphertextBuffer = await globalThis.crypto.subtle.encrypt(
+      { name: AES_GCM, iv },
+      key,
+      plaintext
+    );
+    return {
+      ciphertext: new Uint8Array(ciphertextBuffer),
+      iv
+    };
+  } catch (cause) {
+    throw new EncryptionError(
+      'Failed to encrypt data with AES-256-GCM. Ensure the key is a valid AES-GCM CryptoKey with "encrypt" usage.',
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+async function decryptData(key, ciphertext, iv) {
+  assertCryptoAvailable2();
+  try {
+    const plaintextBuffer = await globalThis.crypto.subtle.decrypt(
+      { name: AES_GCM, iv },
+      key,
+      ciphertext
+    );
+    return new Uint8Array(plaintextBuffer);
+  } catch (cause) {
+    throw new EncryptionError(
+      "Failed to decrypt data with AES-256-GCM. This may indicate a wrong key, tampered ciphertext, or incorrect IV.",
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+async function exportKey(key) {
+  assertCryptoAvailable2();
+  try {
+    const rawBuffer = await globalThis.crypto.subtle.exportKey("raw", key);
+    return new Uint8Array(rawBuffer);
+  } catch (cause) {
+    throw new EncryptionError(
+      "Failed to export AES-256-GCM key. The key may not be extractable. Only keys generated with extractable=true can be exported.",
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+async function importKey(rawKey) {
+  assertCryptoAvailable2();
+  if (rawKey.length !== 32) {
+    throw new EncryptionError(
+      `Invalid key length: expected 32 bytes (256 bits) for AES-256, but received ${rawKey.length} bytes.`,
+      { actualLength: rawKey.length, expectedLength: 32 }
+    );
+  }
+  try {
+    const key = await globalThis.crypto.subtle.importKey(
+      "raw",
+      rawKey,
+      { name: AES_GCM, length: AES_KEY_LENGTH },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    return key;
+  } catch (cause) {
+    throw new EncryptionError(
+      "Failed to import raw key bytes as AES-256-GCM key. Ensure the key material is valid.",
+      { cause: cause instanceof Error ? cause.message : String(cause) }
+    );
+  }
+}
+
+// src/passkey/passkey-client.ts
+import { KoraError as KoraError3 } from "@korajs/core";
+var PasskeyError = class extends KoraError3 {
+  constructor(message, context) {
+    super(message, "PASSKEY_ERROR", context);
+    this.name = "PasskeyError";
+  }
+};
+var PasskeyUnsupportedError = class extends KoraError3 {
+  constructor() {
+    super(
+      "WebAuthn is not supported in this browser. Passkey authentication requires a modern browser with WebAuthn support.",
+      "PASSKEY_UNSUPPORTED"
+    );
+    this.name = "PasskeyUnsupportedError";
+  }
+};
+function isPasskeySupported() {
+  return typeof globalThis.navigator !== "undefined" && typeof globalThis.navigator.credentials !== "undefined" && typeof globalThis.navigator.credentials.create === "function" && typeof globalThis.navigator.credentials.get === "function";
+}
+async function isPlatformAuthenticatorAvailable() {
+  if (!isPasskeySupported()) {
+    return false;
+  }
+  if (typeof PublicKeyCredential !== "undefined" && typeof PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable === "function") {
+    try {
+      return await PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+async function createPasskeyCredential(options) {
+  if (!isPasskeySupported()) {
+    throw new PasskeyUnsupportedError();
+  }
+  const excludeCredentials = (options.excludeCredentialIds ?? []).map((id) => ({
+    type: "public-key",
+    id: fromBase64Url(id).buffer
+  }));
+  const authenticatorSelection = {
+    authenticatorAttachment: options.authenticatorSelection?.authenticatorAttachment ?? "platform",
+    residentKey: options.authenticatorSelection?.residentKey ?? "preferred",
+    userVerification: options.authenticatorSelection?.userVerification ?? "required"
+  };
+  if (authenticatorSelection.residentKey === "required") {
+    authenticatorSelection.requireResidentKey = true;
+  }
+  const publicKeyOptions = {
+    challenge: fromBase64Url(options.challenge).buffer,
+    rp: {
+      id: options.rpId,
+      name: options.rpName
+    },
+    user: {
+      id: fromBase64Url(options.userId).buffer,
+      name: options.userName,
+      displayName: options.userDisplayName
+    },
+    pubKeyCredParams: [
+      // ES256 (ECDSA w/ SHA-256) — the most widely supported algorithm
+      { type: "public-key", alg: -7 },
+      // RS256 (RSASSA-PKCS1-v1_5 w/ SHA-256) — fallback for older authenticators
+      { type: "public-key", alg: -257 }
+    ],
+    excludeCredentials,
+    authenticatorSelection,
+    timeout: 6e4,
+    attestation: "none"
+  };
+  let credential;
+  try {
+    const result = await navigator.credentials.create({
+      publicKey: publicKeyOptions
+    });
+    if (result === null) {
+      throw new PasskeyError(
+        "Credential creation returned null. The user may have cancelled the operation.",
+        { rpId: options.rpId }
+      );
+    }
+    credential = result;
+  } catch (error) {
+    if (error instanceof PasskeyError) {
+      throw error;
+    }
+    const domError = error;
+    if (domError.name === "NotAllowedError") {
+      throw new PasskeyError(
+        "Passkey creation was cancelled or not allowed. The user may have dismissed the prompt or the operation timed out.",
+        { rpId: options.rpId, errorName: domError.name }
+      );
+    }
+    if (domError.name === "InvalidStateError") {
+      throw new PasskeyError(
+        "A passkey already exists for this user on this authenticator. Use the existing passkey to sign in.",
+        { rpId: options.rpId, errorName: domError.name }
+      );
+    }
+    throw new PasskeyError(
+      `Passkey creation failed: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        rpId: options.rpId,
+        errorName: error instanceof Error ? error.name : void 0
+      }
+    );
+  }
+  const response = credential.response;
+  const attestationObject = new Uint8Array(response.attestationObject);
+  const clientDataJSON = new Uint8Array(response.clientDataJSON);
+  const publicKeyBytes = extractPublicKeyFromAttestationObject(attestationObject);
+  return {
+    credentialId: toBase64Url(credential.rawId),
+    publicKey: toBase64Url(publicKeyBytes.buffer),
+    clientDataJSON: toBase64Url(clientDataJSON.buffer),
+    attestationObject: toBase64Url(attestationObject.buffer)
+  };
+}
+async function authenticateWithPasskey(options) {
+  if (!isPasskeySupported()) {
+    throw new PasskeyUnsupportedError();
+  }
+  const allowCredentials = options.allowCredentialIds?.map((id) => ({
+    type: "public-key",
+    id: fromBase64Url(id).buffer
+  }));
+  const publicKeyOptions = {
+    challenge: fromBase64Url(options.challenge).buffer,
+    rpId: options.rpId,
+    allowCredentials,
+    userVerification: options.userVerification ?? "preferred",
+    timeout: options.timeout ?? 6e4
+  };
+  let credential;
+  try {
+    const result = await navigator.credentials.get({
+      publicKey: publicKeyOptions
+    });
+    if (result === null) {
+      throw new PasskeyError(
+        "Authentication returned null. The user may have cancelled the operation.",
+        { rpId: options.rpId }
+      );
+    }
+    credential = result;
+  } catch (error) {
+    if (error instanceof PasskeyError) {
+      throw error;
+    }
+    const domError = error;
+    if (domError.name === "NotAllowedError") {
+      throw new PasskeyError(
+        "Passkey authentication was cancelled or not allowed. The user may have dismissed the prompt or the operation timed out.",
+        { rpId: options.rpId, errorName: domError.name }
+      );
+    }
+    throw new PasskeyError(
+      `Passkey authentication failed: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        rpId: options.rpId,
+        errorName: error instanceof Error ? error.name : void 0
+      }
+    );
+  }
+  const response = credential.response;
+  const authenticatorData = new Uint8Array(response.authenticatorData);
+  const clientDataJSON = new Uint8Array(response.clientDataJSON);
+  const signature = new Uint8Array(response.signature);
+  const userHandle = response.userHandle !== null && response.userHandle.byteLength > 0 ? toBase64Url(response.userHandle) : null;
+  return {
+    credentialId: toBase64Url(credential.rawId),
+    authenticatorData: toBase64Url(authenticatorData.buffer),
+    clientDataJSON: toBase64Url(clientDataJSON.buffer),
+    signature: toBase64Url(signature.buffer),
+    userHandle
+  };
+}
+function extractPublicKeyFromAttestationObject(attestationObject) {
+  const decoded = decodeCbor(attestationObject, 0);
+  const topMap = decoded.value;
+  const authData = topMap.get("authData");
+  if (!(authData instanceof Uint8Array)) {
+    throw new PasskeyError(
+      "Invalid attestation object: authData is missing or not a byte string."
+    );
+  }
+  let offset = 0;
+  offset += 32;
+  const flags = authData[offset];
+  offset += 1;
+  offset += 4;
+  const hasAttestedCredentialData = (flags & 64) !== 0;
+  if (!hasAttestedCredentialData) {
+    throw new PasskeyError(
+      "Attestation object does not contain attested credential data. The authenticator did not include a public key."
+    );
+  }
+  offset += 16;
+  const credentialIdLength = authData[offset] << 8 | authData[offset + 1];
+  offset += 2;
+  offset += credentialIdLength;
+  const coseKeyResult = decodeCbor(authData, offset);
+  const coseKeyLength = coseKeyResult.offset - offset;
+  return authData.slice(offset, offset + coseKeyLength);
+}
+function decodeCbor(data, offset) {
+  if (offset >= data.length) {
+    throw new PasskeyError("CBOR decode error: unexpected end of data.");
+  }
+  const initialByte = data[offset];
+  const majorType = initialByte >> 5;
+  const additionalInfo = initialByte & 31;
+  offset += 1;
+  let argument;
+  if (additionalInfo < 24) {
+    argument = additionalInfo;
+  } else if (additionalInfo === 24) {
+    argument = data[offset];
+    offset += 1;
+  } else if (additionalInfo === 25) {
+    argument = data[offset] << 8 | data[offset + 1];
+    offset += 2;
+  } else if (additionalInfo === 26) {
+    argument = data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+    argument = argument >>> 0;
+    offset += 4;
+  } else {
+    throw new PasskeyError(
+      `CBOR decode error: unsupported additional info ${additionalInfo} at byte ${offset - 1}. This CBOR decoder only supports definite-length encodings.`
+    );
+  }
+  switch (majorType) {
+    // Major type 0: Unsigned integer
+    case 0:
+      return { value: argument, offset };
+    // Major type 1: Negative integer (-1 - argument)
+    case 1:
+      return { value: -1 - argument, offset };
+    // Major type 2: Byte string
+    case 2: {
+      const bytes = data.slice(offset, offset + argument);
+      return { value: bytes, offset: offset + argument };
+    }
+    // Major type 3: Text string (UTF-8)
+    case 3: {
+      const textBytes = data.slice(offset, offset + argument);
+      const text = new TextDecoder().decode(textBytes);
+      return { value: text, offset: offset + argument };
+    }
+    // Major type 4: Array
+    case 4: {
+      const arr = [];
+      let currentOffset = offset;
+      for (let i = 0; i < argument; i++) {
+        const item = decodeCbor(data, currentOffset);
+        arr.push(item.value);
+        currentOffset = item.offset;
+      }
+      return { value: arr, offset: currentOffset };
+    }
+    // Major type 5: Map
+    case 5: {
+      const map = /* @__PURE__ */ new Map();
+      let currentOffset = offset;
+      for (let i = 0; i < argument; i++) {
+        const keyResult = decodeCbor(data, currentOffset);
+        const valResult = decodeCbor(data, keyResult.offset);
+        map.set(keyResult.value, valResult.value);
+        currentOffset = valResult.offset;
+      }
+      return { value: map, offset: currentOffset };
+    }
+    default:
+      throw new PasskeyError(
+        `CBOR decode error: unsupported major type ${majorType} at byte ${offset - 1}. This CBOR decoder only supports types 0-5 (integers, byte/text strings, arrays, maps).`
+      );
+  }
+}
+
+// src/encryption/operation-encryptor.ts
+import { KoraError as KoraError4 } from "@korajs/core";
+var ENCRYPTED_MARKER = "__kora_encrypted";
+var ENCRYPTION_VERSION = 1;
+var OperationEncryptionError = class extends KoraError4 {
+  constructor(message, context) {
+    super(message, "OPERATION_ENCRYPTION_ERROR", context);
+    this.name = "OperationEncryptionError";
+  }
+};
+function toBase64Url2(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url2(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const paddingNeeded = (4 - base64.length % 4) % 4;
+  base64 += "=".repeat(paddingNeeded);
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+var OperationEncryptor = class {
+  key;
+  constructor(config) {
+    this.key = config.key;
+  }
+  /**
+   * Encrypt an operation's data fields.
+   *
+   * Returns a new Operation with `data` and `previousData` replaced by
+   * encrypted envelopes. The original operation is not mutated.
+   *
+   * If `data` or `previousData` is null (e.g., delete operations),
+   * that field remains null — there is nothing to encrypt.
+   *
+   * @param operation - The operation to encrypt
+   * @returns A new operation with encrypted data fields
+   * @throws {OperationEncryptionError} If encryption fails
+   */
+  async encryptOperation(operation) {
+    const [encryptedData, encryptedPreviousData] = await Promise.all([
+      this.encryptField(operation.data, operation.id, "data"),
+      this.encryptField(operation.previousData, operation.id, "previousData")
+    ]);
+    return {
+      ...operation,
+      data: encryptedData,
+      previousData: encryptedPreviousData
+    };
+  }
+  /**
+   * Decrypt an operation's data fields.
+   *
+   * Returns a new Operation with the original `data` and `previousData`
+   * restored from their encrypted envelopes. The original operation is
+   * not mutated.
+   *
+   * If a field is null or not encrypted (no marker), it passes through unchanged.
+   * This enables mixed plaintext/encrypted operations during migration.
+   *
+   * @param operation - The operation to decrypt
+   * @returns A new operation with decrypted data fields
+   * @throws {OperationEncryptionError} If decryption fails (wrong key, tampered data)
+   */
+  async decryptOperation(operation) {
+    const [decryptedData, decryptedPreviousData] = await Promise.all([
+      this.decryptField(operation.data, operation.id, "data"),
+      this.decryptField(operation.previousData, operation.id, "previousData")
+    ]);
+    return {
+      ...operation,
+      data: decryptedData,
+      previousData: decryptedPreviousData
+    };
+  }
+  /**
+   * Check if an operation's data fields are encrypted.
+   *
+   * Returns true if either `data` or `previousData` contains an encrypted
+   * envelope marker. Useful for determining whether decryption is needed
+   * before applying an operation.
+   *
+   * @param operation - The operation to check
+   * @returns true if any data field is encrypted
+   */
+  isEncrypted(operation) {
+    return isEncryptedEnvelope(operation.data) || isEncryptedEnvelope(operation.previousData);
+  }
+  /**
+   * Encrypt a batch of operations.
+   *
+   * Convenience method for encrypting multiple operations at once.
+   * Operations are encrypted in parallel for performance.
+   *
+   * @param operations - The operations to encrypt
+   * @returns New operations with encrypted data fields
+   */
+  async encryptBatch(operations) {
+    return Promise.all(operations.map((op) => this.encryptOperation(op)));
+  }
+  /**
+   * Decrypt a batch of operations.
+   *
+   * Convenience method for decrypting multiple operations at once.
+   * Operations are decrypted in parallel for performance.
+   *
+   * @param operations - The operations to decrypt
+   * @returns New operations with decrypted data fields
+   */
+  async decryptBatch(operations) {
+    return Promise.all(operations.map((op) => this.decryptOperation(op)));
+  }
+  // --- Private helpers ---
+  async encryptField(field, operationId, fieldName) {
+    if (field === null) {
+      return null;
+    }
+    const plaintext = new TextEncoder().encode(JSON.stringify(field));
+    try {
+      const { ciphertext, iv } = await encryptData(this.key, plaintext);
+      const envelope = {
+        [ENCRYPTED_MARKER]: true,
+        ciphertext: toBase64Url2(ciphertext),
+        iv: toBase64Url2(iv),
+        algorithm: "AES-256-GCM",
+        version: ENCRYPTION_VERSION
+      };
+      return envelope;
+    } catch (cause) {
+      if (cause instanceof OperationEncryptionError) {
+        throw cause;
+      }
+      throw new OperationEncryptionError(
+        `Failed to encrypt operation ${fieldName} field.`,
+        {
+          operationId,
+          fieldName,
+          cause: cause instanceof Error ? cause.message : String(cause)
+        }
+      );
+    }
+  }
+  async decryptField(field, operationId, fieldName) {
+    if (field === null) {
+      return null;
+    }
+    if (!isEncryptedEnvelope(field)) {
+      return field;
+    }
+    const envelope = field;
+    if (envelope.version > ENCRYPTION_VERSION) {
+      throw new OperationEncryptionError(
+        `Encrypted field uses version ${envelope.version}, but this client only supports version ${ENCRYPTION_VERSION}. Update your @korajs/auth package to decrypt this operation.`,
+        { operationId, fieldName, version: envelope.version }
+      );
+    }
+    try {
+      const ciphertext = fromBase64Url2(envelope.ciphertext);
+      const iv = fromBase64Url2(envelope.iv);
+      const plaintextBytes = await decryptData(this.key, ciphertext, iv);
+      const json = new TextDecoder().decode(plaintextBytes);
+      const parsed = JSON.parse(json);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new OperationEncryptionError(
+          `Decrypted ${fieldName} is not a valid record object.`,
+          { operationId, fieldName }
+        );
+      }
+      return parsed;
+    } catch (cause) {
+      if (cause instanceof OperationEncryptionError) {
+        throw cause;
+      }
+      throw new OperationEncryptionError(
+        `Failed to decrypt operation ${fieldName} field. This may indicate a wrong encryption key or tampered data.`,
+        {
+          operationId,
+          fieldName,
+          cause: cause instanceof Error ? cause.message : String(cause)
+        }
+      );
+    }
+  }
+};
+function isEncryptedField(field) {
+  return isEncryptedEnvelope(field);
+}
+function isEncryptedEnvelope(field) {
+  if (field === null || typeof field !== "object") {
+    return false;
+  }
+  return field[ENCRYPTED_MARKER] === true && typeof field["ciphertext"] === "string" && typeof field["iv"] === "string" && field["algorithm"] === "AES-256-GCM";
+}
+
+export {
+  CryptoUnavailableError,
+  DeviceIdentityError,
+  toBase64Url,
+  fromBase64Url,
+  generateDeviceKeyPair,
+  exportPublicKeyJwk,
+  signChallenge,
+  verifyChallenge,
+  computePublicKeyThumbprint,
+  EncryptionError,
+  generateEncryptionKey,
+  encryptData,
+  decryptData,
+  exportKey,
+  importKey,
+  PasskeyError,
+  PasskeyUnsupportedError,
+  isPasskeySupported,
+  isPlatformAuthenticatorAvailable,
+  createPasskeyCredential,
+  authenticateWithPasskey,
+  decodeCbor,
+  OperationEncryptionError,
+  OperationEncryptor,
+  isEncryptedField
+};
+//# sourceMappingURL=chunk-FSU4SK32.js.map