@absolutejs/auth 0.38.0 → 0.40.0-beta.1

package/dist/index.js

@@ -16,6 +16,141 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/constants.ts
+var SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_SECOND = 1000, MILLISECONDS_IN_A_MINUTE, MINUTES_IN_AN_HOUR = 60, HOURS_IN_A_DAY = 24, MILLISECONDS_IN_A_DAY, MILLISECONDS_IN_AN_HOUR, COOKIE_MINUTES = 30, COOKIE_DURATION, DEFAULT_MAX_SESSIONS = 1e4;
+var init_constants = __esm(() => {
+  MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+  MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_A_DAY;
+  MILLISECONDS_IN_AN_HOUR = MILLISECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR;
+  COOKIE_DURATION = SECONDS_IN_A_MINUTE * COOKIE_MINUTES;
+});
+
+// src/crypto.ts
+var exports_crypto = {};
+__export(exports_crypto, {
+  verifyTotp: () => verifyTotp,
+  verifyPassword: () => verifyPassword,
+  hashToken: () => hashToken,
+  hashPassword: () => hashPassword,
+  generateTotpSecret: () => generateTotpSecret,
+  generateTotp: () => generateTotp,
+  generateSecureToken: () => generateSecureToken,
+  generateEncryptionKey: () => generateEncryptionKey,
+  encryptSecret: () => encryptSecret,
+  decryptSecret: () => decryptSecret,
+  createTotpKeyUri: () => createTotpKeyUri,
+  constantTimeEqual: () => constantTimeEqual,
+  base32Encode: () => base32Encode,
+  base32Decode: () => base32Decode
+});
+var DEFAULT_TOKEN_BYTES = 32, AES_KEY_BYTES = 32, AES_IV_BYTES = 12, HOTP_COUNTER_BYTES = 8, TOTP_SECRET_BYTES = 20, TOTP_DIGITS = 6, TOTP_PERIOD_SECONDS = 30, DEFAULT_TOTP_WINDOW = 1, DECIMAL_RADIX = 10, LAST_NIBBLE_MASK = 15, SIGN_BIT_MASK = 2147483647, BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", BASE32_GROUP_BITS = 5, BASE32_MASK = 31, BYTE_BITS = 8, textEncoder, textDecoder, base64UrlEncode = (bytes) => Buffer.from(bytes).toString("base64url"), base64UrlDecode = (encoded) => new Uint8Array(Buffer.from(encoded, "base64url")), sha256 = async (input) => {
+  const digest = await crypto.subtle.digest("SHA-256", textEncoder.encode(input));
+  return new Uint8Array(digest);
+}, hmacSha1 = async (key, message) => {
+  const cryptoKey = await crypto.subtle.importKey("raw", key, { hash: "SHA-1", name: "HMAC" }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, message);
+  return new Uint8Array(signature);
+}, counterToBytes = (counter) => {
+  const bytes = new Uint8Array(HOTP_COUNTER_BYTES);
+  new DataView(bytes.buffer).setBigUint64(0, BigInt(counter), false);
+  return bytes;
+}, generateHotp = async (secret, counter, digits = TOTP_DIGITS) => {
+  const hmac = await hmacSha1(secret, counterToBytes(counter));
+  const view = new DataView(hmac.buffer, hmac.byteOffset, hmac.byteLength);
+  const offset = view.getUint8(hmac.byteLength - 1) & LAST_NIBBLE_MASK;
+  const truncated = view.getUint32(offset, false) & SIGN_BIT_MASK;
+  const otp = truncated % DECIMAL_RADIX ** digits;
+  return otp.toString().padStart(digits, "0");
+}, importAesKey = (keyMaterial) => crypto.subtle.importKey("raw", base64UrlDecode(keyMaterial), { name: "AES-GCM" }, false, ["decrypt", "encrypt"]), base32Decode = (encoded) => {
+  const normalized = encoded.toUpperCase().replace(/[^A-Z2-7]/gu, "");
+  const bits = [...normalized].map((char) => BASE32_ALPHABET.indexOf(char).toString(2).padStart(BASE32_GROUP_BITS, "0")).join("");
+  const byteChunks = bits.match(/.{8}/gu) ?? [];
+  return new Uint8Array(byteChunks.map((chunk) => parseInt(chunk, 2)));
+}, base32Encode = (bytes) => {
+  const bits = Array.from(bytes, (byte) => byte.toString(2).padStart(BYTE_BITS, "0")).join("");
+  const groups = bits.match(/.{1,5}/gu) ?? [];
+  return groups.map((group) => BASE32_ALPHABET[parseInt(group.padEnd(BASE32_GROUP_BITS, "0"), 2) & BASE32_MASK] ?? "").join("");
+}, constantTimeEqual = async (left, right) => {
+  const [leftDigest, rightDigest] = await Promise.all([
+    sha256(left),
+    sha256(right)
+  ]);
+  const leftView = new DataView(leftDigest.buffer, leftDigest.byteOffset, leftDigest.byteLength);
+  const rightView = new DataView(rightDigest.buffer, rightDigest.byteOffset, rightDigest.byteLength);
+  let mismatch = 0;
+  for (let index = 0;index < leftDigest.byteLength; index += 1) {
+    mismatch |= leftView.getUint8(index) ^ rightView.getUint8(index);
+  }
+  return mismatch === 0;
+}, createTotpKeyUri = ({
+  accountName,
+  digits = TOTP_DIGITS,
+  issuer,
+  period = TOTP_PERIOD_SECONDS,
+  secret
+}) => {
+  const params = new URLSearchParams({
+    algorithm: "SHA1",
+    digits: `${digits}`,
+    issuer,
+    period: `${period}`,
+    secret
+  });
+  const label = encodeURIComponent(`${issuer}:${accountName}`);
+  return `otpauth://totp/${label}?${params.toString()}`;
+}, decryptSecret = async (ciphertext, keyMaterial) => {
+  const key = await importAesKey(keyMaterial);
+  const combined = base64UrlDecode(ciphertext);
+  const nonce = combined.subarray(0, AES_IV_BYTES);
+  const data = combined.subarray(AES_IV_BYTES);
+  const plaintext = await crypto.subtle.decrypt({ iv: nonce, name: "AES-GCM" }, key, data);
+  return textDecoder.decode(plaintext);
+}, encryptSecret = async (plaintext, keyMaterial) => {
+  const key = await importAesKey(keyMaterial);
+  const nonce = new Uint8Array(AES_IV_BYTES);
+  crypto.getRandomValues(nonce);
+  const ciphertext = await crypto.subtle.encrypt({ iv: nonce, name: "AES-GCM" }, key, textEncoder.encode(plaintext));
+  const combined = new Uint8Array(nonce.byteLength + ciphertext.byteLength);
+  combined.set(nonce, 0);
+  combined.set(new Uint8Array(ciphertext), nonce.byteLength);
+  return base64UrlEncode(combined);
+}, generateEncryptionKey = () => generateSecureToken(AES_KEY_BYTES), generateSecureToken = (byteLength = DEFAULT_TOKEN_BYTES) => {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return base64UrlEncode(bytes);
+}, generateTotp = async ({
+  digits = TOTP_DIGITS,
+  now = Date.now(),
+  period = TOTP_PERIOD_SECONDS,
+  secret
+}) => {
+  const counter = Math.floor(now / MILLISECONDS_IN_A_SECOND / period);
+  return generateHotp(base32Decode(secret), counter, digits);
+}, generateTotpSecret = (byteLength = TOTP_SECRET_BYTES) => {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return base32Encode(bytes);
+}, hashPassword = (password) => Bun.password.hash(password, { algorithm: "argon2id" }), hashToken = async (token) => base64UrlEncode(await sha256(token)), verifyPassword = (password, hash) => Bun.password.verify(password, hash), verifyTotp = async ({
+  digits = TOTP_DIGITS,
+  now = Date.now(),
+  period = TOTP_PERIOD_SECONDS,
+  secret,
+  token,
+  window = DEFAULT_TOTP_WINDOW
+}) => {
+  const secretBytes = base32Decode(secret);
+  const counter = Math.floor(now / MILLISECONDS_IN_A_SECOND / period);
+  const drifts = Array.from({ length: window * 2 + 1 }, (_, offset) => counter - window + offset);
+  const candidates = await Promise.all(drifts.map((value) => generateHotp(secretBytes, value, digits)));
+  const matches = await Promise.all(candidates.map((candidate) => constantTimeEqual(candidate, token)));
+  return matches.includes(true);
+};
+var init_crypto = __esm(() => {
+  init_constants();
+  textEncoder = new TextEncoder;
+  textDecoder = new TextDecoder;
+});
+
 // node_modules/citra/dist/index.js
 var BASE64_BLOCK_SIZE = 4;
 var NUM_GENERATOR_BYTES = 32;
@@ -2537,165 +2672,14 @@ var createOAuth2Client = async (providerName, config) => {
 };
 
 // src/index.ts
-import { Elysia as Elysia36 } from "elysia";
+import { Elysia as Elysia39 } from "elysia";
 
 // src/apikeys/routes.ts
 import { Elysia, t } from "elysia";
 
-// src/constants.ts
-var SECONDS_IN_A_MINUTE = 60;
-var MILLISECONDS_IN_A_SECOND = 1000;
-var MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
-var MINUTES_IN_AN_HOUR = 60;
-var HOURS_IN_A_DAY = 24;
-var MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_A_DAY;
-var MILLISECONDS_IN_AN_HOUR = MILLISECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR;
-var COOKIE_MINUTES = 30;
-var COOKIE_DURATION = SECONDS_IN_A_MINUTE * COOKIE_MINUTES;
-var DEFAULT_MAX_SESSIONS = 1e4;
-
-// src/crypto.ts
-var DEFAULT_TOKEN_BYTES = 32;
-var AES_KEY_BYTES = 32;
-var AES_IV_BYTES = 12;
-var HOTP_COUNTER_BYTES = 8;
-var TOTP_SECRET_BYTES = 20;
-var TOTP_DIGITS = 6;
-var TOTP_PERIOD_SECONDS = 30;
-var DEFAULT_TOTP_WINDOW = 1;
-var DECIMAL_RADIX = 10;
-var LAST_NIBBLE_MASK = 15;
-var SIGN_BIT_MASK = 2147483647;
-var BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-var BASE32_GROUP_BITS = 5;
-var BASE32_MASK = 31;
-var BYTE_BITS = 8;
-var textEncoder = new TextEncoder;
-var textDecoder = new TextDecoder;
-var base64UrlEncode = (bytes) => Buffer.from(bytes).toString("base64url");
-var base64UrlDecode = (encoded) => new Uint8Array(Buffer.from(encoded, "base64url"));
-var sha256 = async (input) => {
-  const digest = await crypto.subtle.digest("SHA-256", textEncoder.encode(input));
-  return new Uint8Array(digest);
-};
-var hmacSha1 = async (key, message) => {
-  const cryptoKey = await crypto.subtle.importKey("raw", key, { hash: "SHA-1", name: "HMAC" }, false, ["sign"]);
-  const signature = await crypto.subtle.sign("HMAC", cryptoKey, message);
-  return new Uint8Array(signature);
-};
-var counterToBytes = (counter) => {
-  const bytes = new Uint8Array(HOTP_COUNTER_BYTES);
-  new DataView(bytes.buffer).setBigUint64(0, BigInt(counter), false);
-  return bytes;
-};
-var generateHotp = async (secret, counter, digits = TOTP_DIGITS) => {
-  const hmac = await hmacSha1(secret, counterToBytes(counter));
-  const view = new DataView(hmac.buffer, hmac.byteOffset, hmac.byteLength);
-  const offset = view.getUint8(hmac.byteLength - 1) & LAST_NIBBLE_MASK;
-  const truncated = view.getUint32(offset, false) & SIGN_BIT_MASK;
-  const otp = truncated % DECIMAL_RADIX ** digits;
-  return otp.toString().padStart(digits, "0");
-};
-var importAesKey = (keyMaterial) => crypto.subtle.importKey("raw", base64UrlDecode(keyMaterial), { name: "AES-GCM" }, false, ["decrypt", "encrypt"]);
-var base32Decode = (encoded) => {
-  const normalized = encoded.toUpperCase().replace(/[^A-Z2-7]/gu, "");
-  const bits = [...normalized].map((char) => BASE32_ALPHABET.indexOf(char).toString(2).padStart(BASE32_GROUP_BITS, "0")).join("");
-  const byteChunks = bits.match(/.{8}/gu) ?? [];
-  return new Uint8Array(byteChunks.map((chunk) => parseInt(chunk, 2)));
-};
-var base32Encode = (bytes) => {
-  const bits = Array.from(bytes, (byte) => byte.toString(2).padStart(BYTE_BITS, "0")).join("");
-  const groups = bits.match(/.{1,5}/gu) ?? [];
-  return groups.map((group) => BASE32_ALPHABET[parseInt(group.padEnd(BASE32_GROUP_BITS, "0"), 2) & BASE32_MASK] ?? "").join("");
-};
-var constantTimeEqual = async (left, right) => {
-  const [leftDigest, rightDigest] = await Promise.all([
-    sha256(left),
-    sha256(right)
-  ]);
-  const leftView = new DataView(leftDigest.buffer, leftDigest.byteOffset, leftDigest.byteLength);
-  const rightView = new DataView(rightDigest.buffer, rightDigest.byteOffset, rightDigest.byteLength);
-  let mismatch = 0;
-  for (let index = 0;index < leftDigest.byteLength; index += 1) {
-    mismatch |= leftView.getUint8(index) ^ rightView.getUint8(index);
-  }
-  return mismatch === 0;
-};
-var createTotpKeyUri = ({
-  accountName,
-  digits = TOTP_DIGITS,
-  issuer,
-  period = TOTP_PERIOD_SECONDS,
-  secret
-}) => {
-  const params = new URLSearchParams({
-    algorithm: "SHA1",
-    digits: `${digits}`,
-    issuer,
-    period: `${period}`,
-    secret
-  });
-  const label = encodeURIComponent(`${issuer}:${accountName}`);
-  return `otpauth://totp/${label}?${params.toString()}`;
-};
-var decryptSecret = async (ciphertext, keyMaterial) => {
-  const key = await importAesKey(keyMaterial);
-  const combined = base64UrlDecode(ciphertext);
-  const nonce = combined.subarray(0, AES_IV_BYTES);
-  const data = combined.subarray(AES_IV_BYTES);
-  const plaintext = await crypto.subtle.decrypt({ iv: nonce, name: "AES-GCM" }, key, data);
-  return textDecoder.decode(plaintext);
-};
-var encryptSecret = async (plaintext, keyMaterial) => {
-  const key = await importAesKey(keyMaterial);
-  const nonce = new Uint8Array(AES_IV_BYTES);
-  crypto.getRandomValues(nonce);
-  const ciphertext = await crypto.subtle.encrypt({ iv: nonce, name: "AES-GCM" }, key, textEncoder.encode(plaintext));
-  const combined = new Uint8Array(nonce.byteLength + ciphertext.byteLength);
-  combined.set(nonce, 0);
-  combined.set(new Uint8Array(ciphertext), nonce.byteLength);
-  return base64UrlEncode(combined);
-};
-var generateEncryptionKey = () => generateSecureToken(AES_KEY_BYTES);
-var generateSecureToken = (byteLength = DEFAULT_TOKEN_BYTES) => {
-  const bytes = new Uint8Array(byteLength);
-  crypto.getRandomValues(bytes);
-  return base64UrlEncode(bytes);
-};
-var generateTotp = async ({
-  digits = TOTP_DIGITS,
-  now = Date.now(),
-  period = TOTP_PERIOD_SECONDS,
-  secret
-}) => {
-  const counter = Math.floor(now / MILLISECONDS_IN_A_SECOND / period);
-  return generateHotp(base32Decode(secret), counter, digits);
-};
-var generateTotpSecret = (byteLength = TOTP_SECRET_BYTES) => {
-  const bytes = new Uint8Array(byteLength);
-  crypto.getRandomValues(bytes);
-  return base32Encode(bytes);
-};
-var hashPassword = (password) => Bun.password.hash(password, { algorithm: "argon2id" });
-var hashToken = async (token) => base64UrlEncode(await sha256(token));
-var verifyPassword = (password, hash) => Bun.password.verify(password, hash);
-var verifyTotp = async ({
-  digits = TOTP_DIGITS,
-  now = Date.now(),
-  period = TOTP_PERIOD_SECONDS,
-  secret,
-  token,
-  window = DEFAULT_TOTP_WINDOW
-}) => {
-  const secretBytes = base32Decode(secret);
-  const counter = Math.floor(now / MILLISECONDS_IN_A_SECOND / period);
-  const drifts = Array.from({ length: window * 2 + 1 }, (_, offset) => counter - window + offset);
-  const candidates = await Promise.all(drifts.map((value) => generateHotp(secretBytes, value, digits)));
-  const matches = await Promise.all(candidates.map((candidate) => constantTimeEqual(candidate, token)));
-  return matches.includes(true);
-};
-
 // src/apikeys/config.ts
+init_constants();
+init_crypto();
 var DEFAULT_TOKEN_ROUTE = "/oauth2/token";
 var ACCESS_TOKEN_PREFIX = "at_";
 var API_KEY_PREFIX = "sk_";
@@ -3202,6 +3186,7 @@ var protectPermissionPlugin = ({
 import { Elysia as Elysia4, t as t4 } from "elysia";
 
 // src/utils.ts
+init_constants();
 var defineAuthConfig = (configuration) => configuration;
 var defineAuthHtmxConfig = (htmxConfig) => htmxConfig;
 var defineAuthSettings = (settings) => settings;
@@ -3542,9 +3527,11 @@ var complianceRoutes = ({
 import { Elysia as Elysia9 } from "elysia";
 
 // src/credentials/emailVerification.ts
+init_crypto();
 import { Elysia as Elysia5, t as t5 } from "elysia";
 
 // src/credentials/config.ts
+init_constants();
 var DEFAULT_CREDENTIAL_SESSION_TTL_MS = MILLISECONDS_IN_A_DAY;
 var DEFAULT_RESET_TOKEN_TTL_MS = MILLISECONDS_IN_AN_HOUR;
 var DEFAULT_VERIFICATION_TOKEN_TTL_MS = MILLISECONDS_IN_A_DAY;
@@ -3586,9 +3573,12 @@ var credentialsEmailVerification = ({
 }, { body: t5.Object({ email: t5.String() }) });
 
 // src/credentials/login.ts
+init_constants();
+init_crypto();
 import { Elysia as Elysia6, t as t6 } from "elysia";
 
 // src/credentials/import.ts
+init_crypto();
 var normalizeEmail = (email) => email.trim().toLowerCase();
 var buildCredential = (email, emailVerified, passwordHash, userId) => ({
   createdAt: Date.now(),
@@ -3866,6 +3856,7 @@ var credentialsLogin = ({
 });
 
 // src/credentials/passwordReset.ts
+init_crypto();
 import { Elysia as Elysia7, t as t7 } from "elysia";
 var credentialsPasswordReset = ({
   credentialStore,
@@ -3924,6 +3915,7 @@ var credentialsPasswordReset = ({
 });
 
 // src/credentials/register.ts
+init_crypto();
 import { Elysia as Elysia8, t as t8 } from "elysia";
 var credentialsRegister = ({
   authSessionStore,
@@ -4201,6 +4193,7 @@ var createAuthHtmxRoutes = (config) => {
 };
 
 // src/lockout/config.ts
+init_constants();
 var DEFAULT_MAX_ATTEMPTS = 5;
 var LOCKOUT_WINDOW_MINUTES = 15;
 var DEFAULT_WINDOW_MS = MILLISECONDS_IN_A_MINUTE * LOCKOUT_WINDOW_MINUTES;
@@ -4237,9 +4230,11 @@ var createMfaGate = ({ getUserId, mfaStore }) => async (user) => isMfaEnrolled(a
 import { Elysia as Elysia14 } from "elysia";
 
 // src/mfa/challenge.ts
+init_crypto();
 import { Elysia as Elysia12, t as t10 } from "elysia";
 
 // src/mfa/backupCodes.ts
+init_crypto();
 var BACKUP_CODE_BYTES = 8;
 var consumeBackupCode = async (code, hashes) => {
   const codeHash = await hashToken(code);
@@ -4255,11 +4250,13 @@ var generateBackupCodes = async (count) => {
 };
 
 // src/mfa/config.ts
+init_constants();
 var DEFAULT_BACKUP_CODE_COUNT = 10;
 var DEFAULT_MFA_ISSUER = "AbsoluteAuth";
 var DEFAULT_MFA_SESSION_TTL_MS = MILLISECONDS_IN_A_DAY;
 
 // src/mfa/secret.ts
+init_crypto();
 var decryptTotpSecret = (ciphertext, encryptionKey) => encryptionKey ? decryptSecret(ciphertext, encryptionKey) : Promise.resolve(ciphertext);
 var encryptTotpSecret = (secret, encryptionKey) => encryptionKey ? encryptSecret(secret, encryptionKey) : Promise.resolve(secret);
 
@@ -4337,6 +4334,7 @@ var mfaChallenge = ({
 });
 
 // src/mfa/totp.ts
+init_crypto();
 import { Elysia as Elysia13, t as t11 } from "elysia";
 var mfaTotpRoutes = ({
   authSessionStore,
@@ -4423,8 +4421,14 @@ var mfaTotpRoutes = ({
 var mfaRoutes = (config) => new Elysia14().use(mfaTotpRoutes(config)).use(mfaChallenge(config));
 
 // src/oidc/routes.ts
+init_constants();
+init_crypto();
 import { Elysia as Elysia15, t as t12 } from "elysia";
 
+// src/oidc/config.ts
+init_constants();
+init_crypto();
+
 // src/oidc/keys.ts
 var ENCODER = new TextEncoder;
 var ES256 = { hash: "SHA-256", name: "ECDSA" };
@@ -4939,6 +4943,7 @@ var exchangeBackchannelAuth = async ({
 };
 
 // src/oidc/clientAuth.ts
+init_constants();
 var CLIENT_ASSERTION_TYPE = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
 var MAX_ASSERTION_LIFETIME_MINUTES = 5;
 var SECONDS_PER_MINUTE = 60;
@@ -5047,6 +5052,329 @@ var verifyJwtSignedByClient = ({
   client
 }) => verifyJwtSignedByClientImpl(client, jwt);
 
+// src/oidc/vci.ts
+init_crypto();
+
+// src/vc/sdJwt.ts
+var SALT_BYTES = 16;
+var SD_ALG = "sha-256";
+var toBase64Url2 = (bytes) => Buffer.from(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)).toString("base64url");
+var fromBase64Url2 = (value) => new Uint8Array(Buffer.from(value, "base64url"));
+var randomSalt = () => {
+  const bytes = new Uint8Array(SALT_BYTES);
+  crypto.getRandomValues(bytes);
+  return toBase64Url2(bytes);
+};
+var sha2562 = async (input) => {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+  return toBase64Url2(digest);
+};
+var encodeDisclosure = (claimName, claimValue) => {
+  const salt = randomSalt();
+  const tuple = JSON.stringify([salt, claimName, claimValue]);
+  const encoded = Buffer.from(tuple).toString("base64url");
+  return { claimName, claimValue, encoded, salt };
+};
+var issueSdJwtVc = async (input) => {
+  const disclosures = Object.entries(input.selective).map(([name, value]) => encodeDisclosure(name, value));
+  const sdDigests = await Promise.all(disclosures.map((disclosure) => sha2562(disclosure.encoded)));
+  const payload = {
+    ...input.base,
+    _sd: sdDigests,
+    _sd_alg: SD_ALG
+  };
+  if (input.holderJwk !== undefined)
+    payload.cnf = { jwk: input.holderJwk };
+  const jwt = await signJwt(payload, input.signingKey);
+  const tail = disclosures.map((disclosure) => disclosure.encoded).join("~");
+  return `${jwt}~${tail}~`;
+};
+var parseSdJwtVc = (token) => {
+  const segments = token.split("~");
+  const jwt = segments[0] ?? "";
+  const tail = segments.slice(1);
+  const last = tail[tail.length - 1];
+  const hasKeyBinding = last !== undefined && last !== "";
+  const keyBindingJwt = hasKeyBinding ? last : undefined;
+  const disclosureCount = hasKeyBinding ? tail.length - 1 : tail.length - 1;
+  const disclosures = tail.slice(0, disclosureCount).filter((entry) => entry !== "");
+  return { disclosures, jwt, keyBindingJwt };
+};
+var presentSdJwtVc = (parsed, selectedClaims, keyBindingJwt) => {
+  const selectedSet = new Set(selectedClaims);
+  const kept = parsed.disclosures.filter((encoded) => {
+    const tuple = decodeDisclosure(encoded);
+    return tuple !== undefined && selectedSet.has(tuple.claimName);
+  });
+  const tail = kept.join("~");
+  const suffix = keyBindingJwt === undefined ? "" : keyBindingJwt;
+  return `${parsed.jwt}~${tail}~${suffix}`;
+};
+var DISCLOSURE_TUPLE_LENGTH = 3;
+var decodeDisclosure = (encoded) => {
+  try {
+    const raw = Buffer.from(encoded, "base64url").toString("utf8");
+    const tuple = JSON.parse(raw);
+    if (!Array.isArray(tuple) || tuple.length !== DISCLOSURE_TUPLE_LENGTH) {
+      return;
+    }
+    const [salt, claimName, claimValue] = tuple;
+    if (typeof salt !== "string" || typeof claimName !== "string") {
+      return;
+    }
+    const decoded = { claimName, claimValue, encoded, salt };
+    return decoded;
+  } catch {
+    return;
+  }
+};
+var verifySdJwtVc = async (input) => {
+  const parsed = parseSdJwtVc(input.token);
+  const decoded = await verifyJwt(parsed.jwt, input.issuerPublicJwk);
+  if (decoded === undefined)
+    return;
+  const rawPayload = decoded.payload;
+  if (typeof rawPayload !== "object" || rawPayload === null)
+    return;
+  const payload = { ...rawPayload };
+  const sdArray = payload._sd;
+  const sdAlg = payload._sd_alg;
+  if (!Array.isArray(sdArray) || sdAlg !== SD_ALG)
+    return;
+  const acceptedHashes = new Set(sdArray.filter((entry) => typeof entry === "string"));
+  const disclosedClaims = {};
+  for (const encoded of parsed.disclosures) {
+    const hash = await sha2562(encoded);
+    if (!acceptedHashes.has(hash))
+      return;
+    const tuple = decodeDisclosure(encoded);
+    if (tuple === undefined)
+      return;
+    disclosedClaims[tuple.claimName] = tuple.claimValue;
+  }
+  const protectedClaims = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (key === "_sd" || key === "_sd_alg" || key === "cnf")
+      continue;
+    protectedClaims[key] = value;
+  }
+  const cnf = extractCnf(payload.cnf);
+  const result = {
+    cnf,
+    disclosedClaims,
+    keyBindingJwt: parsed.keyBindingJwt,
+    protectedClaims
+  };
+  return result;
+};
+var extractCnf = (value) => {
+  if (typeof value !== "object" || value === null)
+    return;
+  const jwk = Reflect.get(value, "jwk");
+  if (typeof jwk !== "object" || jwk === null)
+    return;
+  const candidate = jwk;
+  const narrowed = {
+    crv: typeof candidate.crv === "string" ? candidate.crv : undefined,
+    kty: typeof candidate.kty === "string" ? candidate.kty : undefined,
+    x: typeof candidate.x === "string" ? candidate.x : undefined,
+    y: typeof candidate.y === "string" ? candidate.y : undefined
+  };
+  return { jwk: narrowed };
+};
+
+// src/oidc/vci.ts
+var PRE_AUTHORIZED_CODE_GRANT = "urn:ietf:params:oauth:grant-type:pre-authorized_code";
+var MS_PER_SECOND2 = 1000;
+var DEFAULT_OFFER_TTL_MS = 600000;
+var DEFAULT_ACCESS_TTL_MS = 600000;
+var DEFAULT_NONCE_TTL_MS = 300000;
+var PRE_AUTH_CODE_BYTES = 32;
+var C_NONCE_BYTES = 16;
+var DEFAULT_VCI_ROUTE = "/vci";
+var nowSeconds2 = (timeMs) => Math.floor(timeMs / MS_PER_SECOND2);
+var createCredentialOffer = async ({
+  clientId,
+  configurationId,
+  now = Date.now(),
+  store,
+  ttlMs = DEFAULT_OFFER_TTL_MS,
+  userId
+}) => {
+  const preAuthorizedCode = generateSecureToken(PRE_AUTH_CODE_BYTES);
+  const preAuthorizedCodeHash = await hashToken(preAuthorizedCode);
+  const offer = {
+    clientId,
+    configurationId,
+    createdAt: now,
+    expiresAt: now + ttlMs,
+    preAuthorizedCodeHash,
+    redeemed: false,
+    userId
+  };
+  await store.saveOffer(offer);
+  return { offer, preAuthorizedCode };
+};
+var exchangePreAuthorizedCode = async ({
+  config,
+  issuer,
+  now = Date.now(),
+  preAuthorizedCode,
+  signingKey
+}) => {
+  const failFor = (error) => {
+    const failure = { error, ok: false };
+    return failure;
+  };
+  const hash = await hashToken(preAuthorizedCode);
+  const offer = await config.credentialOfferStore.consumeOffer(hash);
+  if (offer === undefined || offer.redeemed)
+    return failFor("invalid_grant");
+  if (offer.expiresAt < now)
+    return failFor("expired_token");
+  const ttlMs = config.accessTokenTtlMs ?? DEFAULT_ACCESS_TTL_MS;
+  const accessToken = await signJwt({
+    aud: issuer,
+    exp: nowSeconds2(now + ttlMs),
+    iat: nowSeconds2(now),
+    iss: issuer,
+    scope: `openid_credential:${offer.configurationId}`,
+    sub: offer.userId,
+    vci_configuration_id: offer.configurationId
+  }, signingKey);
+  const result = {
+    access_token: accessToken,
+    expires_in: Math.floor(ttlMs / MS_PER_SECOND2),
+    ok: true,
+    token_type: "Bearer"
+  };
+  if (config.credentialNonceStore !== undefined) {
+    const nonce = generateSecureToken(C_NONCE_BYTES);
+    const nonceTtlMs = config.nonceTtlMs ?? DEFAULT_NONCE_TTL_MS;
+    await config.credentialNonceStore.saveNonce({
+      expiresAt: now + nonceTtlMs,
+      nonceHash: await hashToken(nonce)
+    });
+    result.c_nonce = nonce;
+    result.c_nonce_expires_in = Math.floor(nonceTtlMs / MS_PER_SECOND2);
+  }
+  return result;
+};
+var decodeJwtHeader = (jwt) => {
+  const [header] = jwt.split(".");
+  if (header === undefined)
+    return;
+  try {
+    const decoded = JSON.parse(Buffer.from(header, "base64url").toString("utf8"));
+    if (typeof decoded !== "object" || decoded === null)
+      return;
+    return decoded;
+  } catch {
+    return;
+  }
+};
+var extractHolderJwk = (proofJwt) => {
+  const header = decodeJwtHeader(proofJwt);
+  if (header === undefined)
+    return;
+  const jwk = Reflect.get(header, "jwk");
+  if (typeof jwk !== "object" || jwk === null)
+    return;
+  const candidate = jwk;
+  return {
+    crv: typeof candidate.crv === "string" ? candidate.crv : undefined,
+    kty: typeof candidate.kty === "string" ? candidate.kty : undefined,
+    x: typeof candidate.x === "string" ? candidate.x : undefined,
+    y: typeof candidate.y === "string" ? candidate.y : undefined
+  };
+};
+var buildIssuerMetadata = ({
+  config,
+  issuer,
+  vciRoute
+}) => ({
+  credential_configurations_supported: Object.fromEntries(config.credentialConfigurations.map((configuration) => [
+    configuration.id,
+    {
+      claims: configuration.claims,
+      credential_signing_alg_values_supported: ["ES256"],
+      cryptographic_binding_methods_supported: ["jwk"],
+      display: configuration.display,
+      format: configuration.format,
+      order: configuration.order,
+      proof_types_supported: { jwt: { proof_signing_alg_values_supported: ["ES256"] } },
+      vct: configuration.vct
+    }
+  ])),
+  credential_endpoint: `${issuer}${vciRoute}/credential`,
+  credential_issuer: issuer,
+  nonce_endpoint: config.credentialNonceStore === undefined ? undefined : `${issuer}${vciRoute}/nonce`,
+  token_endpoint: `${issuer}/oauth2/token`
+});
+var issueOk = (credential) => {
+  const success = {
+    credential,
+    format: "vc+sd-jwt",
+    ok: true
+  };
+  return success;
+};
+var issueFail = (error) => {
+  const failure = { error, ok: false };
+  return failure;
+};
+var issueCredential = async ({
+  config,
+  input,
+  issuer,
+  now = Date.now(),
+  signingKey
+}) => {
+  const requested = input.requestedFormat ?? "vc+sd-jwt";
+  if (requested !== "vc+sd-jwt")
+    return issueFail("unsupported_credential_format");
+  const decoded = await verifyJwt(input.accessToken, signingKey.publicJwk);
+  if (decoded === undefined)
+    return issueFail("invalid_token");
+  const rawPayload = decoded.payload;
+  if (typeof rawPayload !== "object" || rawPayload === null) {
+    return issueFail("invalid_token");
+  }
+  const payload = { ...rawPayload };
+  if (typeof payload.exp === "number" && payload.exp * MS_PER_SECOND2 < now) {
+    return issueFail("invalid_token");
+  }
+  const userId = payload.sub;
+  const configurationId = payload.vci_configuration_id;
+  if (typeof userId !== "string" || typeof configurationId !== "string") {
+    return issueFail("invalid_token");
+  }
+  const configuration = config.credentialConfigurations.find((entry) => entry.id === configurationId);
+  if (configuration === undefined)
+    return issueFail("invalid_credential_request");
+  const holderJwk = input.proofJwt === undefined ? undefined : extractHolderJwk(input.proofJwt);
+  if (input.proofJwt !== undefined && holderJwk === undefined) {
+    return issueFail("invalid_proof");
+  }
+  const selective = await config.resolveCredentialClaims({
+    configurationId,
+    userId
+  });
+  const protectedClaims = config.resolveProtectedClaims ? await config.resolveProtectedClaims({ configurationId, userId }) : {};
+  const credential = await issueSdJwtVc({
+    base: {
+      iat: nowSeconds2(now),
+      iss: issuer,
+      ...protectedClaims,
+      vct: configuration.vct
+    },
+    holderJwk,
+    selective,
+    signingKey
+  });
+  return issueOk(credential);
+};
+
 // src/oidc/mtls.ts
 var RFC9440_HEADER = "client-cert";
 var SF_BINARY_PREFIX = ":";
@@ -5097,6 +5425,7 @@ var verifyCertificateBoundToken = async ({
 };
 
 // src/oidc/dpop.ts
+init_constants();
 var DEFAULT_MAX_AGE_MS = 60000;
 var SECONDS_TO_MS = 1000;
 var NONCE_WINDOW_SECONDS = 120;
@@ -5180,6 +5509,7 @@ var verifyDpopProof = async ({
 };
 
 // src/oidc/logout.ts
+init_constants();
 var BACKCHANNEL_LOGOUT_EVENT = "http://schemas.openid.net/event/backchannel-logout";
 var buildLogoutClaims = ({
   clientId,
@@ -5312,7 +5642,7 @@ var fanOutBackchannelLogout = async ({
 };
 
 // src/oidc/jar.ts
-var MS_PER_SECOND2 = 1000;
+var MS_PER_SECOND3 = 1000;
 var numberClaim = (value) => typeof value === "number" ? value : undefined;
 var stringClaim = (value) => typeof value === "string" ? value : undefined;
 var arrayClaim = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : undefined;
@@ -5337,7 +5667,7 @@ var parseSignedRequestObject = async ({
   if (!audMatches) {
     return { error: "invalid_request_object", ok: false };
   }
-  if (exp !== undefined && exp * MS_PER_SECOND2 <= now) {
+  if (exp !== undefined && exp * MS_PER_SECOND3 <= now) {
     return { error: "invalid_request_object", ok: false };
   }
   const envelope = new Set(["aud", "exp", "iat", "iss", "jti", "nbf"]);
@@ -5346,6 +5676,8 @@ var parseSignedRequestObject = async ({
 };
 
 // src/oidc/par.ts
+init_constants();
+init_crypto();
 var REQUEST_URI_BYTES = 32;
 var DEFAULT_PAR_TTL_SECONDS = 90;
 var DEFAULT_PAR_TTL_MS = DEFAULT_PAR_TTL_SECONDS * MILLISECONDS_IN_A_SECOND;
@@ -5455,6 +5787,7 @@ var fetchUserInfo = async ({
 var userInfoChallengeHeader = (error) => `Bearer realm="userinfo", error="${error}"`;
 
 // src/oidc/registration.ts
+init_crypto();
 var REG_TOKEN_BYTES = 32;
 var CLIENT_ID_BYTES = 16;
 var mintRegistrationToken = async (clientId) => {
@@ -5976,6 +6309,9 @@ var oidcProviderRoutes = (config) => {
   if (config.backchannelAuthStore) {
     grantTypes.push(CIBA_GRANT_TYPE);
   }
+  if (config.vciConfig !== undefined) {
+    grantTypes.push(PRE_AUTHORIZED_CODE_GRANT);
+  }
   const discovery = {
     authorization_endpoint: `${issuer}${authorizeRoute}`,
     backchannel_logout_session_supported: false,
@@ -6209,6 +6545,27 @@ var oidcProviderRoutes = (config) => {
       state: t12.Optional(t12.String())
     })
   }).post(tokenRoute, async ({ body, headers, request }) => {
+    if (body.grant_type === PRE_AUTHORIZED_CODE_GRANT && config.vciConfig !== undefined) {
+      const preAuthorizedCode = body["pre-authorized_code"];
+      if (typeof preAuthorizedCode !== "string") {
+        return oauthError2(HTTP_BAD_REQUEST2, "invalid_request");
+      }
+      const result = await exchangePreAuthorizedCode({
+        config: config.vciConfig,
+        issuer: config.issuer,
+        preAuthorizedCode,
+        signingKey: config.vciConfig.signingKey ?? config.signingKey
+      });
+      if (!result.ok)
+        return oauthError2(HTTP_BAD_REQUEST2, result.error);
+      return jsonResponse({
+        access_token: result.access_token,
+        c_nonce: result.c_nonce,
+        c_nonce_expires_in: result.c_nonce_expires_in,
+        expires_in: result.expires_in,
+        token_type: result.token_type
+      }, HTTP_OK2);
+    }
     const basic = readBasicAuth2(headers.authorization);
     const auth = await authenticateTokenClient({
       basicClientId: basic.clientId,
@@ -6254,6 +6611,7 @@ var oidcProviderRoutes = (config) => {
       code_verifier: t12.Optional(t12.String()),
       device_code: t12.Optional(t12.String()),
       grant_type: t12.Optional(t12.String()),
+      "pre-authorized_code": t12.Optional(t12.String()),
       redirect_uri: t12.Optional(t12.String()),
       refresh_token: t12.Optional(t12.String()),
       resource: t12.Optional(t12.String()),
@@ -6638,12 +6996,14 @@ var oidcProviderRoutes = (config) => {
 import { Elysia as Elysia16, t as t13 } from "elysia";
 
 // src/organizations/config.ts
+init_constants();
 var INVITATION_TTL_DAYS = 7;
 var DEFAULT_INVITATION_TTL_MS = MILLISECONDS_IN_A_DAY * INVITATION_TTL_DAYS;
 var DEFAULT_ORGANIZATIONS_ROUTE = "/auth/organizations";
 var DEFAULT_OWNER_ROLES = ["owner"];
 
 // src/organizations/operations.ts
+init_crypto();
 var acceptInvitation = async ({
   organizationStore,
   token,
@@ -6996,9 +7356,11 @@ var organizationRoutes = ({
 };
 
 // src/passwordless/routes.ts
+init_crypto();
 import { Elysia as Elysia17, t as t14 } from "elysia";
 
 // src/passwordless/config.ts
+init_constants();
 var SECONDS_IN_TEN_MINUTES = 600;
 var DEFAULT_OTP_DIGITS = 6;
 var DEFAULT_MAGIC_LINK_TTL_MS = MILLISECONDS_IN_A_SECOND * SECONDS_IN_TEN_MINUTES;
@@ -7132,6 +7494,7 @@ var passwordlessRoutes = ({
 import { Elysia as Elysia18, t as t15 } from "elysia";
 
 // src/scim/config.ts
+init_crypto();
 var DEFAULT_SCIM_ROUTE = "/scim/v2";
 var SCIM_TOKEN_BYTES = 32;
 var BEARER_PREFIX3 = "Bearer ";
@@ -7158,15 +7521,18 @@ var resolveScimOrganization = async (scimTokenStore, authorization) => {
 };
 
 // src/sso/config.ts
+init_constants();
 var DEFAULT_SSO_ROUTE = "/sso";
 var DEFAULT_SSO_SESSION_TTL_MS = MILLISECONDS_IN_A_DAY;
 
 // src/portal/config.ts
+init_constants();
 var SETUP_TTL_DAYS = 3;
 var DEFAULT_PORTAL_ROUTE = "/auth/portal";
 var DEFAULT_SETUP_SESSION_TTL_MS = MILLISECONDS_IN_A_DAY * SETUP_TTL_DAYS;
 
 // src/portal/operations.ts
+init_crypto();
 var BEARER_PREFIX4 = "Bearer ";
 var createSetupSession = async ({
   capabilities,
@@ -7593,6 +7959,7 @@ var resolveProviderClientConfiguration = ({
 };
 
 // src/routes/authorize.ts
+init_constants();
 import { Elysia as Elysia20, t as t17 } from "elysia";
 var parseReferer = (headerReferer) => {
   if (!headerReferer)
@@ -7968,6 +8335,7 @@ var profile = ({
 });
 
 // src/routes/refresh.ts
+init_constants();
 import { Elysia as Elysia23, t as t20 } from "elysia";
 var refresh = ({
   authSessionStore,
@@ -8936,6 +9304,7 @@ var scimRoutes = ({
 };
 
 // src/session/cleanup.ts
+init_constants();
 import { Elysia as Elysia30 } from "elysia";
 var sessionCleanup = ({
   authSessionStore,
@@ -9184,6 +9553,7 @@ var ssoDiscoveryRoute = ({
 };
 
 // src/sso/oidcRoutes.ts
+init_constants();
 import { Elysia as Elysia32, t as t28 } from "elysia";
 var makeSsoCookieOptions = (secure) => ({
   httpOnly: true,
@@ -9604,9 +9974,11 @@ var samlSsoRoutes = ({
 };
 
 // src/webauthn/routes.ts
+init_constants();
 import { Elysia as Elysia34, t as t30 } from "elysia";
 
 // src/webauthn/config.ts
+init_constants();
 var FIVE_MINUTES_MS = 300000;
 var DEFAULT_WEBAUTHN_CHALLENGE_TTL_MS = FIVE_MINUTES_MS;
 var DEFAULT_WEBAUTHN_ROUTE = "/auth/webauthn";
@@ -9792,7 +10164,11 @@ var webauthnRoutes = ({
   });
 };
 
+// src/webhooks/dispatcher.ts
+init_constants();
+
 // src/webhooks/config.ts
+init_constants();
 var DEFAULT_TIMEOUT_SECONDS = 5;
 var DEFAULT_RETRY_ATTEMPTS = 3;
 var DEFAULT_RETRY_INITIAL_DELAY_MS = MILLISECONDS_IN_A_SECOND;
@@ -9805,6 +10181,7 @@ var DEFAULT_WEBHOOK_RETRY = {
 var DEFAULT_WEBHOOK_TIMEOUT_MS = MILLISECONDS_IN_A_SECOND * DEFAULT_TIMEOUT_SECONDS;
 
 // src/webhooks/sign.ts
+init_crypto();
 var textEncoder2 = new TextEncoder;
 var importHmacKey = (secret) => crypto.subtle.importKey("raw", textEncoder2.encode(secret), { hash: "SHA-256", name: "HMAC" }, false, ["sign"]);
 var signWebhook = async ({
@@ -10032,6 +10409,7 @@ var createActionPipeline = (actions) => ({
   }
 });
 // src/compliance/cipher.ts
+init_crypto();
 var createSecretCipher = (keyMaterial) => ({
   decrypt: (ciphertext) => decryptSecret(ciphertext, keyMaterial),
   encrypt: (plaintext) => encryptSecret(plaintext, keyMaterial)
@@ -20791,6 +21169,7 @@ var createInMemoryLinkedProviderStores = (input = {}) => {
   return { bindingStore, grantStore };
 };
 // src/session/impersonation.ts
+init_constants();
 var DEFAULT_IMPERSONATION_TTL_MS = MILLISECONDS_IN_AN_HOUR;
 var endImpersonation = async ({
   authSessionStore,
@@ -20873,6 +21252,7 @@ var startImpersonation = async ({
   return sessionId;
 };
 // src/session/anonymous.ts
+init_constants();
 var DEFAULT_GUEST_TTL_MS = MILLISECONDS_IN_A_DAY;
 var createAnonymousSession = async ({
   authSessionStore,
@@ -20960,6 +21340,10 @@ var switchActiveSession = ({
   });
   return true;
 };
+
+// src/index.ts
+init_crypto();
+
 // src/tenancy.ts
 var hasOrganizationScope = (value) => typeof value.organizationId === "string" && value.organizationId.length > 0;
 // src/credentials/backgroundOps.ts
@@ -20969,7 +21353,7 @@ var DEFAULT_PAUSE_MS = 1700;
 var HIBP_NOT_FOUND = 404;
 var HIBP_RATE_LIMITED = 429;
 var MS_PER_DAY = 86400000;
-var MS_PER_SECOND3 = 1000;
+var MS_PER_SECOND4 = 1000;
 var sleep = (delayMs) => new Promise((resolve) => {
   setTimeout(resolve, delayMs);
 });
@@ -20995,7 +21379,7 @@ var checkEmailBreaches = async (email, apiKey, truncate) => {
   if (response.status === HIBP_RATE_LIMITED) {
     const retryAfter = Number(response.headers.get("retry-after") ?? "0");
     if (retryAfter > 0)
-      await sleep(retryAfter * MS_PER_SECOND3);
+      await sleep(retryAfter * MS_PER_SECOND4);
     return [];
   }
   if (!response.ok)
@@ -21650,6 +22034,7 @@ var defaultBotClassifier = (context) => {
   return "human";
 };
 // src/compliance/redaction.ts
+init_crypto();
 var createAuditRedactor = ({
   dropFields = [],
   hashFields = [],
@@ -21900,6 +22285,529 @@ var diffScimGroupMembers = (current, next) => {
   const removed = current.filter((member) => !nextValues.has(member.value));
   return { added, removed };
 };
+// src/oidc/inMemoryVciStores.ts
+var createInMemoryCredentialNonceStore = () => {
+  const nonces = new Map;
+  return {
+    consumeNonce: async (nonceHash) => {
+      const record = nonces.get(nonceHash);
+      if (record === undefined)
+        return;
+      nonces.delete(nonceHash);
+      return record;
+    },
+    saveNonce: async (record) => {
+      nonces.set(record.nonceHash, record);
+    }
+  };
+};
+var createInMemoryCredentialOfferStore = () => {
+  const offers = new Map;
+  return {
+    consumeOffer: async (preAuthorizedCodeHash) => {
+      const offer = offers.get(preAuthorizedCodeHash);
+      if (offer === undefined)
+        return;
+      offers.set(preAuthorizedCodeHash, { ...offer, redeemed: true });
+      return offer;
+    },
+    saveOffer: async (offer) => {
+      offers.set(offer.preAuthorizedCodeHash, offer);
+    }
+  };
+};
+// src/oidc/vciRoutes.ts
+import { Elysia as Elysia35, t as t31 } from "elysia";
+var HTTP_OK3 = 200;
+var HTTP_BAD_REQUEST3 = 400;
+var HTTP_UNAUTHORIZED3 = 401;
+var BEARER_PREFIX5 = "Bearer ";
+var errorBody = (error, status) => new Response(JSON.stringify({ error }), {
+  headers: { "content-type": "application/json" },
+  status
+});
+var extractBearer = (authorization) => {
+  if (authorization === undefined || !authorization.startsWith(BEARER_PREFIX5)) {
+    return;
+  }
+  const value = authorization.slice(BEARER_PREFIX5.length).trim();
+  return value.length === 0 ? undefined : value;
+};
+var vciRoutes = ({
+  issuerUrl,
+  signingKey,
+  vciConfig
+}) => {
+  const vciRoute = vciConfig.vciRoute ?? DEFAULT_VCI_ROUTE;
+  const credentialRoute = `${vciRoute}/credential`;
+  const nonceRoute = `${vciRoute}/nonce`;
+  const vciSigningKey = vciConfig.signingKey ?? signingKey;
+  return new Elysia35().get("/.well-known/openid-credential-issuer", () => Response.json(buildIssuerMetadata({ config: vciConfig, issuer: issuerUrl, vciRoute }))).post(credentialRoute, async ({ body, headers }) => {
+    const accessToken = extractBearer(headers.authorization);
+    if (accessToken === undefined) {
+      return errorBody("invalid_token", HTTP_UNAUTHORIZED3);
+    }
+    const result = await issueCredential({
+      config: vciConfig,
+      input: {
+        accessToken,
+        proofJwt: body.proof?.jwt,
+        requestedFormat: body.format
+      },
+      issuer: issuerUrl,
+      signingKey: vciSigningKey
+    });
+    if (!result.ok)
+      return errorBody(result.error, HTTP_BAD_REQUEST3);
+    return Response.json({ credential: result.credential, format: result.format }, { status: HTTP_OK3 });
+  }, {
+    body: t31.Object({
+      format: t31.Optional(t31.Union([t31.Literal("vc+sd-jwt")])),
+      proof: t31.Optional(t31.Object({
+        jwt: t31.String(),
+        proof_type: t31.Literal("jwt")
+      }))
+    })
+  }).post(nonceRoute, async () => {
+    if (vciConfig.credentialNonceStore === undefined) {
+      return errorBody("not_supported", HTTP_BAD_REQUEST3);
+    }
+    const { generateSecureToken: generateSecureToken2, hashToken: hashToken2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+    const nonceBytes = 16;
+    const nonce = generateSecureToken2(nonceBytes);
+    const ttlMs = vciConfig.nonceTtlMs ?? 300000;
+    await vciConfig.credentialNonceStore.saveNonce({
+      expiresAt: Date.now() + ttlMs,
+      nonceHash: await hashToken2(nonce)
+    });
+    const msPerSecond = 1000;
+    return Response.json({ c_nonce: nonce, c_nonce_expires_in: Math.floor(ttlMs / msPerSecond) }, { status: HTTP_OK3 });
+  });
+};
+// src/vc/statusList.ts
+var STATUS_LIST_TYP = "statuslist+jwt";
+var STATUS_LIST_SUB_TYP = "application/statuslist+jwt";
+var DEFAULT_LIST_SIZE = 131072;
+var BITS_PER_BYTE = 8;
+var MS_PER_SECOND5 = 1000;
+var BYTE_MASK = 255;
+var createStatusList = (size = DEFAULT_LIST_SIZE) => {
+  if (size % BITS_PER_BYTE !== 0) {
+    throw new Error("Status list size must be a multiple of 8");
+  }
+  return new Uint8Array(size / BITS_PER_BYTE);
+};
+var getCredentialStatus = (bits, idx) => {
+  const byteIndex = Math.floor(idx / BITS_PER_BYTE);
+  const bitIndex = idx % BITS_PER_BYTE;
+  if (byteIndex >= bits.length)
+    return;
+  const byte = bits[byteIndex] ?? 0;
+  return (byte >> bitIndex & 1) === 1 ? 1 : 0;
+};
+var setCredentialStatus = (bits, idx, value) => {
+  const byteIndex = Math.floor(idx / BITS_PER_BYTE);
+  const bitIndex = idx % BITS_PER_BYTE;
+  if (byteIndex >= bits.length) {
+    throw new Error(`Status idx ${idx} out of range for this list`);
+  }
+  const current = bits[byteIndex] ?? 0;
+  const mask = 1 << bitIndex;
+  const next = value === 1 ? current | mask : current & (BYTE_MASK ^ mask);
+  bits[byteIndex] = next;
+  return bits;
+};
+var compress = async (bits) => {
+  const blob = new Blob([new Uint8Array(bits)]);
+  const stream = new Response(blob.stream().pipeThrough(new CompressionStream("deflate")));
+  const compressed = new Uint8Array(await stream.arrayBuffer());
+  return Buffer.from(compressed).toString("base64url");
+};
+var decompress = async (encoded) => {
+  const compressed = Buffer.from(encoded, "base64url");
+  const blob = new Blob([new Uint8Array(compressed)]);
+  const stream = new Response(blob.stream().pipeThrough(new DecompressionStream("deflate")));
+  return new Uint8Array(await stream.arrayBuffer());
+};
+var nowSeconds3 = (timeMs) => Math.floor(timeMs / MS_PER_SECOND5);
+var buildStatusClaim = (idx, uri) => ({
+  status_list: { idx, uri }
+});
+var signStatusList = async ({
+  bits,
+  issuer,
+  listUri,
+  now = Date.now(),
+  signingKey,
+  ttlSeconds
+}) => {
+  const payload = {
+    iat: nowSeconds3(now),
+    iss: issuer,
+    status_list: {
+      bits: 1,
+      lst: await compress(bits)
+    },
+    sub: listUri,
+    ttl: ttlSeconds
+  };
+  if (ttlSeconds !== undefined) {
+    payload.exp = nowSeconds3(now) + ttlSeconds;
+  }
+  return signJwt(payload, signingKey);
+};
+var verifyStatusListJwt = async ({
+  issuerPublicJwk,
+  token
+}) => {
+  const decoded = await verifyJwt(token, issuerPublicJwk);
+  if (decoded === undefined)
+    return;
+  const rawPayload = decoded.payload;
+  if (typeof rawPayload !== "object" || rawPayload === null)
+    return;
+  const payload = { ...rawPayload };
+  const statusList = payload.status_list;
+  if (typeof statusList !== "object" || statusList === null)
+    return;
+  const lst = Reflect.get(statusList, "lst");
+  const bitsPerEntry = Reflect.get(statusList, "bits");
+  if (typeof lst !== "string")
+    return;
+  if (bitsPerEntry !== undefined && bitsPerEntry !== 1) {
+    return;
+  }
+  const bits = await decompress(lst);
+  return { bits, sub: typeof payload.sub === "string" ? payload.sub : undefined };
+};
+// src/vc/statusListRoutes.ts
+import { Elysia as Elysia36, t as t32 } from "elysia";
+var HTTP_OK4 = 200;
+var HTTP_NOT_FOUND = 404;
+var DEFAULT_STATUS_ROUTE = "/vc/status";
+var statusListRoutes = ({
+  getStatusList,
+  issuerUrl,
+  signingKey,
+  statusRoute = DEFAULT_STATUS_ROUTE,
+  ttlSeconds
+}) => {
+  const listRoute = `${statusRoute}/:listId`;
+  return new Elysia36().get(listRoute, async ({ params: { listId } }) => {
+    const bits = await getStatusList(listId);
+    if (bits === undefined) {
+      return new Response("Not found", { status: HTTP_NOT_FOUND });
+    }
+    const jwt = await signStatusList({
+      bits,
+      issuer: issuerUrl,
+      listUri: `${issuerUrl}${statusRoute}/${listId}`,
+      signingKey,
+      ttlSeconds
+    });
+    return new Response(jwt, {
+      headers: { "content-type": STATUS_LIST_SUB_TYP },
+      status: HTTP_OK4
+    });
+  }, { params: t32.Object({ listId: t32.String() }) });
+};
+// src/vc/openid4vp.ts
+init_crypto();
+var REQUEST_BYTES = 16;
+var DEFAULT_REQUEST_TTL_MS = 600000;
+var MS_PER_SECOND6 = 1000;
+var createPresentationRequest = async ({
+  config,
+  getRequestUri,
+  input,
+  issuer
+}) => {
+  const requestId = generateSecureToken(REQUEST_BYTES);
+  const nonce = generateSecureToken(REQUEST_BYTES);
+  const now = input.now ?? Date.now();
+  const ttlMs = config.requestTtlMs ?? DEFAULT_REQUEST_TTL_MS;
+  const request = {
+    clientId: input.clientId,
+    createdAt: now,
+    expectedIssuerPublicJwk: config.defaultExpectedIssuerPublicJwk,
+    expiresAt: now + ttlMs,
+    nonce,
+    requestedClaims: input.requestedClaims,
+    requestId,
+    responseUri: config.getResponseUri(requestId),
+    state: input.state
+  };
+  await config.requestStore.saveRequest(request);
+  const requestObject = await signJwt({
+    aud: "https://self-issued.me/v2",
+    client_id: input.clientId,
+    iat: Math.floor(now / MS_PER_SECOND6),
+    iss: issuer,
+    nonce,
+    presentation_definition: buildSimplePresentationDefinition(requestId, input.requestedClaims),
+    response_mode: "direct_post",
+    response_type: "vp_token",
+    response_uri: request.responseUri,
+    state: input.state
+  }, config.clientSigningKey);
+  return {
+    nonce,
+    request,
+    requestObject,
+    requestUri: getRequestUri(requestId)
+  };
+};
+var buildSimplePresentationDefinition = (requestId, requestedClaims) => ({
+  id: requestId,
+  input_descriptors: [
+    {
+      constraints: {
+        fields: requestedClaims.map((claim) => ({
+          path: [`$.${claim}`]
+        })),
+        limit_disclosure: "required"
+      },
+      format: { "vc+sd-jwt": { "sd-jwt_alg_values": ["ES256"] } },
+      id: "sd-jwt-vc",
+      name: "SD-JWT VC",
+      purpose: "Verify holder claims"
+    }
+  ]
+});
+var verifyPresentationResponse = async ({
+  config,
+  input,
+  now = Date.now()
+}) => {
+  const failFor = (error) => {
+    const failure = { error, ok: false };
+    return failure;
+  };
+  const request = await config.requestStore.consumeRequest(input.requestId);
+  if (request === undefined)
+    return failFor("unknown_request");
+  if (request.expiresAt < now)
+    return failFor("expired_request");
+  const verified = await verifySdJwtVc({
+    issuerPublicJwk: request.expectedIssuerPublicJwk,
+    token: input.vpToken
+  });
+  if (verified === undefined)
+    return failFor("invalid_signature");
+  if (verified.cnf !== undefined) {
+    if (verified.keyBindingJwt === undefined) {
+      return failFor("invalid_holder_binding");
+    }
+    const valid = await verifyHolderBinding({
+      audience: request.clientId,
+      holderJwk: verified.cnf.jwk,
+      keyBindingJwt: verified.keyBindingJwt,
+      nonce: request.nonce
+    });
+    if (!valid)
+      return failFor("invalid_holder_binding");
+  }
+  const missingClaims = request.requestedClaims.filter((claim) => !(claim in verified.disclosedClaims));
+  if (missingClaims.length > 0)
+    return failFor("missing_claims");
+  const statusValid = await checkStatus({
+    config,
+    credentialClaims: verified.protectedClaims
+  });
+  if (!statusValid)
+    return failFor("revoked_credential");
+  const success = {
+    ok: true,
+    verified: {
+      disclosedClaims: verified.disclosedClaims,
+      holderJwk: verified.cnf?.jwk,
+      missingClaims,
+      protectedClaims: verified.protectedClaims,
+      requestId: request.requestId,
+      statusValid: true
+    }
+  };
+  return success;
+};
+var verifyHolderBinding = async ({
+  audience,
+  holderJwk,
+  keyBindingJwt,
+  nonce
+}) => {
+  const decoded = await verifyJwt(keyBindingJwt, holderJwk);
+  if (decoded === undefined)
+    return false;
+  const rawPayload = decoded.payload;
+  if (typeof rawPayload !== "object" || rawPayload === null)
+    return false;
+  const payload = { ...rawPayload };
+  if (payload.aud !== audience)
+    return false;
+  if (payload.nonce !== nonce)
+    return false;
+  if (typeof payload.iat !== "number")
+    return false;
+  return true;
+};
+var checkStatus = async ({
+  config,
+  credentialClaims
+}) => {
+  if (config.statusListResolver === undefined)
+    return true;
+  if (config.statusListPublicJwk === undefined)
+    return true;
+  const { status } = credentialClaims;
+  if (typeof status !== "object" || status === null)
+    return true;
+  const list = Reflect.get(status, "status_list");
+  if (typeof list !== "object" || list === null)
+    return true;
+  const uri = Reflect.get(list, "uri");
+  const idx = Reflect.get(list, "idx");
+  if (typeof uri !== "string" || typeof idx !== "number")
+    return true;
+  const token = await config.statusListResolver(uri);
+  if (token === undefined)
+    return true;
+  const verified = await verifyStatusListJwt({
+    issuerPublicJwk: config.statusListPublicJwk,
+    token
+  });
+  if (verified === undefined)
+    return false;
+  const bitsPerByte = 8;
+  const byteIndex = Math.floor(idx / bitsPerByte);
+  const bitIndex = idx % bitsPerByte;
+  const byte = verified.bits[byteIndex] ?? 0;
+  return (byte >> bitIndex & 1) === 0;
+};
+var buildHolderKeyBindingJwt = async ({
+  audience,
+  holderKey,
+  nonce,
+  now = Date.now(),
+  sdHash
+}) => signJwt({
+  aud: audience,
+  iat: Math.floor(now / MS_PER_SECOND6),
+  nonce,
+  sd_hash: sdHash
+}, holderKey);
+var parsePresentationToken = (vpToken) => parseSdJwtVc(vpToken);
+// src/vc/inMemoryVpStores.ts
+var createInMemoryPresentationRequestStore = () => {
+  const requests = new Map;
+  return {
+    consumeRequest: async (requestId) => {
+      const request = requests.get(requestId);
+      if (request === undefined)
+        return;
+      requests.delete(requestId);
+      return request;
+    },
+    getRequest: async (requestId) => requests.get(requestId),
+    saveRequest: async (request) => {
+      requests.set(request.requestId, request);
+    }
+  };
+};
+// src/vc/vpRoutes.ts
+import { Elysia as Elysia37, t as t33 } from "elysia";
+var HTTP_OK5 = 200;
+var HTTP_BAD_REQUEST4 = 400;
+var HTTP_NOT_FOUND2 = 404;
+var errorBody2 = (error, status) => new Response(JSON.stringify({ error }), {
+  headers: { "content-type": "application/json" },
+  status
+});
+var DEFAULT_VP_ROUTE = "/vp";
+var vpRoutes = ({
+  defaultClientId,
+  issuerUrl,
+  onVerifiedPresentation,
+  vpConfig,
+  vpRoute = DEFAULT_VP_ROUTE
+}) => {
+  const authorizeRoute = `${vpRoute}/authorize`;
+  const requestRoute = `${vpRoute}/request/:id`;
+  const responseRoute = `${vpRoute}/response`;
+  return new Elysia37().post(authorizeRoute, async ({ body }) => {
+    const input = {
+      clientId: body.client_id ?? defaultClientId,
+      requestedClaims: body.requested_claims,
+      state: body.state
+    };
+    const result = await createPresentationRequest({
+      config: vpConfig,
+      input,
+      issuer: issuerUrl,
+      getRequestUri: (id) => `${issuerUrl}${vpRoute}/request/${id}`
+    });
+    return Response.json({
+      nonce: result.nonce,
+      request_uri: result.requestUri,
+      requestId: result.request.requestId
+    }, { status: HTTP_OK5 });
+  }, {
+    body: t33.Object({
+      client_id: t33.Optional(t33.String()),
+      requested_claims: t33.Array(t33.String()),
+      state: t33.Optional(t33.String())
+    })
+  }).get(requestRoute, async ({ params: { id } }) => {
+    const stored = await vpConfig.requestStore.getRequest(id);
+    if (stored === undefined) {
+      return errorBody2("unknown_request", HTTP_NOT_FOUND2);
+    }
+    const rebuilt = await createPresentationRequest({
+      config: { ...vpConfig, requestStore: passthroughStore(stored) },
+      input: {
+        clientId: stored.clientId,
+        requestedClaims: stored.requestedClaims,
+        state: stored.state
+      },
+      issuer: issuerUrl,
+      getRequestUri: () => `${issuerUrl}${vpRoute}/request/${id}`
+    });
+    return new Response(rebuilt.requestObject, {
+      headers: { "content-type": "application/oauth-authz-req+jwt" },
+      status: HTTP_OK5
+    });
+  }, { params: t33.Object({ id: t33.String() }) }).post(responseRoute, async ({ body }) => {
+    const requestId = body.state;
+    if (requestId === undefined) {
+      return errorBody2("missing_state", HTTP_BAD_REQUEST4);
+    }
+    const result = await verifyPresentationResponse({
+      config: vpConfig,
+      input: { requestId, vpToken: body.vp_token }
+    });
+    if (!result.ok)
+      return errorBody2(result.error, HTTP_BAD_REQUEST4);
+    if (onVerifiedPresentation !== undefined) {
+      await onVerifiedPresentation({ verified: result.verified });
+    }
+    return Response.json({
+      disclosed_claims: result.verified.disclosedClaims,
+      holder_jwk: result.verified.holderJwk,
+      protected_claims: result.verified.protectedClaims,
+      verified: true
+    }, { status: HTTP_OK5 });
+  }, {
+    body: t33.Object({
+      presentation_submission: t33.Optional(t33.Unknown()),
+      state: t33.Optional(t33.String()),
+      vp_token: t33.String()
+    })
+  });
+};
+var passthroughStore = (request) => ({
+  consumeRequest: async () => request,
+  getRequest: async () => request,
+  saveRequest: async () => {}
+});
 // src/scim/inMemoryScimTokenStore.ts
 var createInMemoryScimTokenStore = () => {
   const tokens = new Map;
@@ -22770,6 +23678,7 @@ var createPostgresBackchannelAuthStore = (db) => ({
   }
 });
 // src/adaptive/config.ts
+init_constants();
 var DEFAULT_HISTORY_LIMIT = 50;
 var DEFAULT_MAX_TRAVEL_KMH = 900;
 var DEFAULT_VELOCITY_MAX_ATTEMPTS = 5;
@@ -22944,6 +23853,7 @@ var trustDevice = async (config, userId, deviceId, label) => {
   });
 };
 // src/adaptive/fingerprint.ts
+init_crypto();
 var canonical = (signals) => JSON.stringify(signals, (_key, value) => value === null || typeof value !== "object" || Array.isArray(value) ? value : Object.fromEntries(Object.entries(value).sort((left, right) => left[0].localeCompare(right[0]))));
 var fingerprintDevice = (signals) => hashToken(canonical(signals));
 // src/adaptive/inMemoryStores.ts
@@ -24061,18 +24971,18 @@ var blockMigrations = {
   webhooks: initMigration("webhooks", [webhookDeliveriesTable])
 };
 // src/sso/samlIdpRoutes.ts
-import { Elysia as Elysia35, t as t31 } from "elysia";
-var HTTP_BAD_REQUEST3 = 400;
-var HTTP_UNAUTHORIZED3 = 401;
+import { Elysia as Elysia38, t as t34 } from "elysia";
+var HTTP_BAD_REQUEST5 = 400;
+var HTTP_UNAUTHORIZED4 = 401;
 var HTTP_FOUND2 = 302;
-var HTTP_OK3 = 200;
+var HTTP_OK6 = 200;
 var xmlResponse = (body) => new Response(body, {
   headers: { "content-type": "application/samlmetadata+xml" },
-  status: HTTP_OK3
+  status: HTTP_OK6
 });
 var htmlResponse = (body) => new Response(body, {
   headers: { "content-type": "text/html; charset=utf-8" },
-  status: HTTP_OK3
+  status: HTTP_OK6
 });
 var redirectTo2 = (url) => new Response(null, { headers: { location: url }, status: HTTP_FOUND2 });
 var errorJson = (status, error) => new Response(JSON.stringify({ error }), {
@@ -24124,7 +25034,7 @@ var samlIdpRoutes = ({
     userSessionIdValue
   }) => {
     if (body.SAMLRequest === undefined) {
-      return errorJson(HTTP_BAD_REQUEST3, "missing_saml_request");
+      return errorJson(HTTP_BAD_REQUEST5, "missing_saml_request");
     }
     let firstPass;
     try {
@@ -24133,11 +25043,11 @@ var samlIdpRoutes = ({
         samlRequest: body.SAMLRequest
       });
     } catch {
-      return errorJson(HTTP_BAD_REQUEST3, "invalid_authn_request");
+      return errorJson(HTTP_BAD_REQUEST5, "invalid_authn_request");
     }
     const serviceProvider = await samlServiceProviderStore.findServiceProvider(firstPass.issuer);
     if (serviceProvider === undefined) {
-      return errorJson(HTTP_BAD_REQUEST3, "unknown_service_provider");
+      return errorJson(HTTP_BAD_REQUEST5, "unknown_service_provider");
     }
     let parsed;
     try {
@@ -24150,7 +25060,7 @@ var samlIdpRoutes = ({
         signedQueryString: binding === "Redirect" ? new URL(request.url).search.slice(1) : undefined
       });
     } catch {
-      return errorJson(HTTP_BAD_REQUEST3, "invalid_authn_request");
+      return errorJson(HTTP_BAD_REQUEST5, "invalid_authn_request");
     }
     const userSession = await loadSessionFromSource({
       authSessionStore,
@@ -24159,7 +25069,7 @@ var samlIdpRoutes = ({
     });
     if (userSession === undefined || parsed.forceAuthn === true) {
       if (loginUrl === undefined) {
-        return errorJson(HTTP_UNAUTHORIZED3, "login_required");
+        return errorJson(HTTP_UNAUTHORIZED4, "login_required");
       }
       return redirectTo2(`${loginUrl}?return_to=${encodeURIComponent(request.url)}`);
     }
@@ -24171,7 +25081,7 @@ var samlIdpRoutes = ({
       user: userSession.user
     });
   };
-  return new Elysia35().use(sessionStore()).post(ssoIdpRoute, async ({
+  return new Elysia38().use(sessionStore()).post(ssoIdpRoute, async ({
     body,
     cookie: { user_session_id },
     request,
@@ -24183,12 +25093,12 @@ var samlIdpRoutes = ({
     request,
     userSessionIdValue: user_session_id.value
   }), {
-    body: t31.Object({
-      RelayState: t31.Optional(t31.String()),
-      SAMLRequest: t31.Optional(t31.String())
+    body: t34.Object({
+      RelayState: t34.Optional(t34.String()),
+      SAMLRequest: t34.Optional(t34.String())
     }),
-    cookie: t31.Cookie({
-      user_session_id: t31.Optional(userSessionIdTypebox)
+    cookie: t34.Cookie({
+      user_session_id: t34.Optional(userSessionIdTypebox)
     })
   }).get(ssoIdpRoute, async ({
     cookie: { user_session_id },
@@ -24202,14 +25112,14 @@ var samlIdpRoutes = ({
     request,
     userSessionIdValue: user_session_id.value
   }), {
-    cookie: t31.Cookie({
-      user_session_id: t31.Optional(userSessionIdTypebox)
+    cookie: t34.Cookie({
+      user_session_id: t34.Optional(userSessionIdTypebox)
     }),
-    query: t31.Object({
-      RelayState: t31.Optional(t31.String()),
-      SAMLRequest: t31.Optional(t31.String()),
-      SigAlg: t31.Optional(t31.String()),
-      Signature: t31.Optional(t31.String())
+    query: t34.Object({
+      RelayState: t34.Optional(t34.String()),
+      SAMLRequest: t34.Optional(t34.String()),
+      SigAlg: t34.Optional(t34.String()),
+      Signature: t34.Optional(t34.String())
     })
   }).get(idpInitiateRoute, async ({
     cookie: { user_session_id },
@@ -24218,11 +25128,11 @@ var samlIdpRoutes = ({
     store
   }) => {
     if (serviceProviderEntityId === undefined) {
-      return errorJson(HTTP_BAD_REQUEST3, "missing_sp");
+      return errorJson(HTTP_BAD_REQUEST5, "missing_sp");
     }
     const serviceProvider = await samlServiceProviderStore.findServiceProvider(serviceProviderEntityId);
     if (serviceProvider === undefined) {
-      return errorJson(HTTP_BAD_REQUEST3, "unknown_service_provider");
+      return errorJson(HTTP_BAD_REQUEST5, "unknown_service_provider");
     }
     const userSession = authSessionStore === undefined ? await loadSessionFromSource({
       session: store.session,
@@ -24234,7 +25144,7 @@ var samlIdpRoutes = ({
     });
     if (userSession === undefined) {
       if (loginUrl === undefined) {
-        return errorJson(HTTP_UNAUTHORIZED3, "login_required");
+        return errorJson(HTTP_UNAUTHORIZED4, "login_required");
       }
       return redirectTo2(`${loginUrl}?return_to=${encodeURIComponent(request.url)}`);
     }
@@ -24245,12 +25155,12 @@ var samlIdpRoutes = ({
       user: userSession.user
     });
   }, {
-    cookie: t31.Cookie({
-      user_session_id: t31.Optional(userSessionIdTypebox)
+    cookie: t34.Cookie({
+      user_session_id: t34.Optional(userSessionIdTypebox)
     }),
-    query: t31.Object({
-      RelayState: t31.Optional(t31.String()),
-      sp: t31.Optional(t31.String())
+    query: t34.Object({
+      RelayState: t34.Optional(t34.String()),
+      sp: t34.Optional(t34.String())
     })
   }).get(idpMetadataRoute, async ({ request }) => xmlResponse(await idpAdapter.getIdpMetadata({
     entityId: idpEntityId,
@@ -24548,7 +25458,7 @@ var auth = async ({
   const auditedOnCallbackSuccess = auditEmit ? composeCallbackAudit(onCallbackSuccess, auditEmit) : onCallbackSuccess;
   const auditedOnRevocationSuccess = auditEmit ? composeRevocationAudit(onRevocationSuccess, auditEmit) : onRevocationSuccess;
   const auditedOnSignOut = auditEmit ? composeSignOutAudit(onSignOut, auditEmit) : onSignOut;
-  return new Elysia36().use(sessionCleanup({
+  return new Elysia39().use(sessionCleanup({
     authSessionStore,
     cleanupIntervalMs,
     maxSessions,
@@ -24596,53 +25506,53 @@ var auth = async ({
     authSessionStore,
     cookieSecure: resolvedCookieSecure,
     lockoutGuard
-  }) : new Elysia36).use(auditedMfa ? mfaRoutes({
+  }) : new Elysia39).use(auditedMfa ? mfaRoutes({
     ...auditedMfa,
     authSessionStore,
     cookieSecure: resolvedCookieSecure
-  }) : new Elysia36).use(passwordless ? passwordlessRoutes({
+  }) : new Elysia39).use(passwordless ? passwordlessRoutes({
     ...passwordless,
     authSessionStore,
     cookieSecure: resolvedCookieSecure,
     emit: auditEmit
-  }) : new Elysia36).use(sessions ? sessionRoutes({ ...sessions, authSessionStore }) : new Elysia36).use(sso ? oidcSsoRoutes({
+  }) : new Elysia39).use(sessions ? sessionRoutes({ ...sessions, authSessionStore }) : new Elysia39).use(sso ? oidcSsoRoutes({
     ...sso,
     authSessionStore,
     cookieSecure: resolvedCookieSecure
-  }) : new Elysia36).use(sso && sso.samlAdapter ? samlSsoRoutes({
+  }) : new Elysia39).use(sso && sso.samlAdapter ? samlSsoRoutes({
     ...sso,
     authSessionStore,
     cookieSecure: resolvedCookieSecure,
     samlAdapter: sso.samlAdapter
-  }) : new Elysia36).use(sso && sso.getOrganizationByEmailDomain ? ssoDiscoveryRoute({
+  }) : new Elysia39).use(sso && sso.getOrganizationByEmailDomain ? ssoDiscoveryRoute({
     getOrganizationByEmailDomain: sso.getOrganizationByEmailDomain,
     ssoConnectionStore: sso.ssoConnectionStore,
     ssoRoute: sso.ssoRoute
-  }) : new Elysia36).use(scim ? scimRoutes(scim) : new Elysia36).use(apikeys ? apiKeysRoutes(apikeys) : new Elysia36).use(oidc ? oidcProviderRoutes({ ...oidc, authSessionStore }) : new Elysia36).use(organizations ? organizationRoutes({
+  }) : new Elysia39).use(scim ? scimRoutes(scim) : new Elysia39).use(apikeys ? apiKeysRoutes(apikeys) : new Elysia39).use(oidc ? oidcProviderRoutes({ ...oidc, authSessionStore }) : new Elysia39).use(organizations ? organizationRoutes({
     ...organizations,
     authSessionStore,
     emit: auditEmit
-  }) : new Elysia36).use(roles ? roleRoutes({
+  }) : new Elysia39).use(roles ? roleRoutes({
     ...roles,
     authSessionStore,
     emit: auditEmit
-  }) : new Elysia36).use(portal ? portalRoutes({ ...portal, emit: auditEmit }) : new Elysia36).use(webauthn ? webauthnRoutes({
+  }) : new Elysia39).use(portal ? portalRoutes({ ...portal, emit: auditEmit }) : new Elysia39).use(webauthn ? webauthnRoutes({
     ...webauthn,
     authSessionStore,
     cookieSecure: resolvedCookieSecure,
     emit: auditEmit
-  }) : new Elysia36).use(compliance ? complianceRoutes({
+  }) : new Elysia39).use(compliance ? complianceRoutes({
     ...compliance,
     authSessionStore,
     emit: auditEmit
-  }) : new Elysia36).use(protectRoutePlugin({ authSessionStore })).use(stepUpPlugin({ authSessionStore })).use(authorization ? protectPermissionPlugin({
+  }) : new Elysia39).use(protectRoutePlugin({ authSessionStore })).use(stepUpPlugin({ authSessionStore })).use(authorization ? protectPermissionPlugin({
     ...authorization,
     authSessionStore,
     emit: auditEmit
-  }) : new Elysia36).use(htmx ? createAuthHtmxRoutes({
+  }) : new Elysia39).use(htmx ? createAuthHtmxRoutes({
     ...htmx,
     authSessionStore
-  }) : new Elysia36);
+  }) : new Elysia39);
 };
 export {
   writeWarrant,
@@ -24652,10 +25562,14 @@ export {
   webauthnCredentialsTable,
   warrantsTable,
   warrantKey,
+  vpRoutes,
   verifyWebhookSignature,
   verifyTurnstile,
   verifyTotp,
+  verifyStatusListJwt,
+  verifySdJwtVc,
   verifyRecaptcha,
+  verifyPresentationResponse,
   verifyPkce,
   verifyPassword,
   verifyJwtSignedByClient,
@@ -24671,6 +25585,7 @@ export {
   verifyAuditChain,
   verifyApiKey,
   verifyAccessToken,
+  vciRoutes,
   vaultEntriesTable,
   validateSession,
   validateEmailDeliverability,
@@ -24679,15 +25594,19 @@ export {
   updateRegisteredClient,
   trustDevice,
   toPublicJwk,
+  toBase64Url2 as toBase64Url,
   switchActiveSession,
   stepUpPlugin,
+  statusListRoutes,
   startImpersonation,
   ssoDiscoveryRoute,
   ssoConnectionsTable,
   signWebhook,
+  signStatusList,
   signJwt,
   setupSessionsTable,
   setMemberRoles,
+  setCredentialStatus,
   sessionStore,
   sessionRoutes,
   sessionCleanup,
@@ -24732,12 +25651,15 @@ export {
   providerOptions,
   protectRoutePlugin,
   protectPermissionPlugin,
+  presentSdJwtVc,
   portalRoutes,
   pkceProviderOptions,
   passwordlessTokensTable,
   passwordlessRoutes,
   parseSignedRequestObject,
+  parseSdJwtVc,
   parseSchema,
+  parsePresentationToken,
   organizationsTable,
   organizationRoutes,
   organizationMembershipsTable,
@@ -24772,7 +25694,9 @@ export {
   knownDevicesTable,
   jwkThumbprint,
   issueTokenSet,
+  issueSdJwtVc,
   issueDeviceAuthorization,
+  issueCredential,
   issueBackchannelAuth,
   isValidUser,
   isValidProviderOption,
@@ -24805,12 +25729,14 @@ export {
   getStatus,
   getRegisteredClient,
   getOrRefreshFederatedTokens,
+  getCredentialStatus,
   generateTotpSecret,
   generateTotp,
   generateSigningKey,
   generateSecureToken,
   generateEncryptionKey,
   generateBackupCodes,
+  fromBase64Url2 as fromBase64Url,
   fingerprintDevice,
   fetchUserInfo,
   fanOutBackchannelLogout,
@@ -24819,6 +25745,7 @@ export {
   extractDpopNonceClaim,
   exportAuditCsv,
   exchangeToken,
+  exchangePreAuthorizedCode,
   exchangeDeviceCode,
   exchangeClientCredentials,
   exchangeBackchannelAuth,
@@ -24852,6 +25779,7 @@ export {
   createVault,
   createTotpKeyUri,
   createTamperEvidentSink,
+  createStatusList,
   createSiemLogStream,
   createSetupSession,
   createSecretCipher,
@@ -24860,6 +25788,7 @@ export {
   createRedisLockoutStore,
   createRedisFgaCache,
   createRedisAuthSessionStore,
+  createPresentationRequest,
   createPostgresWebhookDeliveryStore,
   createPostgresWebAuthnCredentialStore,
   createPostgresWarrantStore,
@@ -24940,6 +25869,7 @@ export {
   createInMemorySamlServiceProviderStore,
   createInMemoryRoleStore,
   createInMemoryPushedAuthorizationRequestStore,
+  createInMemoryPresentationRequestStore,
   createInMemoryPasswordlessTokenStore,
   createInMemoryOrganizationStore,
   createInMemoryOidcRefreshTokenStore,
@@ -24953,6 +25883,8 @@ export {
   createInMemoryInitialAccessTokenStore,
   createInMemoryDeviceAuthorizationStore,
   createInMemoryCredentialStore,
+  createInMemoryCredentialOfferStore,
+  createInMemoryCredentialNonceStore,
   createInMemoryClientRegistrationTokenStore,
   createInMemoryClientAssertionJtiStore,
   createInMemoryCheckCache,
@@ -24965,6 +25897,7 @@ export {
   createInMemoryAccessTokenStore,
   createFgaEngine,
   createFederatedTokenStore,
+  createCredentialOffer,
   createAuthHtmxRoutes,
   createAuditRedactor,
   createAuditEmitter,
@@ -24979,6 +25912,9 @@ export {
   computeCertThumbprint,
   complianceRoutes,
   check,
+  buildStatusClaim,
+  buildIssuerMetadata,
+  buildHolderKeyBindingJwt,
   buildClientProviders,
   blockMigrations,
   base32Encode,
@@ -24999,14 +25935,20 @@ export {
   accessTokensTable,
   acceptInvitation,
   WEBAUTHN_CHALLENGE_COOKIE,
+  STATUS_LIST_TYP,
+  STATUS_LIST_SUB_TYP,
   REQUEST_URI_PREFIX,
+  PRE_AUTHORIZED_CODE_GRANT,
   DEFAULT_WEBHOOK_TIMEOUT_MS,
   DEFAULT_WEBHOOK_RETRY,
   DEFAULT_WEBAUTHN_SESSION_TTL_MS,
   DEFAULT_WEBAUTHN_ROUTE,
   DEFAULT_WEBAUTHN_CHALLENGE_TTL_MS,
+  DEFAULT_VP_ROUTE,
   DEFAULT_VERIFICATION_TOKEN_TTL_MS,
+  DEFAULT_VCI_ROUTE,
   DEFAULT_TOKEN_ROUTE,
+  DEFAULT_STATUS_ROUTE,
   DEFAULT_SSO_SESSION_TTL_MS,
   DEFAULT_SSO_ROUTE,
   DEFAULT_SETUP_SESSION_TTL_MS,
@@ -25033,5 +25975,5 @@ export {
   AuthIdentityConflictError
 };
 
-//# debugId=5A0B79F67182545764756E2164756E21
+//# debugId=6D61B26FBEAED15664756E2164756E21
 //# sourceMappingURL=index.js.map