@authyon/server 0.2.0-beta.0 → 0.2.0-beta.1

package/dist/index.cjs

@@ -20,43 +20,523 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AuthorizationError: () => AuthorizationError,
+  AuthyonAbility: () => AuthyonAbility,
+  AuthyonAbilityBuilder: () => AuthyonAbilityBuilder,
   AuthyonError: () => AuthyonError,
   AuthyonServerClient: () => AuthyonServerClient,
+  AuthyonServerClientBuilder: () => AuthyonServerClientBuilder,
+  ErrorCodes: () => ErrorCodes,
+  FetchHttpAdapter: () => FetchHttpAdapter,
+  JwksTokenVerifier: () => JwksTokenVerifier,
+  LoggingHttpAdapter: () => LoggingHttpAdapter,
   TenantScopedClient: () => TenantScopedClient,
-  createClient: () => createClient
+  TokenVerificationError: () => TokenVerificationError,
+  authorizeRequest: () => authorizeRequest,
+  authorizeToken: () => authorizeToken,
+  createAuthorizationErrorResponse: () => createAuthorizationErrorResponse,
+  createAuthyonAbility: () => createAuthyonAbility,
+  createAuthyonRules: () => createAuthyonRules,
+  createClient: () => createClient,
+  createExpressAuthorizationMiddleware: () => createExpressAuthorizationMiddleware,
+  normalizeClientIp: () => normalizeClientIp
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/errors.ts
+// ../../internal/core/config/defaults.ts
+var DEFAULT_BASE_URL = "https://api.authyon.com";
+var DEFAULT_EXPIRY_SKEW_MS = 3e4;
+
+// ../../internal/core/auth/expiringTokenProvider.ts
+var ExpiringTokenProvider = class {
+  constructor(acquire, expirySkewMs = DEFAULT_EXPIRY_SKEW_MS) {
+    this.acquire = acquire;
+    this.expirySkewMs = expirySkewMs;
+    this.token = null;
+    this.inFlight = null;
+  }
+  async getAccessToken() {
+    if (this.token && Date.now() < this.token.expiresAt - this.expirySkewMs) {
+      return this.token.accessToken;
+    }
+    if (this.inFlight) return this.inFlight;
+    this.inFlight = this.acquire().then((token) => {
+      this.token = token;
+      return token.accessToken;
+    }).finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  clear() {
+    this.token = null;
+  }
+};
+
+// ../../internal/core/errors/authyonError.ts
+var ErrorCodes = {
+  Unknown: "unknown",
+  NetworkError: "request.network_error",
+  Timeout: "request.timeout",
+  SessionMalformed: "session.malformed",
+  NotAuthenticated: "auth.not_authenticated",
+  InvalidToken: "auth.invalid_token",
+  MissingToken: "auth.missing_token",
+  EmailTaken: "user.email_taken",
+  PasswordWeak: "user.password_weak",
+  PasswordPwned: "user.password_pwned",
+  RateLimited: "rate_limited"
+};
 var AuthyonError = class extends Error {
-  constructor(status, body) {
+  constructor(status, body, options = {}) {
     super(body.detail ?? body.title ?? `Authyon request failed with status ${status}`);
     this.name = "AuthyonError";
     this.status = status;
     this.code = body.code ?? "unknown";
     this.title = body.title ?? "Error";
     this.detail = body.detail;
+    this.requestId = options.requestId;
+    this.retryAfter = options.retryAfter;
+    this.cause = options.cause;
   }
   is(code) {
     return this.code === code;
   }
+  isAny(...codes) {
+    return codes.includes(this.code);
+  }
+  hasPrefix(prefix) {
+    return this.code.startsWith(prefix);
+  }
+  isStatus(...statuses) {
+    return statuses.includes(this.status);
+  }
+  /** Stable interpretation for UI decisions, retries, telemetry and support flows. */
+  interpret() {
+    const category = classifyError(this.status, this.code);
+    return {
+      category,
+      action: actionFor(category),
+      retryable: isRetryable(category),
+      ...this.retryAfter !== void 0 ? { retryAfter: this.retryAfter } : {},
+      ...this.requestId !== void 0 ? { requestId: this.requestId } : {}
+    };
+  }
+  get category() {
+    return this.interpret().category;
+  }
+  get retryable() {
+    return this.interpret().retryable;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      code: this.code,
+      title: this.title,
+      detail: this.detail,
+      requestId: this.requestId,
+      retryAfter: this.retryAfter,
+      ...this.interpret()
+    };
+  }
 };
+function classifyError(status, code) {
+  if (code === ErrorCodes.NetworkError) return "network";
+  if (code === ErrorCodes.Timeout || status === 408) return "timeout";
+  if (code === ErrorCodes.RateLimited || status === 429) return "rate_limit";
+  if (code === ErrorCodes.EmailTaken || status === 409) return "conflict";
+  if (code === ErrorCodes.PasswordWeak || code === ErrorCodes.PasswordPwned) return "validation";
+  if (code === ErrorCodes.SessionMalformed) return "server";
+  if (code.startsWith("auth.") || status === 401) return "authentication";
+  if (status === 403) return "authorization";
+  if (status === 404) return "not_found";
+  if (status === 400 || status === 422) return "validation";
+  if (status >= 500) return "server";
+  return "unknown";
+}
+function actionFor(category) {
+  switch (category) {
+    case "network":
+    case "timeout":
+    case "rate_limit":
+    case "server":
+      return "retry";
+    case "authentication":
+      return "reauthenticate";
+    case "authorization":
+      return "request_access";
+    case "validation":
+      return "fix_input";
+    case "not_found":
+      return "not_found";
+    case "conflict":
+      return "resolve_conflict";
+    case "unknown":
+      return "contact_support";
+  }
+}
+function isRetryable(category) {
+  return category === "network" || category === "timeout" || category === "rate_limit" || category === "server";
+}
 
-// src/client.ts
-var DEFAULT_BASE_URL = "https://api.authyon.com";
-var EXPIRY_SKEW_MS = 3e4;
-function toQuery(params = {}) {
+// ../../internal/core/http/query.ts
+function appendQuery(path, params) {
+  if (!params) return path;
   const query = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== void 0) query.set(key, String(value));
+  for (const [key, value2] of Object.entries(params)) {
+    if (value2 !== void 0) query.set(key, String(value2));
+  }
+  const value = query.toString();
+  return value ? `${path}${path.includes("?") ? "&" : "?"}${value}` : path;
+}
+
+// ../../internal/core/http/httpAdapter.ts
+var FetchHttpAdapter = class {
+  constructor(fetchImpl = fetch.bind(globalThis)) {
+    this.fetchImpl = fetchImpl;
+  }
+  request(request) {
+    return this.fetchImpl(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.body,
+      signal: request.signal
+    });
+  }
+};
+var LoggingHttpAdapter = class {
+  constructor(adapter, options) {
+    this.adapter = adapter;
+    this.options = options;
+  }
+  async request(request) {
+    const startedAt = Date.now();
+    const eventBase = {
+      method: request.method,
+      url: sanitizeUrl(request.url)
+    };
+    this.log({ type: "request", ...eventBase, timestamp: startedAt });
+    try {
+      const response = await this.adapter.request(request);
+      this.log({
+        type: "response",
+        ...eventBase,
+        status: response.status,
+        durationMs: Date.now() - startedAt,
+        requestId: response.headers.get("x-request-id") ?? response.headers.get("trace-id") ?? void 0,
+        timestamp: Date.now()
+      });
+      return response;
+    } catch (error) {
+      this.log({
+        type: "error",
+        ...eventBase,
+        errorName: error instanceof Error ? error.name : "UnknownError",
+        durationMs: Date.now() - startedAt,
+        timestamp: Date.now()
+      });
+      throw error;
+    }
+  }
+  log(event) {
+    if (!this.options.enabled) return;
+    const logger = this.options.logger ?? defaultHttpLogger;
+    try {
+      logger(event);
+    } catch {
+    }
+  }
+};
+function defaultHttpLogger(event) {
+  console.debug("[Authyon HTTP]", event);
+}
+function sanitizeUrl(value) {
+  const url = new URL(value);
+  const queryKeys = /* @__PURE__ */ new Set();
+  url.searchParams.forEach((_value, key) => queryKeys.add(key));
+  url.search = queryKeys.size > 0 ? [...queryKeys].map((key) => `${encodeURIComponent(key)}=REDACTED`).join("&") : "";
+  return url.toString();
+}
+
+// ../../internal/core/http/transport.ts
+var DEFAULT_TIMEOUT_MS = 15e3;
+var SharedTransportError = class extends Error {
+  constructor(code, cause) {
+    super(code === "request.timeout" ? "Request timed out" : "Network request failed");
+    this.name = "SharedTransportError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+function createSharedTransport(options) {
+  const baseUrl = normalizeBaseUrl(options.baseUrl, options.allowInsecureHttp ?? false);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+    throw new Error("Authyon: `timeoutMs` must be a non-negative finite number");
+  }
+  if (options.httpAdapter && options.fetch) {
+    throw new Error("Authyon: use either `httpAdapter` or `fetch`, not both");
+  }
+  const baseAdapter = options.httpAdapter ?? new FetchHttpAdapter(options.fetch);
+  const httpAdapter = options.httpLogger ? new LoggingHttpAdapter(baseAdapter, options.httpLogger) : baseAdapter;
+  return {
+    baseUrl,
+    async request(path, init) {
+      const controller = new AbortController();
+      const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+      try {
+        return await httpAdapter.request({
+          url: `${baseUrl}${path}`,
+          method: init.method ?? "GET",
+          headers: normalizeHeaders(init.headers),
+          body: init.body,
+          signal: controller.signal
+        });
+      } catch (cause) {
+        throw new SharedTransportError(
+          controller.signal.aborted ? ErrorCodes.Timeout : ErrorCodes.NetworkError,
+          cause
+        );
+      } finally {
+        if (timeout !== void 0) clearTimeout(timeout);
+      }
+    }
+  };
+}
+function normalizeHeaders(headers) {
+  const normalized = {};
+  new Headers(headers).forEach((value, key) => {
+    normalized[key] = value;
+  });
+  return normalized;
+}
+function responseMetadata(response) {
+  const retryAfterHeader = response.headers.get("retry-after");
+  const retryAfter = retryAfterHeader ? Number(retryAfterHeader) : void 0;
+  return {
+    requestId: response.headers.get("x-request-id") ?? response.headers.get("trace-id") ?? void 0,
+    retryAfter: Number.isFinite(retryAfter) ? retryAfter : void 0
+  };
+}
+function normalizeBaseUrl(value, allowInsecureHttp) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Authyon: `baseUrl` must be an absolute URL");
+  }
+  const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && (loopback || allowInsecureHttp))) {
+    throw new Error(
+      "Authyon: `baseUrl` must use HTTPS (HTTP is allowed only for loopback or with `allowInsecureHttp`)"
+    );
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    throw new Error(
+      "Authyon: `baseUrl` cannot contain credentials, query parameters, or fragments"
+    );
+  }
+  return url.toString().replace(/\/+$/, "");
+}
+
+// ../../internal/core/http/jsonHttpClient.ts
+var JsonHttpClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async send(path, options = {}) {
+    const headers = { ...options.headers };
+    if (options.body !== void 0) headers["Content-Type"] = "application/json";
+    try {
+      return await this.transport.request(appendQuery(path, options.query), {
+        method: options.method ?? "GET",
+        headers,
+        body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+      });
+    } catch (cause) {
+      if (!(cause instanceof SharedTransportError)) throw cause;
+      throw new AuthyonError(0, { code: cause.code, title: cause.message }, { cause: cause.cause });
+    }
+  }
+  async parse(response) {
+    if (!response.ok) {
+      let body = {};
+      try {
+        body = await response.json();
+      } catch {
+      }
+      throw new AuthyonError(response.status, body, responseMetadata(response));
+    }
+    if (response.status === 204) return void 0;
+    return await response.json();
+  }
+  async request(path, options = {}) {
+    return this.parse(await this.send(path, options));
+  }
+};
+
+// ../../internal/core/http/clientIp.ts
+function clientIpHeaders(context) {
+  if (!context?.clientIp) return {};
+  return { "X-Forwarded-For": normalizeClientIp(context.clientIp) };
+}
+function normalizeClientIp(value) {
+  let ip = value.trim();
+  if (ip.startsWith("[") && ip.endsWith("]")) ip = ip.slice(1, -1);
+  if (!ip || ip.length > 45 || ip.includes(",") || /[\r\n\s]/.test(ip) || !/^[0-9a-f:.]+$/i.test(ip) || !ip.includes(".") && !ip.includes(":")) {
+    throw invalidClientIp();
+  }
+  try {
+    new URL(ip.includes(":") ? `http://[${ip}]` : `http://${ip}`);
+  } catch {
+    throw invalidClientIp();
+  }
+  return ip;
+}
+function invalidClientIp() {
+  return new Error("Authyon: `clientIp` must be a single valid IPv4 or IPv6 address");
+}
+
+// src/security/jwksTokenVerifier.ts
+var import_jose = require("jose");
+var SAFE_ASYMMETRIC_ALGORITHMS = [
+  "RS256",
+  "PS256",
+  "ES256",
+  "EdDSA"
+];
+var TokenVerificationError = class extends Error {
+  constructor(code, options = {}) {
+    super(messageForCode(code));
+    this.code = code;
+    this.name = "TokenVerificationError";
+    if (options.cause !== void 0) Object.defineProperty(this, "cause", { value: options.cause });
+  }
+};
+var JwksTokenVerifier = class {
+  constructor(options) {
+    this.options = options;
+    validateOptions(options);
+    this.algorithms = [...options.algorithms ?? ["RS256"]];
+    this.acceptedTokenTypes = new Set(options.acceptedTokenTypes ?? ["JWT", "at+jwt"]);
+    this.verifyKey = options.jwks ? (0, import_jose.createLocalJWKSet)(options.jwks) : (0, import_jose.createRemoteJWKSet)(new URL(options.jwksUri), {
+      timeoutDuration: options.jwksTimeoutMs ?? 5e3,
+      cacheMaxAge: options.jwksCacheMs ?? 6e5,
+      cooldownDuration: options.jwksCooldownMs ?? 3e4
+    });
+  }
+  async verifyAccessToken(token) {
+    if (!token || token.length > 16384) {
+      throw new TokenVerificationError("token.invalid");
+    }
+    try {
+      const result = await (0, import_jose.jwtVerify)(token, this.verifyKey, {
+        algorithms: this.algorithms,
+        issuer: this.options.issuer,
+        audience: this.options.audience,
+        clockTolerance: this.options.clockToleranceSeconds ?? 5,
+        maxTokenAge: this.options.maxTokenAgeSeconds ?? 3600,
+        requiredClaims: ["iss", "aud", "sub", "exp", "iat"]
+      });
+      validateTokenType(result, this.acceptedTokenTypes);
+      validateClaims(result.payload);
+      return { claims: result.payload, protectedHeader: result.protectedHeader };
+    } catch (cause) {
+      if (cause instanceof TokenVerificationError) throw cause;
+      throw new TokenVerificationError(errorCode(cause), { cause });
+    }
+  }
+};
+function validateTokenType(result, acceptedTokenTypes) {
+  const type = result.protectedHeader.typ;
+  if (!type || !acceptedTokenTypes.has(type)) {
+    throw new TokenVerificationError("token.invalid_claims");
+  }
+}
+function validateClaims(claims) {
+  if (typeof claims.sub !== "string" || !claims.sub) invalidClaims();
+  if (claims.permissions !== void 0 && !isStringArray(claims.permissions)) invalidClaims();
+  if (claims.roles !== void 0 && !isStringArray(claims.roles)) invalidClaims();
+  if (claims.scope !== void 0 && typeof claims.scope !== "string") invalidClaims();
+}
+function validateOptions(options) {
+  const issuer = secureUrl(options.issuer, "issuer");
+  if (Boolean(options.jwksUri) === Boolean(options.jwks)) {
+    throw new Error("Authyon: configure exactly one of `jwksUri` or `jwks`");
+  }
+  const jwks = options.jwksUri ? secureUrl(options.jwksUri, "jwksUri") : void 0;
+  if (!options.audience || Array.isArray(options.audience) && options.audience.length === 0) {
+    throw new Error("Authyon: JWT `audience` is required");
+  }
+  if (jwks && issuer.origin !== jwks.origin) {
+    throw new Error("Authyon: `issuer` and `jwksUri` must use the same trusted origin");
+  }
+  const algorithms = options.algorithms ?? ["RS256"];
+  if (algorithms.length === 0 || algorithms.some((algorithm) => !SAFE_ASYMMETRIC_ALGORITHMS.includes(algorithm))) {
+    throw new Error("Authyon: only approved asymmetric JWT algorithms are accepted");
+  }
+  if (options.acceptedTokenTypes?.length === 0 || options.acceptedTokenTypes?.some((type) => !type.trim())) {
+    throw new Error("Authyon: `acceptedTokenTypes` must contain non-empty values");
+  }
+  for (const [name, value] of [
+    ["clockToleranceSeconds", options.clockToleranceSeconds],
+    ["maxTokenAgeSeconds", options.maxTokenAgeSeconds],
+    ["jwksTimeoutMs", options.jwksTimeoutMs],
+    ["jwksCacheMs", options.jwksCacheMs],
+    ["jwksCooldownMs", options.jwksCooldownMs]
+  ]) {
+    if (value !== void 0 && (!Number.isFinite(value) || value < 0)) {
+      throw new Error(`Authyon: \`${name}\` must be a non-negative finite number`);
+    }
+  }
+}
+function secureUrl(value, name) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`Authyon: JWT \`${name}\` must be an absolute URL`);
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.hash) {
+    throw new Error(`Authyon: JWT \`${name}\` must be a credential-free HTTPS URL`);
+  }
+  return url;
+}
+function errorCode(error) {
+  const code = isRecord(error) && typeof error.code === "string" ? error.code : "";
+  if (code === "ERR_JWT_EXPIRED") return "token.expired";
+  if (code === "ERR_JWS_SIGNATURE_VERIFICATION_FAILED") return "token.invalid_signature";
+  if (code === "ERR_JWKS_TIMEOUT") {
+    return "token.key_unavailable";
   }
-  const qs = query.toString();
-  return qs ? `?${qs}` : "";
+  if (code === "ERR_JWKS_NO_MATCHING_KEY") return "token.invalid_signature";
+  if (code === "ERR_JWT_CLAIM_VALIDATION_FAILED") {
+    const claim = isRecord(error) && typeof error.claim === "string" ? error.claim : "";
+    return claim === "nbf" ? "token.not_active" : "token.invalid_claims";
+  }
+  return "token.invalid";
+}
+function messageForCode(code) {
+  if (code === "token.key_unavailable") return "Token verification key is unavailable";
+  if (code === "token.expired") return "Token has expired";
+  if (code === "token.not_active") return "Token is not active yet";
+  return "Token verification failed";
+}
+function invalidClaims() {
+  throw new TokenVerificationError("token.invalid_claims");
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/client/authyonServerClient.ts
 var AuthyonServerClient = class {
   constructor(options = {}) {
-    this.environmentToken = null;
-    this.environmentTokenInFlight = null;
     // ── Discovery ──────────────────────────────────────────────────────────────
     this.discovery = {
       /** GET /.well-known/jwks.json — the environment's public signing keys. */
@@ -330,53 +810,55 @@ var AuthyonServerClient = class {
     this.envKey = options.envKey;
     this.clientId = options.clientId;
     this.clientSecret = options.clientSecret;
-    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
-    this.fetchImpl = options.fetch ?? fetch.bind(globalThis);
+    this.transport = createSharedTransport({
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+      allowInsecureHttp: options.allowInsecureHttp,
+      timeoutMs: options.timeoutMs,
+      httpAdapter: options.httpAdapter,
+      httpLogger: options.httpLogger,
+      fetch: options.fetch
+    });
+    this.http = new JsonHttpClient(this.transport);
+    this.environmentTokenProvider = new ExpiringTokenProvider(async () => {
+      if (!this.clientId || !this.clientSecret) {
+        throw new Error(
+          "Authyon: `clientId`/`clientSecret` are required for environment management calls (mint a pair in the console, under the environment's OAuth clients)."
+        );
+      }
+      const token = await this.environmentAuth.token({
+        clientId: this.clientId,
+        clientSecret: this.clientSecret
+      });
+      return {
+        accessToken: token.access_token,
+        expiresAt: Date.now() + token.expires_in * 1e3
+      };
+    });
   }
   async request(path, options = {}) {
     const headers = { ...options.headers };
-    if (options.body !== void 0) headers["Content-Type"] = "application/json";
     if (options.envBearer) {
       headers.Authorization = `Bearer ${await this.getEnvironmentAccessToken()}`;
     }
     if (this.envKey) headers["X-Authyon-Environment"] = this.envKey;
-    const response = await this.fetchImpl(`${this.baseUrl}${path}${toQuery(options.query)}`, {
-      method: options.method ?? "GET",
-      headers,
-      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
-    });
-    if (!response.ok) {
-      let body = {};
-      try {
-        body = await response.json();
-      } catch {
-      }
-      throw new AuthyonError(response.status, body);
-    }
-    if (response.status === 204) return void 0;
-    return await response.json();
+    return this.http.request(path, { ...options, headers });
   }
   /** Mints (and caches) an environment access token from `clientId`/`clientSecret`. */
   async getEnvironmentAccessToken() {
-    if (this.environmentToken && Date.now() < this.environmentToken.expiresAt - EXPIRY_SKEW_MS) {
-      return this.environmentToken.accessToken;
-    }
-    if (this.environmentTokenInFlight) return this.environmentTokenInFlight;
-    if (!this.clientId || !this.clientSecret) {
-      throw new Error(
-        "Authyon: `clientId`/`clientSecret` are required for environment management calls (mint a pair in the console, under the environment's OAuth clients)."
-      );
+    return this.environmentTokenProvider.getAccessToken();
+  }
+  /** Discovers Authyon's trusted issuer/JWKS and creates a cached local access-token verifier. */
+  async createJwksTokenVerifier(options) {
+    const { publishableKey, issuer, ...verifierOptions } = options;
+    const configuration = await this.discovery.openidConfiguration(publishableKey);
+    if (issuer && configuration.issuer !== issuer) {
+      throw new Error("Authyon: discovered JWT issuer does not match the configured issuer");
     }
-    this.environmentTokenInFlight = this.environmentAuth.token({ clientId: this.clientId, clientSecret: this.clientSecret }).then((token) => {
-      this.environmentToken = {
-        accessToken: token.access_token,
-        expiresAt: Date.now() + token.expires_in * 1e3
-      };
-      return token.access_token;
-    }).finally(() => {
-      this.environmentTokenInFlight = null;
+    return new JwksTokenVerifier({
+      ...verifierOptions,
+      issuer: issuer ?? configuration.issuer,
+      jwksUri: configuration.jwks_uri
     });
-    return this.environmentTokenInFlight;
   }
   // ── Token verification ────────────────────────────────────────────────────
   //
@@ -387,12 +869,22 @@ var AuthyonServerClient = class {
   // endpoint with only the `X-Authyon-Environment` header (no bearer)
   // returns 401 with `WWW-Authenticate: Bearer`.
   /** POST /auth/introspect — lightweight token introspection (RFC 7662). */
-  introspect(token) {
-    return this.request("/auth/introspect", { method: "POST", envBearer: true, body: { token } });
+  introspect(token, context) {
+    return this.request("/auth/introspect", {
+      method: "POST",
+      envBearer: true,
+      body: { token },
+      headers: clientIpHeaders(context)
+    });
   }
   /** POST /auth/validate — recommended: cross-checks DB state, catches revocation immediately. */
-  async validate(token) {
-    const raw = await this.request("/auth/validate", { method: "POST", envBearer: true, body: { token } });
+  async validate(token, context) {
+    const raw = await this.request("/auth/validate", {
+      method: "POST",
+      envBearer: true,
+      body: { token },
+      headers: clientIpHeaders(context)
+    });
     return { valid: raw.valid, reason: raw.reason ?? null, user: raw.profile };
   }
   /**
@@ -415,8 +907,6 @@ var AuthyonServerClient = class {
 };
 var TenantScopedClient = class {
   constructor(server, credentials) {
-    this.token = null;
-    this.tokenInFlight = null;
     this.members = {
       /**
        * GET /tenant/members — members of the token's tenant.
@@ -473,23 +963,16 @@ var TenantScopedClient = class {
       delete: (roleId) => this.request(`/tenant/roles/${encodeURIComponent(roleId)}`, { method: "DELETE" })
     };
     this.server = server;
-    this.credentials = credentials;
-  }
-  async getAccessToken() {
-    if (this.token && Date.now() < this.token.expiresAt - EXPIRY_SKEW_MS) {
-      return this.token.accessToken;
-    }
-    if (this.tokenInFlight) return this.tokenInFlight;
-    this.tokenInFlight = this.server.tenantAuth.token(this.credentials).then((token) => {
-      this.token = {
+    this.tokenProvider = new ExpiringTokenProvider(async () => {
+      const token = await this.server.tenantAuth.token(credentials);
+      return {
         accessToken: token.access_token,
         expiresAt: Date.now() + token.expires_in * 1e3
       };
-      return token.access_token;
-    }).finally(() => {
-      this.tokenInFlight = null;
     });
-    return this.tokenInFlight;
+  }
+  async getAccessToken() {
+    return this.tokenProvider.getAccessToken();
   }
   async request(path, options = {}) {
     return this.server._requestAsTenant(await this.getAccessToken(), path, options);
@@ -498,10 +981,348 @@ var TenantScopedClient = class {
 function createClient(options = {}) {
   return new AuthyonServerClient(options);
 }
+
+// src/client/authyonServerClientBuilder.ts
+var AuthyonServerClientBuilder = class {
+  constructor() {
+    this.options = {};
+  }
+  withEnvironmentKey(envKey) {
+    this.options.envKey = envKey;
+    return this;
+  }
+  withEnvironmentCredentials(clientId, clientSecret) {
+    this.options.clientId = clientId;
+    this.options.clientSecret = clientSecret;
+    return this;
+  }
+  withBaseUrl(baseUrl, allowInsecureHttp = false) {
+    this.options.baseUrl = baseUrl;
+    this.options.allowInsecureHttp = allowInsecureHttp;
+    return this;
+  }
+  withTimeout(timeoutMs) {
+    this.options.timeoutMs = timeoutMs;
+    return this;
+  }
+  withHttpAdapter(httpAdapter) {
+    this.options.httpAdapter = httpAdapter;
+    return this;
+  }
+  withHttpLogger(httpLogger) {
+    this.options.httpLogger = httpLogger;
+    return this;
+  }
+  build() {
+    return new AuthyonServerClient({ ...this.options });
+  }
+};
+
+// ../../internal/core/authorization/ability.ts
+var AuthyonAbility = class {
+  constructor(rules = [], detectSubjectType = defaultSubjectType) {
+    this.detectSubjectType = detectSubjectType;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.currentRules = rules.map(cloneRule);
+  }
+  get rules() {
+    return this.currentRules;
+  }
+  can(action, subject, field) {
+    const subjectType = typeof subject === "string" ? subject : this.detectSubjectType(subject);
+    for (let index = this.currentRules.length - 1; index >= 0; index -= 1) {
+      const rule = this.currentRules[index];
+      if (!matchesToken(rule.action, action, "manage")) continue;
+      if (!matchesToken(rule.subject, subjectType, "all")) continue;
+      if (field && rule.fields && !rule.fields.some((value) => matchesField(value, field)))
+        continue;
+      if (rule.conditions) {
+        if (typeof subject === "string" || !matchesConditions(subject, rule.conditions)) continue;
+      }
+      return !rule.inverted;
+    }
+    return false;
+  }
+  cannot(action, subject, field) {
+    return !this.can(action, subject, field);
+  }
+  rulesFor(action, subject) {
+    return this.currentRules.filter(
+      (rule) => matchesToken(rule.action, action, "manage") && matchesToken(rule.subject, subject, "all")
+    );
+  }
+  update(rules) {
+    this.currentRules = rules.map(cloneRule);
+    for (const listener of this.listeners) listener(this.rules);
+  }
+  on(event, listener) {
+    if (event !== "updated") return () => void 0;
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+};
+var AuthyonAbilityBuilder = class {
+  constructor() {
+    this.rules = [];
+  }
+  can(action, subject, conditions, fields) {
+    this.rules.push({ action, subject, conditions, fields });
+    return this;
+  }
+  cannot(action, subject, conditions, fields, reason) {
+    this.rules.push({ action, subject, conditions, fields, reason, inverted: true });
+    return this;
+  }
+  build(options = {}) {
+    return new AuthyonAbility(this.rules, options.detectSubjectType);
+  }
+};
+function createAuthyonAbility(source = {}, options = {}) {
+  return new AuthyonAbility(createAuthyonRules(source, options), options.detectSubjectType);
+}
+function createAuthyonRules(source = {}, options = {}) {
+  const permissions = /* @__PURE__ */ new Set([
+    ...source.permissions ?? [],
+    ...source.scope?.split(/\s+/).filter(Boolean) ?? []
+  ]);
+  const rules = [...permissions].map(permissionToRule).filter(isAbilityRule);
+  for (const role of /* @__PURE__ */ new Set([...source.roles ?? [], ...options.roles ?? []])) {
+    rules.push(...(options.roleRules?.[role] ?? []).map(cloneRule));
+  }
+  rules.push(...(options.rules ?? []).map(cloneRule));
+  return rules;
+}
+function permissionToRule(permission) {
+  const normalized = permission.trim();
+  if (!normalized) return null;
+  if (normalized === "*" || normalized === "*:*" || normalized === "all:manage") {
+    return { action: "manage", subject: "all" };
+  }
+  const separator = normalized.lastIndexOf(":");
+  if (separator <= 0 || separator === normalized.length - 1) return null;
+  const subject = normalized.slice(0, separator);
+  const action = normalized.slice(separator + 1);
+  return {
+    action: action === "*" ? "manage" : action,
+    subject: subject === "*" ? "all" : subject
+  };
+}
+function matchesToken(value, expected, wildcard) {
+  return (Array.isArray(value) ? value : [value]).some(
+    (candidate) => candidate === expected || candidate === wildcard || candidate === "*"
+  );
+}
+function matchesField(pattern, field) {
+  if (pattern === "*" || pattern === field) return true;
+  return pattern.endsWith(".*") && field.startsWith(pattern.slice(0, -1));
+}
+function matchesConditions(subject, conditions) {
+  return Object.entries(conditions).every(([path, expected]) => {
+    if (path === "$and" && Array.isArray(expected)) {
+      return expected.every(
+        (condition) => matchesConditions(subject, condition)
+      );
+    }
+    if (path === "$or" && Array.isArray(expected)) {
+      return expected.some(
+        (condition) => matchesConditions(subject, condition)
+      );
+    }
+    return matchesValue(readPath(subject, path), expected);
+  });
+}
+function matchesValue(actual, expected) {
+  if (!isRecord2(expected) || !Object.keys(expected).some((key) => key.startsWith("$"))) {
+    return isRecord2(expected) && isRecord2(actual) ? matchesConditions(actual, expected) : Object.is(actual, expected);
+  }
+  return Object.entries(expected).every(([operator, operand]) => {
+    switch (operator) {
+      case "$eq":
+        return Object.is(actual, operand);
+      case "$ne":
+        return !Object.is(actual, operand);
+      case "$in":
+        return Array.isArray(operand) && operand.some((value) => Object.is(actual, value));
+      case "$nin":
+        return Array.isArray(operand) && !operand.some((value) => Object.is(actual, value));
+      case "$gt":
+        return typeof actual === "number" && typeof operand === "number" && actual > operand;
+      case "$gte":
+        return typeof actual === "number" && typeof operand === "number" && actual >= operand;
+      case "$lt":
+        return typeof actual === "number" && typeof operand === "number" && actual < operand;
+      case "$lte":
+        return typeof actual === "number" && typeof operand === "number" && actual <= operand;
+      case "$exists":
+        return operand ? actual !== void 0 : actual === void 0;
+      default:
+        return false;
+    }
+  });
+}
+function readPath(value, path) {
+  return path.split(".").reduce((current, part) => isRecord2(current) ? current[part] : void 0, value);
+}
+function defaultSubjectType(subject) {
+  const explicit = subject.__type ?? subject.type ?? subject.kind;
+  if (typeof explicit === "string") return explicit;
+  const constructorName = subject.constructor?.name;
+  return typeof constructorName === "string" ? constructorName : "Object";
+}
+function cloneRule(rule) {
+  return {
+    ...rule,
+    action: Array.isArray(rule.action) ? [...rule.action] : rule.action,
+    subject: Array.isArray(rule.subject) ? [...rule.subject] : rule.subject,
+    fields: rule.fields ? [...rule.fields] : void 0
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAbilityRule(value) {
+  return value !== null;
+}
+
+// src/integrations/authorization.ts
+var AuthorizationError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "AuthorizationError";
+  }
+};
+async function authorizeToken(client, token, options = {}) {
+  if (!token) throw unauthenticated();
+  let userId;
+  let permissions = [];
+  let roles = [];
+  let scope;
+  if (options.verification === "jwks") {
+    if (!options.jwksVerifier) {
+      throw new Error("Authyon: `jwksVerifier` is required for JWKS verification");
+    }
+    let verified;
+    try {
+      verified = await options.jwksVerifier.verifyAccessToken(token);
+    } catch (error) {
+      if (!(error instanceof TokenVerificationError)) throw error;
+      if (error.code === "token.key_unavailable") {
+        throw new AuthorizationError(
+          503,
+          "authorization.unavailable",
+          "Token verification is temporarily unavailable"
+        );
+      }
+      throw unauthenticated();
+    }
+    const { claims } = verified;
+    userId = claims.sub;
+    permissions = claims.permissions ?? [];
+    roles = claims.roles ?? [];
+    scope = claims.scope;
+  } else if (options.verification === "introspect") {
+    const identity = await client.introspect(token, { clientIp: options.clientIp });
+    if (!identity.active) throw unauthenticated();
+    userId = identity.sub;
+    permissions = identity.permissions ?? [];
+    roles = identity.roles ?? [];
+    scope = identity.scope;
+  } else {
+    const identity = await client.validate(token, { clientIp: options.clientIp });
+    if (!identity.valid || !identity.user) throw unauthenticated();
+    userId = identity.user.id;
+    permissions = identity.user.permissions ?? [];
+  }
+  const ability = createAuthyonAbility(
+    { permissions, roles, scope },
+    {
+      rules: options.rules,
+      roleRules: options.roleRules,
+      roles: options.roles,
+      detectSubjectType: options.detectSubjectType
+    }
+  );
+  if (options.requirement && !canAccess(ability, options.requirement)) {
+    throw new AuthorizationError(403, "authorization.forbidden", "Permission denied");
+  }
+  return { token, userId, ability, permissions, roles };
+}
+function authorizeRequest(client, request, options = {}) {
+  const clientIp = options.resolveClientIp?.(request) ?? options.clientIp;
+  return authorizeToken(client, bearerToken(request.headers.get("authorization")), {
+    ...options,
+    clientIp
+  });
+}
+function createExpressAuthorizationMiddleware(client, options = {}) {
+  return async (request, response, next) => {
+    try {
+      const header = request.headers.authorization;
+      const clientIp = resolveExpressClientIp(request, options);
+      const context = await authorizeToken(
+        client,
+        bearerToken(Array.isArray(header) ? header[0] : header),
+        { ...options, clientIp }
+      );
+      request[options.requestProperty ?? "authyon"] = context;
+      next();
+    } catch (error) {
+      if (options.passErrorsToNext || !(error instanceof AuthorizationError)) {
+        next(error);
+        return;
+      }
+      response.status(error.status).json({ code: error.code, message: error.message });
+    }
+  };
+}
+function resolveExpressClientIp(request, options) {
+  const resolved = options.resolveClientIp?.(request) ?? (options.trustProxy ? request.ip : request.socket?.remoteAddress);
+  return resolved ? normalizeClientIp(stripIpv4Prefix(resolved)) : void 0;
+}
+function stripIpv4Prefix(value) {
+  return value.startsWith("::ffff:") ? value.slice(7) : value;
+}
+function createAuthorizationErrorResponse(error) {
+  if (!(error instanceof AuthorizationError)) throw error;
+  return Response.json({ code: error.code, message: error.message }, { status: error.status });
+}
+function canAccess(ability, requirement) {
+  return ability.can(requirement.action, requirement.subject, requirement.field);
+}
+function bearerToken(header) {
+  const match = header?.match(/^Bearer\s+(.+)$/i);
+  if (!match?.[1]) throw unauthenticated();
+  return match[1].trim();
+}
+function unauthenticated() {
+  return new AuthorizationError(
+    401,
+    "authorization.unauthenticated",
+    "A valid bearer token is required"
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuthorizationError,
+  AuthyonAbility,
+  AuthyonAbilityBuilder,
   AuthyonError,
   AuthyonServerClient,
+  AuthyonServerClientBuilder,
+  ErrorCodes,
+  FetchHttpAdapter,
+  JwksTokenVerifier,
+  LoggingHttpAdapter,
   TenantScopedClient,
-  createClient
+  TokenVerificationError,
+  authorizeRequest,
+  authorizeToken,
+  createAuthorizationErrorResponse,
+  createAuthyonAbility,
+  createAuthyonRules,
+  createClient,
+  createExpressAuthorizationMiddleware,
+  normalizeClientIp
 });