@tdacorp/identity-client 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,80 @@
+import { createRemoteJWKSet } from 'jose';
+export { A as AuthorizationCodeExchangeOptions, C as CLOCK_SKEW_TOLERANCE_SECONDS, a as ClientCredentialsGrantOptions, I as IdTokenClaims, R as RefreshTokensOptions, T as TokenRefreshOutcome, b as TokenRequestError, c as TokenSet, d as TokenVerificationError, e as TokenVerificationErrorCode, V as VerificationResult, f as VerifiedAccessToken, g as VerifyTokenOptions, h as clientCredentialsGrant, i as exchangeAuthorizationCode, r as refreshTokens, v as verifyAccessToken, j as verifyIdToken } from './verify-BiGhwaIz.cjs';
+import '@tdacorp/identity-authz';
+
+/**
+ * The subset of OpenID Provider Metadata / RFC 8414 Authorization Server
+ * Metadata this package actually reads -- every field below is one the
+ * identity server this package targets always sets. An index signature
+ * carries the rest through unread rather than dropping it.
+ */
+interface DiscoveryDocument {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    jwks_uri: string;
+    userinfo_endpoint?: string;
+    end_session_endpoint?: string;
+    revocation_endpoint?: string;
+    introspection_endpoint?: string;
+    registration_endpoint?: string;
+    scopes_supported?: string[];
+    response_types_supported?: string[];
+    grant_types_supported?: string[];
+    code_challenge_methods_supported?: string[];
+    token_endpoint_auth_methods_supported?: string[];
+    subject_types_supported?: string[];
+    id_token_signing_alg_values_supported?: string[];
+    claims_supported?: string[];
+    acr_values_supported?: string[];
+    [key: string]: unknown;
+}
+type RemoteJwks = ReturnType<typeof createRemoteJWKSet>;
+/**
+ * Fetches and caches an issuer's OpenID Provider Metadata.
+ *
+ * Cache: 600s TTL, up to 100 issuers, LRU-evicted. A cache hit also counts as
+ * a use for LRU purposes (`touchLru`), so a repeatedly-queried issuer is the
+ * last one evicted under pressure.
+ *
+ * In-flight requests are deduplicated per issuer: see `discoveryPending`'s
+ * own docblock for why the pending promise is stored before this function
+ * awaits it, and why that ordering is what prevents concurrent cold-start
+ * callers from each firing their own request.
+ */
+declare function fetchDiscovery(issuerUrl: string): Promise<DiscoveryDocument>;
+/**
+ * Returns a cached `createRemoteJWKSet` instance for `jwksUri`, creating one
+ * on first use. See `jwksCache`'s own docblock for why the JWKS response
+ * itself is not cached a second time here.
+ */
+declare function getRemoteJwksForUri(jwksUri: string): RemoteJwks;
+
+/**
+ * Generates a random RFC 7636 PKCE code verifier.
+ *
+ * @returns A base64url string of 43 characters (32 random bytes), the
+ *   shortest length RFC 7636 §4.1 allows (43-128). Pass it to
+ *   `generateCodeChallenge` to derive the matching `code_challenge`, and
+ *   send it unchanged as `code_verifier` when exchanging the authorization
+ *   code.
+ */
+declare function generateCodeVerifier(): string;
+/**
+ * Derives the RFC 7636 S256 `code_challenge` for a verifier.
+ *
+ * @param verifier - The code verifier from `generateCodeVerifier`.
+ * @returns `base64url(SHA-256(verifier))`, sent as `code_challenge` on the
+ *   authorization request (alongside `code_challenge_method=S256`).
+ */
+declare function generateCodeChallenge(verifier: string): Promise<string>;
+/**
+ * Generates a random CSRF `state` value for the authorization request.
+ *
+ * @returns A base64url string of 43 characters (32 random bytes). Store it
+ *   alongside the PKCE verifier and compare it against the `state` the
+ *   callback receives back before trusting the request.
+ */
+declare function generateState(): string;
+
+export { type DiscoveryDocument, fetchDiscovery, generateCodeChallenge, generateCodeVerifier, generateState, getRemoteJwksForUri };

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+import { createRemoteJWKSet } from 'jose';
+export { A as AuthorizationCodeExchangeOptions, C as CLOCK_SKEW_TOLERANCE_SECONDS, a as ClientCredentialsGrantOptions, I as IdTokenClaims, R as RefreshTokensOptions, T as TokenRefreshOutcome, b as TokenRequestError, c as TokenSet, d as TokenVerificationError, e as TokenVerificationErrorCode, V as VerificationResult, f as VerifiedAccessToken, g as VerifyTokenOptions, h as clientCredentialsGrant, i as exchangeAuthorizationCode, r as refreshTokens, v as verifyAccessToken, j as verifyIdToken } from './verify-BiGhwaIz.js';
+import '@tdacorp/identity-authz';
+
+/**
+ * The subset of OpenID Provider Metadata / RFC 8414 Authorization Server
+ * Metadata this package actually reads -- every field below is one the
+ * identity server this package targets always sets. An index signature
+ * carries the rest through unread rather than dropping it.
+ */
+interface DiscoveryDocument {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    jwks_uri: string;
+    userinfo_endpoint?: string;
+    end_session_endpoint?: string;
+    revocation_endpoint?: string;
+    introspection_endpoint?: string;
+    registration_endpoint?: string;
+    scopes_supported?: string[];
+    response_types_supported?: string[];
+    grant_types_supported?: string[];
+    code_challenge_methods_supported?: string[];
+    token_endpoint_auth_methods_supported?: string[];
+    subject_types_supported?: string[];
+    id_token_signing_alg_values_supported?: string[];
+    claims_supported?: string[];
+    acr_values_supported?: string[];
+    [key: string]: unknown;
+}
+type RemoteJwks = ReturnType<typeof createRemoteJWKSet>;
+/**
+ * Fetches and caches an issuer's OpenID Provider Metadata.
+ *
+ * Cache: 600s TTL, up to 100 issuers, LRU-evicted. A cache hit also counts as
+ * a use for LRU purposes (`touchLru`), so a repeatedly-queried issuer is the
+ * last one evicted under pressure.
+ *
+ * In-flight requests are deduplicated per issuer: see `discoveryPending`'s
+ * own docblock for why the pending promise is stored before this function
+ * awaits it, and why that ordering is what prevents concurrent cold-start
+ * callers from each firing their own request.
+ */
+declare function fetchDiscovery(issuerUrl: string): Promise<DiscoveryDocument>;
+/**
+ * Returns a cached `createRemoteJWKSet` instance for `jwksUri`, creating one
+ * on first use. See `jwksCache`'s own docblock for why the JWKS response
+ * itself is not cached a second time here.
+ */
+declare function getRemoteJwksForUri(jwksUri: string): RemoteJwks;
+
+/**
+ * Generates a random RFC 7636 PKCE code verifier.
+ *
+ * @returns A base64url string of 43 characters (32 random bytes), the
+ *   shortest length RFC 7636 §4.1 allows (43-128). Pass it to
+ *   `generateCodeChallenge` to derive the matching `code_challenge`, and
+ *   send it unchanged as `code_verifier` when exchanging the authorization
+ *   code.
+ */
+declare function generateCodeVerifier(): string;
+/**
+ * Derives the RFC 7636 S256 `code_challenge` for a verifier.
+ *
+ * @param verifier - The code verifier from `generateCodeVerifier`.
+ * @returns `base64url(SHA-256(verifier))`, sent as `code_challenge` on the
+ *   authorization request (alongside `code_challenge_method=S256`).
+ */
+declare function generateCodeChallenge(verifier: string): Promise<string>;
+/**
+ * Generates a random CSRF `state` value for the authorization request.
+ *
+ * @returns A base64url string of 43 characters (32 random bytes). Store it
+ *   alongside the PKCE verifier and compare it against the `state` the
+ *   callback receives back before trusting the request.
+ */
+declare function generateState(): string;
+
+export { type DiscoveryDocument, fetchDiscovery, generateCodeChallenge, generateCodeVerifier, generateState, getRemoteJwksForUri };

package/dist/index.js

@@ -0,0 +1,28 @@
+import {
+  CLOCK_SKEW_TOLERANCE_SECONDS,
+  TokenRequestError,
+  clientCredentialsGrant,
+  exchangeAuthorizationCode,
+  fetchDiscovery,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateState,
+  getRemoteJwksForUri,
+  refreshTokens,
+  verifyAccessToken,
+  verifyIdToken
+} from "./chunk-VJSMXIZB.js";
+export {
+  CLOCK_SKEW_TOLERANCE_SECONDS,
+  TokenRequestError,
+  clientCredentialsGrant,
+  exchangeAuthorizationCode,
+  fetchDiscovery,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateState,
+  getRemoteJwksForUri,
+  refreshTokens,
+  verifyAccessToken,
+  verifyIdToken
+};

package/dist/next.cjs

@@ -0,0 +1,461 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next.ts
+var next_exports = {};
+__export(next_exports, {
+  createCallbackRoute: () => createCallbackRoute,
+  createLoginRoute: () => createLoginRoute
+});
+module.exports = __toCommonJS(next_exports);
+var import_server = require("next/server");
+
+// src/discovery.ts
+var import_jose = require("jose");
+var DISCOVERY_CACHE_TTL_MS = 6e5;
+var CACHE_MAX_ENTRIES = 100;
+var discoveryCache = /* @__PURE__ */ new Map();
+var discoveryPending = /* @__PURE__ */ new Map();
+var jwksCache = /* @__PURE__ */ new Map();
+function touchLru(map, key) {
+  const value = map.get(key);
+  if (value === void 0) return;
+  map.delete(key);
+  map.set(key, value);
+}
+function setWithLruEviction(map, key, value, maxEntries) {
+  map.delete(key);
+  map.set(key, value);
+  if (map.size > maxEntries) {
+    const oldestKey = map.keys().next().value;
+    if (oldestKey !== void 0) map.delete(oldestKey);
+  }
+}
+function discoveryUrl(issuerUrl) {
+  return `${issuerUrl.replace(/\/+$/, "")}/.well-known/openid-configuration`;
+}
+function isLoopbackHost(hostname) {
+  return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "::1";
+}
+function assertHttps(url, label) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:" && !isLoopbackHost(parsed.hostname)) {
+    throw new Error(`Discovery: ${label} "${url}" must be https (loopback hosts are the only http exception)`);
+  }
+}
+function validateDiscoveryDocument(document, issuerUrl) {
+  assertHttps(issuerUrl, "issuer");
+  assertHttps(document.jwks_uri, "jwks_uri");
+  assertHttps(document.token_endpoint, "token_endpoint");
+  if (document.issuer !== issuerUrl) {
+    throw new Error(`Discovery: document issuer "${document.issuer}" does not match the configured issuer "${issuerUrl}"`);
+  }
+  const issuerOrigin = new URL(issuerUrl).origin;
+  if (new URL(document.jwks_uri).origin !== issuerOrigin) {
+    throw new Error(`Discovery: jwks_uri "${document.jwks_uri}" is not same-origin as issuer "${issuerUrl}"`);
+  }
+  if (new URL(document.token_endpoint).origin !== issuerOrigin) {
+    throw new Error(`Discovery: token_endpoint "${document.token_endpoint}" is not same-origin as issuer "${issuerUrl}"`);
+  }
+}
+async function fetchDiscovery(issuerUrl) {
+  const cached = discoveryCache.get(issuerUrl);
+  if (cached && cached.expiresAt > Date.now()) {
+    touchLru(discoveryCache, issuerUrl);
+    return cached.document;
+  }
+  const pending = discoveryPending.get(issuerUrl);
+  if (pending) return pending;
+  const promise = fetch(discoveryUrl(issuerUrl), { headers: { Accept: "application/json" } }).then(
+    async (response) => {
+      if (!response.ok) {
+        throw new Error(`Discovery fetch for ${issuerUrl} failed: HTTP ${response.status}`);
+      }
+      const document = await response.json();
+      validateDiscoveryDocument(document, issuerUrl);
+      return document;
+    }
+  );
+  discoveryPending.set(issuerUrl, promise);
+  try {
+    const document = await promise;
+    discoveryPending.delete(issuerUrl);
+    setWithLruEviction(discoveryCache, issuerUrl, { document, expiresAt: Date.now() + DISCOVERY_CACHE_TTL_MS }, CACHE_MAX_ENTRIES);
+    return document;
+  } catch (error) {
+    discoveryPending.delete(issuerUrl);
+    throw error;
+  }
+}
+function getRemoteJwksForUri(jwksUri) {
+  const cached = jwksCache.get(jwksUri);
+  if (cached) {
+    touchLru(jwksCache, jwksUri);
+    return cached;
+  }
+  const jwks = (0, import_jose.createRemoteJWKSet)(new URL(jwksUri));
+  setWithLruEviction(jwksCache, jwksUri, jwks, CACHE_MAX_ENTRIES);
+  return jwks;
+}
+
+// src/pkce.ts
+var CODE_VERIFIER_BYTE_LENGTH = 32;
+var STATE_BYTE_LENGTH = 32;
+function base64UrlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function randomBase64Url(byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return base64UrlEncode(bytes);
+}
+function generateCodeVerifier() {
+  return randomBase64Url(CODE_VERIFIER_BYTE_LENGTH);
+}
+async function generateCodeChallenge(verifier) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return base64UrlEncode(new Uint8Array(digest));
+}
+function generateState() {
+  return randomBase64Url(STATE_BYTE_LENGTH);
+}
+
+// src/token.ts
+var TokenRequestError = class extends Error {
+  status;
+  error;
+  errorDescription;
+  constructor(details) {
+    super(
+      details.errorDescription ?? details.error ?? `Token request failed${details.status ? ` with HTTP ${details.status}` : ""}`
+    );
+    this.name = "TokenRequestError";
+    this.status = details.status;
+    this.error = details.error;
+    this.errorDescription = details.errorDescription;
+  }
+};
+function toTokenSet(body) {
+  return {
+    accessToken: body.access_token,
+    tokenType: body.token_type ?? "Bearer",
+    refreshToken: body.refresh_token,
+    idToken: body.id_token,
+    expiresIn: body.expires_in,
+    scope: body.scope
+  };
+}
+async function postTokenRequest(tokenEndpoint, clientId, clientSecret, params) {
+  const body = new URLSearchParams(params);
+  const headers = {
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  };
+  if (clientSecret) {
+    headers.Authorization = `Basic ${btoa(`${clientId}:${clientSecret}`)}`;
+  } else {
+    body.set("client_id", clientId);
+  }
+  return fetch(tokenEndpoint, { method: "POST", headers, body: body.toString() });
+}
+async function readTokenResponseBody(response) {
+  return await response.json().catch(() => null);
+}
+async function exchangeAuthorizationCode(options) {
+  const discovery = await fetchDiscovery(options.issuer);
+  const response = await postTokenRequest(discovery.token_endpoint, options.clientId, options.clientSecret, {
+    grant_type: "authorization_code",
+    code: options.code,
+    redirect_uri: options.redirectUri,
+    code_verifier: options.codeVerifier
+  });
+  const body = await readTokenResponseBody(response);
+  if (!response.ok || !body || body.error || typeof body.access_token !== "string") {
+    throw new TokenRequestError({ status: response.status, error: body?.error, errorDescription: body?.error_description });
+  }
+  return toTokenSet(body);
+}
+
+// src/verify.ts
+var import_jose2 = require("jose");
+var CLOCK_SKEW_TOLERANCE_SECONDS = 60;
+function joseErrorCode(error) {
+  return error instanceof import_jose2.errors.JOSEError ? error.code : void 0;
+}
+function classifyJoseError(error) {
+  const code = joseErrorCode(error);
+  const message = error instanceof Error ? error.message : "Token verification failed";
+  switch (code) {
+    case "ERR_JWT_EXPIRED":
+      return { code: "expired", message };
+    case "ERR_JWT_CLAIM_VALIDATION_FAILED": {
+      const claim = error instanceof import_jose2.errors.JWTClaimValidationFailed ? error.claim : void 0;
+      if (claim === "aud") return { code: "invalid-audience", message };
+      if (claim === "iss") return { code: "invalid-issuer", message };
+      return { code: "malformed-claims", message };
+    }
+    case "ERR_JWS_SIGNATURE_VERIFICATION_FAILED":
+    case "ERR_JWS_INVALID":
+    case "ERR_JWKS_NO_MATCHING_KEY":
+    case "ERR_JWKS_MULTIPLE_MATCHING_KEYS":
+      return { code: "invalid-signature", message };
+    case "ERR_JWKS_TIMEOUT":
+      return { code: "jwks-unavailable", message };
+    case "ERR_JWT_INVALID":
+    default:
+      return { code: "malformed-token", message };
+  }
+}
+function checkAuthorizedParty(payload, authorizedParties) {
+  const party = typeof payload.azp === "string" ? payload.azp : typeof payload.aud === "string" ? payload.aud : void 0;
+  if (party === void 0) {
+    return { code: "unauthorized-party", message: "Token has no azp claim and no single-string aud to check against authorizedParties" };
+  }
+  if (!authorizedParties.includes(party)) {
+    return { code: "unauthorized-party", message: `Token's authorized party "${party}" is not in the configured allowlist` };
+  }
+  return null;
+}
+function requireConfig(options) {
+  if (!options.issuer) throw new Error("verify: options.issuer is required");
+  if (!options.audience) throw new Error("verify: options.audience is required");
+}
+async function verifyAgainstIssuer(token, options) {
+  requireConfig(options);
+  let jwksUri;
+  try {
+    jwksUri = (await fetchDiscovery(options.issuer)).jwks_uri;
+  } catch (error) {
+    return { errors: [{ code: "jwks-unavailable", message: error instanceof Error ? error.message : "Discovery fetch failed" }] };
+  }
+  const jwks = getRemoteJwksForUri(jwksUri);
+  try {
+    const { payload } = await (0, import_jose2.jwtVerify)(token, jwks, {
+      issuer: options.issuer,
+      audience: options.audience,
+      algorithms: ["EdDSA"],
+      clockTolerance: CLOCK_SKEW_TOLERANCE_SECONDS
+    });
+    if (options.authorizedParties) {
+      const authorizedPartyError = checkAuthorizedParty(payload, options.authorizedParties);
+      if (authorizedPartyError) return { errors: [authorizedPartyError] };
+    }
+    return { payload };
+  } catch (error) {
+    return { errors: [classifyJoseError(error)] };
+  }
+}
+async function verifyIdToken(idToken, options) {
+  const result = await verifyAgainstIssuer(idToken, options);
+  if ("errors" in result) return { success: false, errors: result.errors };
+  const { payload } = result;
+  if (typeof payload.sub !== "string") {
+    return { success: false, errors: [{ code: "malformed-claims", message: "id_token has no sub claim" }] };
+  }
+  return { success: true, data: payload };
+}
+
+// src/sealed.ts
+var import_jose3 = require("jose");
+async function deriveContentEncryptionKey(secret, purpose) {
+  const encoder = new TextEncoder();
+  const keyMaterial = await crypto.subtle.importKey("raw", encoder.encode(secret), "HKDF", false, ["deriveBits"]);
+  const bits = await crypto.subtle.deriveBits(
+    { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: encoder.encode(purpose) },
+    keyMaterial,
+    256
+  );
+  return new Uint8Array(bits);
+}
+function resolveSealingKey(secret) {
+  if (typeof secret === "string") return { secretValue: secret };
+  const keyNumbers = Object.keys(secret).map(Number);
+  if (keyNumbers.length === 0) throw new Error("seal: secret key-rotation map is empty");
+  const highest = Math.max(...keyNumbers);
+  return { kid: String(highest), secretValue: secret[highest] };
+}
+var MAX_SEALED_BYTES = 4096;
+async function seal(payload, options) {
+  const { kid, secretValue } = resolveSealingKey(options.secret);
+  const cek = await deriveContentEncryptionKey(secretValue, options.purpose);
+  const header = {
+    alg: "dir",
+    enc: "A256GCM",
+    ...kid !== void 0 ? { kid } : {}
+  };
+  const sealed = await new import_jose3.EncryptJWT(payload).setProtectedHeader(header).setIssuedAt().setExpirationTime(`${options.ttlSeconds}s`).encrypt(cek);
+  const byteLength = new TextEncoder().encode(sealed).length;
+  if (byteLength > MAX_SEALED_BYTES) {
+    throw new Error(
+      `seal: sealed payload is ${byteLength} bytes, over the ${MAX_SEALED_BYTES}-byte limit (MAX_SEALED_BYTES). Shrink the payload -- do not chunk it across cookies; see MAX_SEALED_BYTES's own docblock for why.`
+    );
+  }
+  return sealed;
+}
+function resolveUnsealingKey(secret, kid) {
+  if (typeof secret === "string") return { secretValue: secret };
+  if (kid === void 0 || !(Number(kid) in secret)) return { reason: "unknown-key" };
+  return { secretValue: secret[Number(kid)] };
+}
+function classifyUnsealError(error) {
+  const code = error instanceof import_jose3.errors.JOSEError ? error.code : void 0;
+  return code === "ERR_JWT_EXPIRED" ? "expired" : "invalid";
+}
+async function unseal(sealedValue, options) {
+  let kid;
+  try {
+    kid = (0, import_jose3.decodeProtectedHeader)(sealedValue).kid;
+  } catch {
+    options.onError?.("invalid");
+    return null;
+  }
+  const resolved = resolveUnsealingKey(options.secret, kid);
+  if ("reason" in resolved) {
+    options.onError?.(resolved.reason);
+    return null;
+  }
+  try {
+    const cek = await deriveContentEncryptionKey(resolved.secretValue, options.purpose);
+    const { payload } = await (0, import_jose3.jwtDecrypt)(sealedValue, cek);
+    return payload;
+  } catch (error) {
+    const reason = classifyUnsealError(error);
+    options.onError?.(reason);
+    return null;
+  }
+}
+
+// src/next.ts
+var TRANSACTION_TTL_SECONDS = 600;
+var DEFAULT_TRANSACTION_COOKIE = "identity_oauth_txn";
+var TRANSACTION_PURPOSE = "identity-client:oauth-transaction";
+function transactionCookieOptions(maxAge) {
+  return {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    path: "/",
+    maxAge
+  };
+}
+function createLoginRoute(config) {
+  return async function loginRoute(request) {
+    const state = generateState();
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = await generateCodeChallenge(codeVerifier);
+    const returnTo = config.getReturnTo?.(request) ?? request.nextUrl.searchParams.get("returnTo") ?? void 0;
+    const transaction = { state, codeVerifier, returnTo };
+    const sealedTransaction = await seal(transaction, {
+      secret: config.cookieSecret,
+      ttlSeconds: TRANSACTION_TTL_SECONDS,
+      purpose: TRANSACTION_PURPOSE
+    });
+    const discovery = await fetchDiscovery(config.issuer);
+    const authorizeUrl = new URL(discovery.authorization_endpoint);
+    authorizeUrl.searchParams.set("client_id", config.clientId);
+    authorizeUrl.searchParams.set("redirect_uri", config.redirectUri);
+    authorizeUrl.searchParams.set("response_type", "code");
+    authorizeUrl.searchParams.set("scope", config.scope ?? "openid profile email roles");
+    authorizeUrl.searchParams.set("state", state);
+    authorizeUrl.searchParams.set("code_challenge", codeChallenge);
+    authorizeUrl.searchParams.set("code_challenge_method", "S256");
+    const response = import_server.NextResponse.redirect(authorizeUrl);
+    response.cookies.set(
+      config.transactionCookieName ?? DEFAULT_TRANSACTION_COOKIE,
+      sealedTransaction,
+      transactionCookieOptions(TRANSACTION_TTL_SECONDS)
+    );
+    return response;
+  };
+}
+function defaultOnError(error) {
+  return import_server.NextResponse.json({ error: error.code, error_description: error.message }, { status: 400 });
+}
+function createCallbackRoute(config) {
+  return async function callbackRoute(request) {
+    const handleError = config.onError ?? defaultOnError;
+    const cookieName = config.transactionCookieName ?? DEFAULT_TRANSACTION_COOKIE;
+    const params = request.nextUrl.searchParams;
+    const providerError = params.get("error");
+    if (providerError) {
+      return handleError({ code: "provider_error", message: params.get("error_description") ?? providerError });
+    }
+    const code = params.get("code");
+    const state = params.get("state");
+    if (!code) return handleError({ code: "missing_code", message: "Callback request has no code parameter" });
+    if (!state) return handleError({ code: "missing_state", message: "Callback request has no state parameter" });
+    const sealedTransaction = request.cookies.get(cookieName)?.value;
+    if (!sealedTransaction) {
+      return handleError({
+        code: "missing_transaction",
+        message: `No ${cookieName} cookie was presented; it may have expired, or this is a replayed callback`
+      });
+    }
+    const transaction = await unseal(sealedTransaction, {
+      secret: config.cookieSecret,
+      purpose: TRANSACTION_PURPOSE
+    });
+    if (!transaction) {
+      return handleError({ code: "missing_transaction", message: "The transaction cookie failed to decrypt, or has expired" });
+    }
+    if (transaction.state !== state) {
+      return handleError({ code: "state_mismatch", message: "The state parameter does not match the value stored at login" });
+    }
+    let tokens;
+    try {
+      tokens = await exchangeAuthorizationCode({
+        issuer: config.issuer,
+        clientId: config.clientId,
+        clientSecret: config.clientSecret,
+        code,
+        redirectUri: config.redirectUri,
+        codeVerifier: transaction.codeVerifier
+      });
+    } catch (error) {
+      return handleError({
+        code: "token_exchange_failed",
+        message: error instanceof Error ? error.message : "Token exchange failed"
+      });
+    }
+    if (!tokens.idToken) {
+      return handleError({ code: "token_verification_failed", message: "Token response carried no id_token to verify" });
+    }
+    const verification = await verifyIdToken(tokens.idToken, {
+      issuer: config.issuer,
+      audience: config.audience ?? config.clientId,
+      authorizedParties: config.authorizedParties
+    });
+    if (!verification.success) {
+      return handleError({
+        code: "token_verification_failed",
+        message: verification.errors.map((e) => `${e.code}: ${e.message}`).join("; ")
+      });
+    }
+    const response = await config.onSuccess(tokens, verification.data, { returnTo: transaction.returnTo });
+    response.cookies.delete(cookieName);
+    return response;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCallbackRoute,
+  createLoginRoute
+});