@pipeline-builder/api-core 4.1.6 → 4.1.8

package/lib/middleware/auth.js

@@ -380,6 +380,94 @@ export function requireAssurance(options) {
         next();
     }, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });
 }
+/**
+ * Handler-level twin of {@link requireAssurance}, for a route where only SOME
+ * requests must be MFA-grade — e.g. a policy route on which TIGHTENING a setting
+ * stays open to a single-factor session (so an admin without MFA can adopt it)
+ * but LOOSENING it does not. Same rules and the same three refusals. Returns
+ * true when the request was REFUSED (a response has been sent).
+ */
+export function refuseWeakSession(req, res, options) {
+    if (!req.user) {
+        sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+        return true;
+    }
+    return refuseForAssurance(options, req.user, req, res);
+}
+/** `details.reason` on a refusal by {@link requireOrgAdminAssurance}, so the UI
+ *  can say it is the ORG's policy asking, not the route's own requirement. */
+export const ORG_ADMIN_MFA_REASON = 'org_admin_policy';
+/**
+ * The refusal {@link requireOrgAdminAssurance} would send for these claims, or
+ * `undefined` when the request may proceed. Exported so a handler whose policy
+ * applies to only PART of a route (e.g. `generate-token`, where opening a new
+ * machine credential is gated but renewing an existing one is not) applies the
+ * exact same rule rather than a copy of it.
+ */
+export function orgAdminAssuranceRefusal(claims, options) {
+    // The claim is only ever `2`, and only when the policy is on (see JwtPayload).
+    if (!claims || claims.org_admin_aal !== 2)
+        return undefined;
+    if (!isHumanPrincipal(claims)) {
+        if (options.machines === 'allow')
+            return undefined;
+        return {
+            status: HttpStatus.FORBIDDEN,
+            code: ErrorCode.HUMAN_SESSION_REQUIRED,
+            reason: 'machine_principal',
+            message: 'Your organization requires two-factor authentication for this action — API keys and service accounts cannot perform it',
+        };
+    }
+    if ((claims.aal ?? 1) >= 2)
+        return undefined;
+    return {
+        status: HttpStatus.UNAUTHORIZED,
+        code: ErrorCode.MFA_REQUIRED,
+        reason: 'weak_session',
+        message: 'Your organization requires two-factor authentication for administrative actions — sign in again with a passkey or an authenticator code',
+    };
+}
+/**
+ * Apply {@link orgAdminAssuranceRefusal} and send its refusal. Returns true when
+ * the request was REFUSED (a response has been sent). For handler-level use;
+ * routes use {@link requireOrgAdminAssurance}.
+ */
+export function refuseForOrgAdminAssurance(req, res, options) {
+    const refusal = orgAdminAssuranceRefusal(req.user, options);
+    if (!refusal)
+        return false;
+    emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: `org_admin_${refusal.reason}` });
+    recordAuthzDenial(req, 'assurance:org-admin');
+    sendError(res, refusal.status, refusal.message, refusal.code, { reason: ORG_ADMIN_MFA_REASON });
+    return true;
+}
+/**
+ * The org policy "administrative actions require MFA" (`adminActionsRequireMfa`).
+ *
+ * Unlike {@link requireAssurance}, the requirement is the ORG's choice, not the
+ * route's: the gate reads the `org_admin_aal` claim, set at token issue from the
+ * active org's policy (strictest across its ancestors), so a service that cannot
+ * read the org document still enforces it. With the policy off the gate is a
+ * no-op; with it on, a single-factor session is refused 401 `MFA_REQUIRED`
+ * (with `details.reason: 'org_admin_policy'`) — the same code the client already
+ * turns into "enrol a factor / sign in with it", never a sign-out.
+ *
+ * `machines` is decided per route (see {@link OrgAdminAssuranceMachines}): the
+ * policy is about how strongly a PERSON's session was opened, so automation that
+ * legitimately drives a route keeps working (`allow`), while a route that mints
+ * a further credential refuses machines outright (`refuse`, 403
+ * `HUMAN_SESSION_REQUIRED` — the same refusal `requireAssurance` gives them).
+ */
+export function requireOrgAdminAssurance(options) {
+    return tagRouteGate((req, res, next) => {
+        if (!req.user) {
+            return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+        }
+        if (refuseForOrgAdminAssurance(req, res, options))
+            return;
+        next();
+    }, { kind: 'orgAdminAssurance', machines: options.machines });
+}
 /**
  * Enforce `minAssurance` / `maxAge` on a verified token. Returns true when the
  * request was REFUSED (a response has been sent).
@@ -849,4 +937,4 @@ export function verifyServicePrincipal(req) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { tagRouteGate } from './route-table.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { JwksUnavailableError, UnknownKidError, platformJwksCache } from '../services/jwks-cache.js';\nimport {\n  SERVICE_SUBJECT_PREFIX,\n  ServiceKeyError,\n  isServiceKid,\n  serviceIdentity,\n  signServiceJwt,\n  verifyServiceJwt,\n} from '../services/service-keys.js';\nimport { AUTH_METHODS, PRINCIPAL_TYPES, TOKEN_USES, type AssuranceLevel, type JwtPayload } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { HttpRequest } from '../types/http.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { isOpaqueApiKey } from '../utils/api-key.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.js';\nimport { USER_TOKEN_ALGORITHM, decodeJwtHeader } from '../utils/jwk.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n\n/** Issuer/audience pinning, when the deployment configures them. Shared by both chains. */\nfunction issuerAudienceOptions(): { issuer?: string; audience?: string } {\n  return {\n    ...(process.env.JWT_ISSUER ? { issuer: process.env.JWT_ISSUER } : {}),\n    ...(process.env.JWT_AUDIENCE ? { audience: process.env.JWT_AUDIENCE } : {}),\n  };\n}\n\n/**\n * Verify a token that speaks for a PERSON — access, step-up, and the token an\n * opaque access key is exchanged for — against platform's published signing\n * keys.\n *\n * ES256 and a `kid` are both mandatory: no `kid` means no way to pick the right\n * key across a rotation, and any other algorithm is refused outright, which is\n * what makes \"no service accepts an HS256 user token\" a property of the code\n * rather than a convention. Key lookup goes through the shared JWKS cache\n * (10-minute refresh, one refetch on an unknown `kid`, brief negative cache).\n *\n * @throws {UnknownKidError} the key set is current and has no such key → 401.\n * @throws {JwksUnavailableError} the key set could not be obtained → 503; an\n *         unverifiable token is never treated as valid.\n */\nexport async function verifyUserJwt<T = JwtPayload>(token: string): Promise<T> {\n  const header = decodeJwtHeader(token);\n  if (header?.alg !== USER_TOKEN_ALGORITHM || !header.kid) {\n    throw new jwt.JsonWebTokenError(`User tokens must be signed with ${USER_TOKEN_ALGORITHM} and carry a kid`);\n  }\n  const key = await platformJwksCache().getKey(header.kid);\n  return jwt.verify(token, key, { algorithms: [USER_TOKEN_ALGORITHM], ...issuerAudienceOptions() }) as T;\n}\n\n/**\n * Verify ANY bearer token and return its claims.\n *\n * Since #14 there is no shared secret left: BOTH chains are ES256 with a `kid`,\n * so the dispatch is by **who owns the `kid`** rather than by algorithm — and\n * because a `kid` is an RFC 7638 thumbprint, ownership is a fact about the key,\n * not a claim the token makes about itself:\n *\n * - a `kid` published in the per-service key bundle → an INTERNAL SERVICE token\n *   ({@link signServiceToken}), verified with that service's key; its `sub` must\n *   name the same service, so one service can never speak for another.\n * - anything else → a platform-signed USER token, verified against platform's\n *   published JWKS. A token claiming `principalType: 'service'` is refused\n *   here: an internal identity may not ride the user signing key.\n *\n * Anything that is not ES256 with a `kid` fails in both chains, which is what\n * makes \"no HS256 token is accepted anywhere\" a property of the code.\n */\nexport async function verifyBearerToken(token: string): Promise<JwtPayload> {\n  const header = decodeJwtHeader(token);\n  if (!header?.alg) throw new jwt.JsonWebTokenError('Malformed token header');\n\n  if (header.kid && isServiceKid(header.kid)) {\n    const claims = verifyServiceJwt<JwtPayload>(token, { kid: header.kid, ...issuerAudienceOptions() });\n    if (claims.principalType !== 'service') {\n      emitCounter('service_key_non_service_token_rejected_total', { alg: header.alg });\n      throw new jwt.JsonWebTokenError('A service signing key may only mint a service principal');\n    }\n    return claims;\n  }\n\n  const claims = await verifyUserJwt(token);\n  if (claims.principalType === 'service') {\n    throw new jwt.JsonWebTokenError('Service principals may not be signed with the user signing key');\n  }\n  return claims;\n}\n\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n  /**\n   * Demand that the whole SESSION be at least this assurance level (#8).\n   *\n   * `minAssurance: 2` means the person authenticated with a second factor — a\n   * passkey with user verification, a password plus an authenticator code, or\n   * SSO through an IdP the org marked as enforcing MFA. A weaker token gets\n   * **401 `MFA_REQUIRED`**, which the client answers by sending the person to\n   * enrolment or to a stronger sign-in; refreshing cannot help, because `aal`\n   * lives on the session slot and a refresh never raises it.\n   *\n   * This is the SESSION-level counterpart to {@link requireStepUp}, which stays\n   * a fresh, per-action confirmation. Use both on the most dangerous routes.\n   *\n   * MACHINES NEVER SATISFY IT. A service principal, an org service account and\n   * an exchanged access key all get **403 `HUMAN_SESSION_REQUIRED`** — there is\n   * no person behind them to have presented a factor, so \"assurance\" is not a\n   * question their credential can answer. That is deliberately not a silent\n   * pass-through for internal services: a route that demands MFA is a route a\n   * human is doing something dangerous on.\n   */\n  minAssurance?: AssuranceLevel;\n  /**\n   * With {@link minAssurance}, additionally bound how long ago that sign-in\n   * happened (seconds, compared against the token's `auth_time`). A session that\n   * is MFA-grade but older than this gets **401 `REAUTH_REQUIRED`**. Ignored\n   * without `minAssurance` — \"how recent\" is only meaningful once \"how strong\"\n   * is being asked.\n   */\n  maxAge?: number;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  const gate = tagRouteGate((req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  }, { kind: 'auth' });\n  if (options.minAssurance) {\n    tagRouteGate(gate, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n  }\n  return gate;\n}\ntagRouteGate(requireAuth, { kind: 'auth' });\n\n/**\n * A source of the CURRENT `tokenVersion` for a user, backed by a store the\n * stateless services can read (in practice a Redis key the platform publishes\n * to on every privilege change). Registered via {@link setTokenRevocationStore}.\n *\n * `getCurrentVersion` returns the user's current version, or `null` when the\n * store has no entry — a miss is treated as \"no known revocation\" (fail-open):\n * revocation entries are published with a TTL matching the access-token\n * lifetime, so a missing entry means any token old enough to predate it has\n * already expired on its own.\n */\nexport interface TokenRevocationStore {\n  getCurrentVersion(userId: string): Promise<number | null>;\n  /**\n   * Whether one IMPERSONATION session (by token `jti`) has been ended early.\n   *\n   * Optional so a store that predates it still links — but a store WITHOUT it\n   * cannot answer, and an impersonation token is then REJECTED. Unlike\n   * `getCurrentVersion`, this is deliberately not fail-open: the platform ends a\n   * session when someone withdraws consent, and a withdrawn consent that keeps\n   * working in every other service is not withdrawn.\n   */\n  getSessionRevocation?(jti: string): Promise<SessionRevocationState>;\n}\n\n/**\n * `revoked`     — the session was ended; reject.\n * `live`        — no revocation recorded; allow.\n * `unavailable` — the store couldn't be read or can't answer; REJECT. Distinct\n *                 from `live` precisely so an outage can't read as \"not revoked\".\n */\nexport type SessionRevocationState = 'revoked' | 'live' | 'unavailable';\n\nlet tokenRevocationStore: TokenRevocationStore | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide token-revocation store.\n * When unset (the default), `requireAuth` performs NO revocation check (it relies\n * on the short access-token TTL); services opt in at boot by wiring their Redis\n * client. Platform keeps its own Mongo-backed check and need not register one.\n */\nexport function setTokenRevocationStore(store: TokenRevocationStore | undefined): void {\n  tokenRevocationStore = store;\n  if (store) revocationStoreMissingWarned = false; // re-arm if a store is (re)registered\n}\n\n/** One-shot guard so the \"revocation inactive\" warning doesn't flood the logs. */\nlet revocationStoreMissingWarned = false;\n\n/**\n * Returns true when `decoded` has been revoked per the registered store: its\n * embedded `tokenVersion` is strictly behind the store's current version.\n * Fail-open — any store error, a missing entry, or a token/store without a\n * usable version yields `false` (allow). Never throws.\n */\nasync function isTokenRevoked(decoded: JwtPayload): Promise<boolean> {\n  const store = tokenRevocationStore;\n  if (!store) {\n    // Make the \"revocation is OFF\" state OBSERVABLE: a service that verifies user\n    // tokens but forgot `setTokenRevocationStore()` silently disables the session\n    // kill-switch. Warn ONCE (only for a revocable user token) so a misconfigured\n    // boot surfaces in the logs instead of failing open invisibly.\n    if (!revocationStoreMissingWarned && decoded.sub && typeof decoded.tokenVersion === 'number') {\n      revocationStoreMissingWarned = true;\n      logger.warn('Token revocation store NOT registered — revocation checks are INACTIVE (setTokenRevocationStore was never called); revoked/compromised sessions stay valid until natural TTL');\n    }\n    return false;\n  }\n  if (!decoded.sub || typeof decoded.tokenVersion !== 'number') return false;\n  try {\n    const current = await store.getCurrentVersion(decoded.sub);\n    return current !== null && decoded.tokenVersion < current;\n  } catch {\n    // Fail-open: a revocation-store outage must not lock every user out.\n    return false;\n  }\n}\n\n/**\n * Resolve an impersonation session's revocation state. Never throws: any failure\n * — no store, a store that can't answer, a read error — is `unavailable`, which\n * callers treat as revoked.\n */\nasync function sessionRevocationState(jti: string): Promise<SessionRevocationState> {\n  const store = tokenRevocationStore;\n  if (!store?.getSessionRevocation) return 'unavailable';\n  try {\n    return await store.getSessionRevocation(jti);\n  } catch {\n    return 'unavailable';\n  }\n}\n\n/** An impersonation session token: it names the operator AND carries its own session id. */\nfunction isImpersonationSession(decoded: { impersonatorId?: unknown; jti?: unknown }): decoded is { impersonatorId: string; jti: string } {\n  return typeof decoded.impersonatorId === 'string' && typeof decoded.jti === 'string' && decoded.jti.length > 0;\n}\n\n/**\n * Public revocation check for routes that verify a platform JWT OUTSIDE\n * `requireAuth` (e.g. the image-registry `/token` mint path, which resolves\n * identity itself). Returns true when the token's `tokenVersion` is strictly\n * behind the store's current version. Fail-open (never throws) — a store outage\n * or a token/store without a usable version yields false (allow), matching\n * `requireAuth`. Pass the verified JWT claims (`sub`, `tokenVersion`).\n */\nexport async function isAccessTokenRevoked(\n  claims: { sub?: string; tokenVersion?: number; jti?: string; impersonatorId?: string },\n): Promise<boolean> {\n  // An impersonation session is revoked unless the store positively says live —\n  // including on this out-of-band path, or a revoked session could still mint\n  // registry tokens.\n  if (isImpersonationSession(claims) && await sessionRevocationState(claims.jti) !== 'live') return true;\n  return isTokenRevoked(claims as JwtPayload);\n}\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  // An OPAQUE ACCESS KEY (`pb_pat_…` / `pb_sa_…`) carries no claims and no\n  // signature, so it cannot be verified here. Trade it at platform for a\n  // short-lived JWT (cached in-process until it expires) and then verify that\n  // JWT on the normal path — services never read a key hash. See\n  // `services/api-key-exchange.ts`.\n  if (isOpaqueApiKey(parts[1])) {\n    void resolveApiKey(options, parts[1], req, res, next);\n    return;\n  }\n\n  // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n  // Express's error middleware — verification itself never rejects (it maps\n  // every failure to a response).\n  void verifyAndAttach(options, parts[1], req, res, next).catch(next);\n}\n\n/**\n * Exchange an opaque key for a JWT, then continue on the normal verification\n * path. A refused key is a 401; an unreachable platform is a 503 (never a pass —\n * an unverifiable credential is not an identity).\n */\nasync function resolveApiKey(\n  options: RequireAuthOptions,\n  key: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  // Loaded LAZILY, on the first key ever presented. A static import would put\n  // the HTTP client (and platform's address) into the import graph of every\n  // module that merely uses `requireAuth`, which both widens the boot graph and\n  // breaks any test that mocks `http-client.js` with a partial module.\n  const { exchangeApiKey, ApiKeyExchangeUnavailableError } = await import('../services/api-key-exchange.js');\n  let token: string;\n  try {\n    token = await exchangeApiKey(key);\n  } catch (error) {\n    if (error instanceof ApiKeyExchangeUnavailableError) {\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Access-key verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid or revoked access key', ErrorCode.TOKEN_INVALID);\n  }\n  await verifyAndAttach(options, token, req, res, next);\n}\n\nasync function verifyAndAttach(\n  options: RequireAuthOptions,\n  rawToken: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  try {\n    // Two chains, one entry point (see `verifyBearerToken`): a user token must\n    // be ES256 signed by platform and verified against its published JWKS; an\n    // internal service token stays on the shared secret and must declare itself\n    // a service principal. Both pin the algorithm (no alg-confusion, no\n    // `alg:none`) and both apply the optional issuer/audience binding.\n    const decoded = await verifyBearerToken(rawToken);\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role || !hasValidIdentityClaims(decoded)) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    // Service-token kill-switch: reject a service principal whose service has\n    // been added to the denylist. Rotating the shared JWT secret is the only\n    // other way to invalidate a service token before its (short) TTL — but that\n    // nukes EVERY service token fleet-wide. This lets one compromised/rogue\n    // service be cut off surgically. O(1) Set lookup, zero cost when the denylist\n    // is empty (the default), so it never taxes the S2S hot path unless armed.\n    if (isServiceTokenDenied(decoded)) {\n      emitCounter('service_token_denied_total', { service: serviceNameOf(decoded) ?? 'unknown' });\n      logger.warn('Rejected denylisted service token', { sub: decoded.sub });\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Service token revoked', ErrorCode.TOKEN_REVOKED);\n    }\n\n    req.user = { ...decoded };\n\n    // BOOTSTRAP-ADMIN ENROLMENT SESSION (#8, revision 4). Such a token exists so\n    // the install's only admin can enrol a factor; it is `aal: 1` and must not\n    // reach anything else. Platform — which owns the exception and knows which\n    // of its own routes `init-platform.sh` calls — allows an explicit few before\n    // this point (see its own `requireAuth`); in EVERY other service the answer\n    // is simply no, so the reach restriction holds without a per-service\n    // allowlist to keep in sync.\n    if (decoded.mfaEnrollmentPending === true) {\n      emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: 'bootstrap_session' });\n      recordAuthzDenial(req, 'mfa-enrolment');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Finish setting up two-factor authentication before using the rest of Pipeline Builder',\n        ErrorCode.MFA_ENROLLMENT_REQUIRED,\n      );\n    }\n\n    // Session-level assurance (`requireAuth({ minAssurance, maxAge })`).\n    if (options.minAssurance\n      && refuseForAssurance({ minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) }, decoded, req, res)) return;\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session-invalidation check for the stateless services: reject a token\n    // whose `tokenVersion` is behind the revocation store's current value (a\n    // privilege change the platform published). No store registered ⇒ this is a\n    // no-op and control passes straight through. Fail-open on any store error.\n    // An impersonation session is checked even when NO store is registered: the\n    // tokenVersion check below is a no-op without a store, but for a session\n    // that would silently mean \"never revoked\". Here no store ⇒ unavailable ⇒\n    // rejected. See `TokenRevocationStore.getSessionRevocation`.\n    const impersonation = isImpersonationSession(decoded);\n    if (impersonation || (tokenRevocationStore && decoded.sub && typeof decoded.tokenVersion === 'number')) {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — without it, that throw would surface as an\n      // unhandled rejection (this `next()` runs in a microtask, outside the\n      // surrounding try/catch and Express's per-layer dispatch). The checks\n      // themselves never reject, so the catch only ever sees a downstream error.\n      (async () => {\n        if (impersonation) {\n          const state = await sessionRevocationState(decoded.jti as string);\n          if (state !== 'live') {\n            return sendError(\n              res,\n              HttpStatus.UNAUTHORIZED,\n              state === 'revoked'\n                ? 'This impersonation session has been ended'\n                : 'This impersonation session could not be verified',\n              ErrorCode.TOKEN_REVOKED,\n            );\n          }\n        }\n        if (tokenRevocationStore && decoded.sub && typeof decoded.tokenVersion === 'number' && await isTokenRevoked(decoded)) {\n          return sendError(res, HttpStatus.UNAUTHORIZED, 'Session has been revoked; please sign in again', ErrorCode.TOKEN_REVOKED);\n        }\n        next();\n      })().catch(next);\n      return;\n    }\n\n    next();\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    // The signing keys couldn't be fetched, so the token's validity is UNKNOWN.\n    // Fail CLOSED with a retryable 503 — never a pass, and never a 401 that\n    // would send a legitimate client off to re-authenticate over our outage.\n    // Same reasoning for the SERVICE chain: no readable key bundle means no way\n    // to tell a peer's token from a forgery, so the request is refused with a\n    // retryable 503 rather than admitted or bounced to re-authenticate.\n    if (error instanceof JwksUnavailableError || error instanceof ServiceKeyError) {\n      logger.warn('Rejecting request: token signing keys unavailable', { error: error.message });\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Token verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n\n    if (error instanceof UnknownKidError || error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n/**\n * Whether a set of verified claims speaks for a PERSON's own session — the only\n * kind of credential an assurance level can be asserted about.\n *\n * Excludes all three machine shapes: an internal service principal, an org\n * service account, and any exchanged access key (`token_use: 'api_key'`, i.e. a\n * PAT or a service-account key), each of which authenticates a program holding a\n * secret rather than a person presenting factors.\n */\nexport function isHumanPrincipal(claims: Pick<JwtPayload, 'principalType' | 'token_use'> | undefined): boolean {\n  return claims?.principalType === 'user' && claims.token_use === 'access';\n}\n\n/** What an assurance gate demands. */\nexport interface AssuranceOptions {\n  minAssurance: AssuranceLevel;\n  maxAge?: number;\n}\n\n/**\n * Standalone assurance gate, for a service whose own `requireAuth` is not\n * api-core's (platform's is its own, because it reads Mongo). Compose it AFTER\n * authentication: `router.get('/x', requireAuth, requireAssurance({ minAssurance: 2 }), h)`.\n *\n * Identical rules and identical refusals to `requireAuth({ minAssurance })` —\n * that option simply calls the same check inline, so there is one implementation\n * of \"is this session MFA-grade\" in the codebase.\n */\nexport function requireAssurance(options: AssuranceOptions) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    if (refuseForAssurance(options, req.user as JwtPayload, req, res)) return;\n    next();\n  }, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n}\n\n/**\n * Enforce `minAssurance` / `maxAge` on a verified token. Returns true when the\n * request was REFUSED (a response has been sent).\n *\n * Three distinct refusals, because the client's next move differs for each:\n * a machine must stop (403), a weak session must gain a factor (401\n * `MFA_REQUIRED` → enrolment, never a sign-out), and a stale one must simply\n * authenticate again (401 `REAUTH_REQUIRED`).\n */\nfunction refuseForAssurance(\n  options: AssuranceOptions,\n  decoded: JwtPayload,\n  req: Request,\n  res: Response,\n): boolean {\n  const minAssurance = options.minAssurance;\n  const refuse = (reason: string, status: number, message: string, code: ErrorCode): true => {\n    emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason });\n    recordAuthzDenial(req, `assurance:${minAssurance}`);\n    sendError(res, status, message, code);\n    return true;\n  };\n\n  if (!isHumanPrincipal(decoded)) {\n    return refuse(\n      'machine_principal', HttpStatus.FORBIDDEN,\n      'This action requires a person signed in with two-factor authentication — API keys and service accounts cannot perform it',\n      ErrorCode.HUMAN_SESSION_REQUIRED,\n    );\n  }\n  if ((decoded.aal ?? 1) < minAssurance) {\n    return refuse(\n      'weak_session', HttpStatus.UNAUTHORIZED,\n      'This action requires two-factor authentication — sign in again with a passkey or an authenticator code',\n      ErrorCode.MFA_REQUIRED,\n    );\n  }\n  if (options.maxAge !== undefined) {\n    const authTime = decoded.auth_time;\n    // No `auth_time` is not \"recent enough by default\" — `hasValidIdentityClaims`\n    // already requires it on a user token, so an absent one means a token this\n    // gate cannot reason about. Fail closed.\n    if (typeof authTime !== 'number' || Math.floor(Date.now() / 1000) - authTime > options.maxAge) {\n      return refuse(\n        'stale_session', HttpStatus.UNAUTHORIZED,\n        'This action requires a recent sign-in — please authenticate again',\n        ErrorCode.REAUTH_REQUIRED,\n      );\n    }\n  }\n  return false;\n}\n\n/**\n * Whether a verified token carries a well-formed identity: a known\n * `principalType` and `token_use`, and the claims that kind of principal must\n * have. Fails closed — a token minted before these claims existed, or one with a\n * contradictory combination, is not an identity any gate should reason about.\n *\n * - `service`: `token_use: 'access'` and a `service:<name>` subject (the name\n *   feeds the denylist and audit attribution).\n * - `user` / `service_account`: `amr` (known methods), `aal` and `auth_time`.\n */\nexport function hasValidIdentityClaims(decoded: Partial<JwtPayload>): boolean {\n  if (!decoded.principalType || !PRINCIPAL_TYPES.includes(decoded.principalType)) return false;\n  if (!decoded.token_use || !TOKEN_USES.includes(decoded.token_use)) return false;\n  if (decoded.principalType === 'service') {\n    return decoded.token_use === 'access'\n      && typeof decoded.sub === 'string'\n      && decoded.sub.startsWith(SERVICE_SUBJECT_PREFIX)\n      && decoded.sub.length > SERVICE_SUBJECT_PREFIX.length;\n  }\n  return Array.isArray(decoded.amr)\n    && decoded.amr.every((m) => AUTH_METHODS.includes(m))\n    && (decoded.aal === 1 || decoded.aal === 2)\n    && typeof decoded.auth_time === 'number';\n}\n\n/**\n * Whether the request's user holds `permission`. Superadmins implicitly hold\n * every permission. Reads the resolved `permissions` claim (set at token issue,\n * or re-derived per request by the platform).\n */\nexport function userHasPermission(req: Request, permission: Permission): boolean {\n  return hasPermission(req.user?.permissions, permission, req.user?.isSuperAdmin);\n}\n\n/**\n * Context passed to a registered authorization-denial auditor when a\n * state-changing request is rejected by `requirePermission` /\n * `requireSystemAdmin`.\n */\nexport interface AuthzDenialInfo {\n  /** The denied user's id (`sub`), if authenticated. */\n  actorId?: string;\n  actorEmail?: string;\n  /** The user's active org at denial time. */\n  orgId?: string;\n  /** HTTP method + path of the rejected request. */\n  method: string;\n  path: string;\n  /** What was required: the missing permission(s), or 'system-admin'. */\n  required: string;\n}\n\n/**\n * Optional sink for denied-authorization events. Left unset by default so\n * api-core stays decoupled from any audit transport — a service registers one\n * at boot (typically forwarding to its `RemoteAuditClient` as an\n * `authz.denied` event, or, on platform, to the local `audit()` helper).\n * MUST be best-effort: it is invoked inside the request path, so it must never\n * throw or block (the gate wraps the call in try/catch regardless).\n */\nlet authzDenialAuditor: ((info: AuthzDenialInfo) => void) | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide authorization-denial\n * auditor. Idempotent; the last registration wins.\n */\nexport function setAuthzDenialAuditor(fn: ((info: AuthzDenialInfo) => void) | undefined): void {\n  authzDenialAuditor = fn;\n}\n\n/**\n * Emit a denial event, best-effort. Only fires for state-changing (non-GET,\n * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and\n * would amplify audit volume under a scan. Never throws.\n *\n * The permission gates here call it themselves. Export it for data-driven checks\n * a route makes inline (cross-org access, service-only endpoints), so those 403s\n * reach the same `authz.denied` trail. `required` names what was missing.\n */\nexport function recordAuthzDenial(req: Request, required: string): void {\n  const auditor = authzDenialAuditor;\n  if (!auditor) return;\n  const method = req.method.toUpperCase();\n  if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return;\n  try {\n    auditor({\n      actorId: req.user?.sub,\n      actorEmail: req.user?.email,\n      orgId: req.user?.organizationId,\n      method,\n      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/**\n * Requires that the user hold AT LEAST ONE of the given permissions (or be a\n * superadmin). Use after requireAuth. Mirrors `requireRole`'s any-of semantics;\n * pass a single permission for a specific action, or several when any one of\n * them should grant access.\n */\nexport function requirePermission(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    // userHasPermission → hasPermission already grants superadmins every\n    // permission, so this single check covers both the superadmin bypass and\n    // the any-of membership test without re-inlining either.\n    if (permissions.some((p) => userHasPermission(req, p))) return next();\n    recordAuthzDenial(req, permissions.join(' or '));\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${permissions.join(' or ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }, { kind: 'permission', mode: 'any', permissions });\n}\n\n/**\n * Requires that the user hold EVERY one of the given permissions (or be a\n * superadmin) — the AND counterpart to `requirePermission`'s any-of. Use for a\n * sensitive action that legitimately demands two distinct capabilities at once\n * (e.g. a cross-surface operation), so the guarantee is explicit rather than\n * approximated by chaining two `requirePermission` gates. Superadmins bypass\n * (they implicitly hold every permission).\n */\nexport function requireAllPermissions(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    const missing = permissions.filter((p) => !userHasPermission(req, p));\n    if (missing.length === 0) return next();\n    recordAuthzDenial(req, permissions.join(' and '));\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${missing.join(' and ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }, { kind: 'permission', mode: 'all', permissions });\n}\n\n/**\n * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (`principalType: 'service'`). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    if (isServicePrincipal(req) || permissions.some((p) => userHasPermission(req, p))) return next();\n    recordAuthzDenial(req, permissions.join(' or '));\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${permissions.join(' or ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }, { kind: 'permission', mode: 'any', permissions, allowService: true });\n}\n\n/**\n * Gate an endpoint to internal service-to-service callers only (a\n * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    // 403 (not 400) — this is an authorization refusal; status must match the\n    // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).\n    return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\n}\ntagRouteGate(requireServicePrincipal, { kind: 'servicePrincipal' });\n\n/**\n * THE gate for an INTERNAL route (#14) — the one every `/internal/*` path, the\n * quota usage counters, the entity-event ingest and the audit ingest go through.\n *\n * Two rules, both fail-closed:\n *\n *  1. **No user token, ever.** Not a member's, not a superadmin's, not a\n *     service-account key's. An internal route is a peer-service API surface, so\n *     \"a sufficiently privileged human\" is not an acceptable caller — that\n *     equivalence is exactly how a browser-reachable path becomes a tenant\n *     boundary bug. `requireServicePrincipal` already refused users; this also\n *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around\n *     the individual internal routes.\n *  2. **Only the NAMED callers.** `callers` lists the services that legitimately\n *     call this route, and the name is cryptographically bound to the signing\n *     key (`services/service-keys.ts`), so this is an identity check rather than\n *     a claim check. It is the same allow-list the mesh policy names, at the\n *     layer that also holds in docker compose, where there is no mesh at all —\n *     the Istio `AuthorizationPolicy` is defence in depth on top, never the\n *     enforcement.\n *\n * Compose after `requireAuth` so `req.user` is populated. Refusals are counted\n * (`internal_route_refused_total`) and audited through the shared `authz.denied`\n * sink.\n */\nexport function requireInternalService(options: { callers: readonly string[] }) {\n  const allowed = new Set(options.callers);\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    const refuse = (reason: 'unauthenticated' | 'user_token' | 'wrong_caller'): void => {\n      emitCounter('internal_route_refused_total', {\n        service: serviceIdentity(),\n        route: req.route?.path ? `${req.method} ${req.baseUrl}${req.route.path}` : `${req.method} ${(req.originalUrl || req.url).split('?')[0]}`,\n        reason,\n        caller: serviceNameOf(req.user) ?? 'none',\n      });\n      recordAuthzDenial(req, `internal-service (${options.callers.join(', ')})`);\n      if (reason === 'unauthenticated') {\n        return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n      }\n      logger.warn('Refused an internal route', { reason, path: (req.originalUrl || req.url).split('?')[0], caller: serviceNameOf(req.user) });\n      return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n    };\n\n    if (!req.user) return refuse('unauthenticated');\n    if (!isServicePrincipal(req)) return refuse('user_token');\n    const caller = serviceNameOf(req.user);\n    if (!caller || !allowed.has(caller)) return refuse('wrong_caller');\n    next();\n  }, { kind: 'servicePrincipal' }, { kind: 'internalService', callers: [...options.callers] });\n}\n\n/**\n * The system tenant's canonical org **id** — a fixed, well-known ObjectId (NOT\n * the string 'system'). This is the single knob every service resolves the\n * system tenant through; override via the `SYSTEM_ORG_ID` env for alternate\n * installs. The system org's human identifier stays the slug/name 'system'\n * (see {@link SYSTEM_ORG_SLUG}); only its `_id` is this ObjectId.\n */\nexport const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || '000000000000000000000001').toLowerCase();\n\n/** The system org's well-known slug/name (the human identifier; its `_id` is {@link SYSTEM_ORG_ID}). */\nexport const SYSTEM_ORG_SLUG = 'system';\n\n/**\n * Check if an orgId or orgName/slug matches the system org. Use this instead of\n * comparing directly: the id is now an ObjectId ({@link SYSTEM_ORG_ID}) while the\n * name/slug is 'system' ({@link SYSTEM_ORG_SLUG}), so the two are compared against\n * their respective canonical values.\n */\nexport function isSystemOrgId(orgId?: string, orgName?: string): boolean {\n  return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_SLUG;\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT. The \"membership in the well-known 'system' org with role\n * admin/owner\" path was removed — it conflated a Pipeline Builder operator\n * with a real customer tenant in the data model, and meant any unintended\n * write that created a 'system'-named org could quietly grant cross-org\n * authority. The `system` org still exists as a *content holder* for shared\n * sample data; it just no longer confers privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/**\n * Whether the request's token carries a specific capability `scope` (e.g.\n * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine\n * identity — a normal interactive user token has no `scope` and returns false.\n */\nexport function hasScope(req: Request, scope: string): boolean {\n  return req.user?.scope === scope;\n}\n\n/** Requires a system admin — granted solely by the `isSuperAdmin` token claim\n *  (the org-membership path was removed). Use after requireAuth. */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    recordAuthzDenial(req, 'system-admin');\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\ntagRouteGate(requireSystemAdmin, { kind: 'systemAdmin' });\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      // Route feature-gate denials through the same audit sink as\n      // requirePermission / requireSystemAdmin so a probe for an\n      // unentitled capability leaves a trail (state-changing methods only).\n      recordAuthzDenial(req, `feature:${feature}`);\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  }, { kind: 'feature', feature });\n}\n\n// ---------------------------------------------------------------------------\n// Service-to-service tokens\n//\n// Inter-service HTTP calls (billing → message, platform → compliance, etc.)\n// need to satisfy the same `requireAuth` middleware as user requests.\n// `signServiceToken` mints a short-lived ES256 JWT signed with THIS service's\n// OWN key (see `services/service-keys.ts`), carrying `principalType: 'service'`\n// and naming the calling service via `sub: 'service:<name>'`. Gates branch on\n// the claim; the subject names — and since #14 the name is cryptographically\n// bound to the signing key, so it can also be trusted.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream `requireOrganization` /\n// `requireSystemAdmin` rely on the org/role embedded in the token.\n//\n// Tokens default to 5-minute TTL — long enough to survive a backend hop,\n// short enough that a leaked token is low-value.\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;\n\n/**\n * Denylist of service NAMES (the `<name>` in `sub: service:<name>`) whose tokens\n * `requireAuth` must reject. Read from `SERVICE_TOKEN_DENYLIST` (comma-separated)\n * at process start, so arming it is a config change + rollout — it cuts off a\n * compromised service WITHOUT rotating any key, and (unlike the pre-#14 shared\n * secret) without invalidating every other service's tokens as collateral.\n */\nconst serviceTokenDenylist = new Set(\n  (process.env.SERVICE_TOKEN_DENYLIST || '')\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean),\n);\n\n/**\n * The calling service's name for a SERVICE principal (`principalType: 'service'`),\n * else `undefined`. A user token never yields a name, whatever its `sub` says.\n */\nexport function serviceNameOf(claims: { principalType?: string; sub?: string } | undefined): string | undefined {\n  if (claims?.principalType !== 'service' || typeof claims.sub !== 'string') return undefined;\n  if (!claims.sub.startsWith(SERVICE_SUBJECT_PREFIX)) return undefined;\n  return claims.sub.slice(SERVICE_SUBJECT_PREFIX.length) || undefined;\n}\n\n/** True when the claims are a service principal whose service is on the denylist. */\nexport function isServiceTokenDenied(claims: { principalType?: string; sub?: string }): boolean {\n  if (serviceTokenDenylist.size === 0) return false;\n  const name = serviceNameOf(claims);\n  return name !== undefined && serviceTokenDenylist.has(name);\n}\n\nexport interface ServiceTokenOptions {\n  /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */\n  serviceName: string;\n  /** Active org context for the call. Use the target tenant's org id, or the\n   *  well-known `SYSTEM_ORG_ID` (an ObjectId) for system-wide ops — NOT the string\n   *  'system', which id-based system-org checks won't recognize. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n  /**\n   * Role the token carries (required — no implicit default). **Pass the LOWEST\n   * role the call actually needs** (`'member'` for read / data-plane calls) so a\n   * leaked service token can't perform admin actions in the target org.\n   * `isAdmin` is derived from this (admin|owner → true).\n   */\n  role: 'owner' | 'admin' | 'member';\n  /**\n   * Optional fine-grained permission claim. Prefer this + `role: 'member'` over a\n   * high role when a call needs ONE specific capability (e.g. `['plugins:write']`\n   * to push a plugin image) — the token then satisfies that permission gate\n   * WITHOUT carrying `isAdmin`, so a leaked token can't perform admin actions.\n   */\n  permissions?: Permission[];\n}\n\n/**\n * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.\n * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.\n * Scope it with `opts.role` — least privilege keeps a leaked token low-value.\n *\n * `opts.serviceName` must be THIS process's own identity (`SERVICE_NAME`): a\n * service holds only its own signing key, so minting a token that names another\n * service throws rather than producing one every peer would reject. That is the\n * one behaviour change #14 forces on callers — see `services/service-keys.ts`.\n */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role;\n  const payload: Omit<JwtPayload, 'sub'> = {\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    principalType: 'service',\n    token_use: 'access',\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n    // Unique token id on every mint. Combined with the short (300s default) TTL\n    // this gives each service token a distinct identity — the correlation handle\n    // for tracing which mint performed a cross-service action, and the building\n    // block for replay detection (a verifier can track seen jtis). It does NOT\n    // by itself prevent replay within the TTL window.\n    jti: randomUUID(),\n    // Least-privilege capability claim (optional) — lets a member-role token\n    // satisfy a specific permission gate without carrying isAdmin.\n    ...(opts.permissions && opts.permissions.length > 0 ? { permissions: opts.permissions } : {}),\n  };\n  // `sub`, `iat`/`exp` and the optional issuer/audience that requireAuth\n  // verifies are stamped by the signer, so there is exactly one place that\n  // decides what a service token says.\n  return signServiceJwt(payload as Record<string, unknown>, {\n    serviceName: opts.serviceName,\n    expiresInSeconds: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n    ...issuerAudienceOptions(),\n  });\n}\n\n/** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */\nexport function getServiceAuthHeader(opts: ServiceTokenOptions): string {\n  return `Bearer ${signServiceToken(opts)}`;\n}\n\n/** True when `req.user` is a service principal (`principalType: 'service'`, minted by `signServiceToken`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.principalType === 'service';\n}\n\n/**\n * True when `req.user` is an ORG SERVICE ACCOUNT (`principalType:\n * 'service_account'`) — a non-human principal owned by one org, authenticating\n * with a `pb_sa_…` key exchanged at platform.\n *\n * A service account is NOT an internal service principal: it holds org Roles and\n * is subject to every permission gate a member is. What it can never do is\n * satisfy a HUMAN-presence requirement — step-up (and any later assurance gate)\n * refuses it outright, because there is no person behind it to re-verify.\n */\nexport function isServiceAccountPrincipal(req: Request): boolean {\n  return req.user?.principalType === 'service_account';\n}\n\n/** True when `req.user` is the named internal service (e.g. `'billing'`). */\nexport function isServicePrincipalNamed(req: Request, serviceName: string): boolean {\n  return serviceNameOf(req.user) === serviceName;\n}\n\n/**\n * PRE-auth check: cryptographically verify the request carries a valid, signed\n * SERVICE token (`principalType: 'service'`). Unlike {@link isServicePrincipal}\n * (which reads the already-populated `req.user`), this verifies the bearer token\n * itself, so it is safe to call BEFORE `requireAuth` runs — e.g. the global rate\n * limiter's `skip`, which must not trust the spoofable `x-internal-service`\n * header. Mirrors `requireAuth`'s SERVICE chain exactly (the signer's own key,\n * resolved by `kid`, with the `sub`/signer agreement check and the optional\n * issuer/audience) and returns `false` on any missing/invalid/non-service token\n * — including any platform-signed USER token, whose `kid` is not in the service\n * bundle at all. Stays SYNCHRONOUS, which is why the per-service public keys are\n * distributed as a mounted bundle rather than fetched over HTTP.\n */\nexport function verifyServicePrincipal(req: Request): boolean {\n  const parts = req.headers.authorization?.split(' ');\n  if (!parts || parts.length !== 2 || parts[0] !== 'Bearer') return false;\n  try {\n    const header = decodeJwtHeader(parts[1]);\n    if (!header?.kid || !isServiceKid(header.kid)) return false;\n    const decoded = verifyServiceJwt<JwtPayload>(parts[1], { kid: header.kid, ...issuerAudienceOptions() });\n    if (decoded.type !== 'access' || decoded.principalType !== 'service' || !hasValidIdentityClaims(decoded)) return false;\n    // A denylisted (killed) service must NOT be treated as a trusted principal —\n    // otherwise it keeps the rate-limiter exemption even though requireAuth rejects\n    // it on real routes. Fold the kill-switch into the pre-auth check too.\n    return !isServiceTokenDenied(decoded);\n  } catch {\n    return false;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAkC,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACrG,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,YAAY,EACZ,eAAe,EACf,cAAc,EACd,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAwC,MAAM,oBAAoB,CAAC;AACrH,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAmB,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAwB,MAAM,sBAAsB,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,MAAM,MAAM,GAAG,YAAY,CAAC,iBAAiB,CAAC,CAAC;AAE/C,2FAA2F;AAC3F,SAAS,qBAAqB;IAC5B,OAAO;QACL,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACrE,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC5E,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAiB,KAAa;IAC/D,MAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IACtC,IAAI,MAAM,EAAE,GAAG,KAAK,oBAAoB,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QACxD,MAAM,IAAI,GAAG,CAAC,iBAAiB,CAAC,mCAAmC,oBAAoB,kBAAkB,CAAC,CAAC;IAC7G,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,iBAAiB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACzD,OAAO,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,UAAU,EAAE,CAAC,oBAAoB,CAAC,EAAE,GAAG,qBAAqB,EAAE,EAAE,CAAM,CAAC;AACzG,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,KAAa;IACnD,MAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IACtC,IAAI,CAAC,MAAM,EAAE,GAAG;QAAE,MAAM,IAAI,GAAG,CAAC,iBAAiB,CAAC,wBAAwB,CAAC,CAAC;IAE5E,IAAI,MAAM,CAAC,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,gBAAgB,CAAa,KAAK,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,qBAAqB,EAAE,EAAE,CAAC,CAAC;QACpG,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACvC,WAAW,CAAC,8CAA8C,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;YACjF,MAAM,IAAI,GAAG,CAAC,iBAAiB,CAAC,yDAAyD,CAAC,CAAC;QAC7F,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,KAAK,CAAC,CAAC;IAC1C,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;QACvC,MAAM,IAAI,GAAG,CAAC,iBAAiB,CAAC,gEAAgE,CAAC,CAAC;IACpG,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAqDD,MAAM,UAAU,WAAW,CACzB,YAA2C,EAC3C,GAAc,EACd,IAAmB;IAEnB,IAAI,YAAY,IAAI,GAAG,IAAI,IAAI,IAAI,SAAS,IAAI,YAAY,EAAE,CAAC;QAC7D,OAAO,YAAY,CAAC,EAAE,EAAE,YAAuB,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED,MAAM,OAAO,GAAI,YAAmC,IAAI,EAAE,CAAC;IAC3D,MAAM,IAAI,GAAG,YAAY,CAAC,CAAC,GAAY,EAAE,QAAkB,EAAE,SAAuB,EAAE,EAAE;QACtF,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAClD,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IACrB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;QACzB,YAAY,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACrJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AACD,YAAY,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;AAmC5C,IAAI,oBAAsD,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAuC;IAC7E,oBAAoB,GAAG,KAAK,CAAC;IAC7B,IAAI,KAAK;QAAE,4BAA4B,GAAG,KAAK,CAAC,CAAC,sCAAsC;AACzF,CAAC;AAED,kFAAkF;AAClF,IAAI,4BAA4B,GAAG,KAAK,CAAC;AAEzC;;;;;GAKG;AACH,KAAK,UAAU,cAAc,CAAC,OAAmB;IAC/C,MAAM,KAAK,GAAG,oBAAoB,CAAC;IACnC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,8EAA8E;QAC9E,8EAA8E;QAC9E,8EAA8E;QAC9E,+DAA+D;QAC/D,IAAI,CAAC,4BAA4B,IAAI,OAAO,CAAC,GAAG,IAAI,OAAO,OAAO,CAAC,YAAY,KAAK,QAAQ,EAAE,CAAC;YAC7F,4BAA4B,GAAG,IAAI,CAAC;YACpC,MAAM,CAAC,IAAI,CAAC,8KAA8K,CAAC,CAAC;QAC9L,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,OAAO,OAAO,CAAC,YAAY,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC3E,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC3D,OAAO,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,YAAY,GAAG,OAAO,CAAC;IAC5D,CAAC;IAAC,MAAM,CAAC;QACP,qEAAqE;QACrE,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,sBAAsB,CAAC,GAAW;IAC/C,MAAM,KAAK,GAAG,oBAAoB,CAAC;IACnC,IAAI,CAAC,KAAK,EAAE,oBAAoB;QAAE,OAAO,aAAa,CAAC;IACvD,IAAI,CAAC;QACH,OAAO,MAAM,KAAK,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,aAAa,CAAC;IACvB,CAAC;AACH,CAAC;AAED,4FAA4F;AAC5F,SAAS,sBAAsB,CAAC,OAAoD;IAClF,OAAO,OAAO,OAAO,CAAC,cAAc,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;AACjH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,MAAsF;IAEtF,8EAA8E;IAC9E,4EAA4E;IAC5E,mBAAmB;IACnB,IAAI,sBAAsB,CAAC,MAAM,CAAC,IAAI,MAAM,sBAAsB,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,MAAM;QAAE,OAAO,IAAI,CAAC;IACvG,OAAO,cAAc,CAAC,MAAoB,CAAC,CAAC;AAC9C,CAAC;AAED,SAAS,YAAY,CACnB,OAA2B,EAC3B,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,MAAM,UAAU,GAAG,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC;IAE7C,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,+BAA+B,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;IAC3G,CAAC;IAED,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE,CAAC;QAChD,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,mDAAmD,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;IAC/H,CAAC;IAED,yEAAyE;IACzE,uEAAuE;IACvE,4EAA4E;IAC5E,+DAA+D;IAC/D,kCAAkC;IAClC,IAAI,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7B,KAAK,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;QACtD,OAAO;IACT,CAAC;IAED,0EAA0E;IAC1E,0EAA0E;IAC1E,gCAAgC;IAChC,KAAK,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACtE,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,aAAa,CAC1B,OAA2B,EAC3B,GAAW,EACX,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,4EAA4E;IAC5E,0EAA0E;IAC1E,8EAA8E;IAC9E,qEAAqE;IACrE,MAAM,EAAE,cAAc,EAAE,8BAA8B,EAAE,GAAG,MAAM,MAAM,CAAC,iCAAiC,CAAC,CAAC;IAC3G,IAAI,KAAa,CAAC;IAClB,IAAI,CAAC;QACH,KAAK,GAAG,MAAM,cAAc,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,8BAA8B,EAAE,CAAC;YACpD,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,mBAAmB,EACnC,kEAAkE,EAClE,SAAS,CAAC,mBAAmB,CAC9B,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,+BAA+B,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;IAC3G,CAAC;IACD,MAAM,eAAe,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AACxD,CAAC;AAED,KAAK,UAAU,eAAe,CAC5B,OAA2B,EAC3B,QAAgB,EAChB,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,IAAI,CAAC;QACH,2EAA2E;QAC3E,0EAA0E;QAC1E,4EAA4E;QAC5E,oEAAoE;QACpE,mEAAmE;QACnE,MAAM,OAAO,GAAG,MAAM,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAElD,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,iDAAiD,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QAC7H,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,EAAE,CAAC;YACtE,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,+BAA+B,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QAC3G,CAAC;QAED,0EAA0E;QAC1E,yEAAyE;QACzE,4EAA4E;QAC5E,wEAAwE;QACxE,8EAA8E;QAC9E,2EAA2E;QAC3E,IAAI,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC;YAClC,WAAW,CAAC,4BAA4B,EAAE,EAAE,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,IAAI,SAAS,EAAE,CAAC,CAAC;YAC5F,MAAM,CAAC,IAAI,CAAC,mCAAmC,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;YACvE,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,uBAAuB,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QACnG,CAAC;QAED,GAAG,CAAC,IAAI,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;QAE1B,6EAA6E;QAC7E,2EAA2E;QAC3E,2EAA2E;QAC3E,6EAA6E;QAC7E,4EAA4E;QAC5E,qEAAqE;QACrE,6BAA6B;QAC7B,IAAI,OAAO,CAAC,oBAAoB,KAAK,IAAI,EAAE,CAAC;YAC1C,WAAW,CAAC,+BAA+B,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAAC;YAC1G,iBAAiB,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;YACxC,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,uFAAuF,EACvF,SAAS,CAAC,uBAAuB,CAClC,CAAC;QACJ,CAAC;QAED,qEAAqE;QACrE,IAAI,OAAO,CAAC,YAAY;eACnB,kBAAkB,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC;YAAE,OAAO;QAEhK,wEAAwE;QACxE,8EAA8E;QAC9E,8EAA8E;QAC9E,8EAA8E;QAC9E,4EAA4E;QAC5E,IAAI,OAAO,CAAC,sBAAsB,IAAI,OAAO,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;YACpE,MAAM,WAAW,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;YAC7D,MAAM,aAAa,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;YACjE,IAAI,WAAW;gBAAE,GAAG,CAAC,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC;YACvD,IAAI,aAAa;gBAAE,GAAG,CAAC,IAAI,CAAC,gBAAgB,GAAG,aAAa,CAAC;QAC/D,CAAC;QAED,qEAAqE;QACrE,EAAE;QACF,2EAA2E;QAC3E,4EAA4E;QAC5E,wEAAwE;QACxE,2EAA2E;QAC3E,+EAA+E;QAC/E,6EAA6E;QAC7E,4EAA4E;QAC5E,8EAA8E;QAC9E,8EAA8E;QAC9E,2EAA2E;QAC3E,0EAA0E;QAC1E,oEAAoE;QACpE,MAAM,MAAM,GAAI,GAA6D,CAAC,OAAO,CAAC;QACtF,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,QAAQ,GAAG,WAAW,CAAC,GAA6B,CAAC,CAAC;QAC/D,CAAC;QAED,wEAAwE;QACxE,yEAAyE;QACzE,4EAA4E;QAC5E,2EAA2E;QAC3E,4EAA4E;QAC5E,yEAAyE;QACzE,0EAA0E;QAC1E,6DAA6D;QAC7D,MAAM,aAAa,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;QACtD,IAAI,aAAa,IAAI,CAAC,oBAAoB,IAAI,OAAO,CAAC,GAAG,IAAI,OAAO,OAAO,CAAC,YAAY,KAAK,QAAQ,CAAC,EAAE,CAAC;YACvG,0EAA0E;YAC1E,0EAA0E;YAC1E,sEAAsE;YACtE,sEAAsE;YACtE,2EAA2E;YAC3E,CAAC,KAAK,IAAI,EAAE;gBACV,IAAI,aAAa,EAAE,CAAC;oBAClB,MAAM,KAAK,GAAG,MAAM,sBAAsB,CAAC,OAAO,CAAC,GAAa,CAAC,CAAC;oBAClE,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;wBACrB,OAAO,SAAS,CACd,GAAG,EACH,UAAU,CAAC,YAAY,EACvB,KAAK,KAAK,SAAS;4BACjB,CAAC,CAAC,2CAA2C;4BAC7C,CAAC,CAAC,kDAAkD,EACtD,SAAS,CAAC,aAAa,CACxB,CAAC;oBACJ,CAAC;gBACH,CAAC;gBACD,IAAI,oBAAoB,IAAI,OAAO,CAAC,GAAG,IAAI,OAAO,OAAO,CAAC,YAAY,KAAK,QAAQ,IAAI,MAAM,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC;oBACrH,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,gDAAgD,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;gBAC5H,CAAC;gBACD,IAAI,EAAE,CAAC;YACT,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACjB,OAAO;QACT,CAAC;QAED,IAAI,EAAE,CAAC;IACT,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,GAAG,CAAC,iBAAiB,EAAE,CAAC;YAC3C,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,mBAAmB,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QAC/F,CAAC;QAED,4EAA4E;QAC5E,wEAAwE;QACxE,yEAAyE;QACzE,4EAA4E;QAC5E,0EAA0E;QAC1E,oEAAoE;QACpE,IAAI,KAAK,YAAY,oBAAoB,IAAI,KAAK,YAAY,eAAe,EAAE,CAAC;YAC9E,MAAM,CAAC,IAAI,CAAC,mDAAmD,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC3F,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,mBAAmB,EACnC,6DAA6D,EAC7D,SAAS,CAAC,mBAAmB,CAC9B,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,YAAY,eAAe,IAAI,KAAK,YAAY,GAAG,CAAC,iBAAiB,EAAE,CAAC;YAC/E,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,eAAe,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QAC3F,CAAC;QAED,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,uBAAuB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;IAClG,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAmE;IAClG,OAAO,MAAM,EAAE,aAAa,KAAK,MAAM,IAAI,MAAM,CAAC,SAAS,KAAK,QAAQ,CAAC;AAC3E,CAAC;AAQD;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAyB;IACxD,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QACD,IAAI,kBAAkB,CAAC,OAAO,EAAE,GAAG,CAAC,IAAkB,EAAE,GAAG,EAAE,GAAG,CAAC;YAAE,OAAO;QAC1E,IAAI,EAAE,CAAC;IACT,CAAC,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AACrI,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY,EAAE,GAAa,EAAE,OAAyB;IACtF,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACd,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QAC3F,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,kBAAkB,CAAC,OAAO,EAAE,GAAG,CAAC,IAAkB,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AACvE,CAAC;AAUD;8EAC8E;AAC9E,MAAM,CAAC,MAAM,oBAAoB,GAAG,kBAAkB,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACtC,MAA8B,EAC9B,OAAiC;IAEjC,+EAA+E;IAC/E,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,aAAa,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC5D,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAC;QAC9B,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;YAAE,OAAO,SAAS,CAAC;QACnD,OAAO;YACL,MAAM,EAAE,UAAU,CAAC,SAAS;YAC5B,IAAI,EAAE,SAAS,CAAC,sBAAsB;YACtC,MAAM,EAAE,mBAAmB;YAC3B,OAAO,EAAE,wHAAwH;SAClI,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IAC7C,OAAO;QACL,MAAM,EAAE,UAAU,CAAC,YAAY;QAC/B,IAAI,EAAE,SAAS,CAAC,YAAY;QAC5B,MAAM,EAAE,cAAc;QACtB,OAAO,EAAE,yIAAyI;KACnJ,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAY,EAAE,GAAa,EAAE,OAAiC;IACvG,MAAM,OAAO,GAAG,wBAAwB,CAAC,GAAG,CAAC,IAA8B,EAAE,OAAO,CAAC,CAAC;IACtF,IAAI,CAAC,OAAO;QAAE,OAAO,KAAK,CAAC;IAC3B,WAAW,CAAC,+BAA+B,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,aAAa,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACpH,iBAAiB,CAAC,GAAG,EAAE,qBAAqB,CAAC,CAAC;IAC9C,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAChG,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAiC;IACxE,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QACD,IAAI,0BAA0B,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC;YAAE,OAAO;QAC1D,IAAI,EAAE,CAAC;IACT,CAAC,EAAE,EAAE,IAAI,EAAE,mBAAmB,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,kBAAkB,CACzB,OAAyB,EACzB,OAAmB,EACnB,GAAY,EACZ,GAAa;IAEb,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAC1C,MAAM,MAAM,GAAG,CAAC,MAAc,EAAE,MAAc,EAAE,OAAe,EAAE,IAAe,EAAQ,EAAE;QACxF,WAAW,CAAC,+BAA+B,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QACrF,iBAAiB,CAAC,GAAG,EAAE,aAAa,YAAY,EAAE,CAAC,CAAC;QACpD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;QAC/B,OAAO,MAAM,CACX,mBAAmB,EAAE,UAAU,CAAC,SAAS,EACzC,0HAA0H,EAC1H,SAAS,CAAC,sBAAsB,CACjC,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,YAAY,EAAE,CAAC;QACtC,OAAO,MAAM,CACX,cAAc,EAAE,UAAU,CAAC,YAAY,EACvC,wGAAwG,EACxG,SAAS,CAAC,YAAY,CACvB,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QACjC,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;QACnC,8EAA8E;QAC9E,2EAA2E;QAC3E,yCAAyC;QACzC,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;YAC9F,OAAO,MAAM,CACX,eAAe,EAAE,UAAU,CAAC,YAAY,EACxC,mEAAmE,EACnE,SAAS,CAAC,eAAe,CAC1B,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAA4B;IACjE,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,aAAa,CAAC;QAAE,OAAO,KAAK,CAAC;IAC7F,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC;QAAE,OAAO,KAAK,CAAC;IAChF,IAAI,OAAO,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;QACxC,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ;eAChC,OAAO,OAAO,CAAC,GAAG,KAAK,QAAQ;eAC/B,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,sBAAsB,CAAC;eAC9C,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,sBAAsB,CAAC,MAAM,CAAC;IAC1D,CAAC;IACD,OAAO,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC;WAC5B,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;WAClD,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC,IAAI,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC;WACxC,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ,CAAC;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY,EAAE,UAAsB;IACpE,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;AAClF,CAAC;AAoBD;;;;;;;GAOG;AACH,IAAI,kBAAiE,CAAC;AAEtE;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,EAAiD;IACrF,kBAAkB,GAAG,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY,EAAE,QAAgB;IAC9D,MAAM,OAAO,GAAG,kBAAkB,CAAC;IACnC,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;IACxC,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO;IAC1E,IAAI,CAAC;QACH,OAAO,CAAC;YACN,OAAO,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG;YACtB,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,KAAK;YAC3B,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,cAAc;YAC/B,MAAM;YACN,0EAA0E;YAC1E,uEAAuE;YACvE,IAAI,EAAE,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAChD,QAAQ;SACT,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACP,iEAAiE;IACnE,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAG,WAAyB;IAC5D,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QACD,qEAAqE;QACrE,yEAAyE;QACzE,yDAAyD;QACzD,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QACtE,iBAAiB,CAAC,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QACjD,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,gCAAgC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAC1D,SAAS,CAAC,wBAAwB,CACnC,CAAC;IACJ,CAAC,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAG,WAAyB;IAChE,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QACD,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACtE,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QACxC,iBAAiB,CAAC,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAClD,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,gCAAgC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,EACvD,SAAS,CAAC,wBAAwB,CACnC,CAAC;IACJ,CAAC,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAG,WAAyB;IACrE,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QACD,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QACjG,iBAAiB,CAAC,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QACjD,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,gCAAgC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAC1D,SAAS,CAAC,wBAAwB,CACnC,CAAC;IACJ,CAAC,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB;IACrF,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,0EAA0E;QAC1E,iFAAiF;QACjF,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,SAAS,EAAE,6BAA6B,EAAE,SAAS,CAAC,wBAAwB,CAAC,CAAC;IACjH,CAAC;IACD,IAAI,EAAE,CAAC;AACT,CAAC;AACD,YAAY,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAuC;IAC5E,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACzC,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,MAAM,MAAM,GAAG,CAAC,MAAyD,EAAQ,EAAE;YACjF,WAAW,CAAC,8BAA8B,EAAE;gBAC1C,OAAO,EAAE,eAAe,EAAE;gBAC1B,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;gBACxI,MAAM;gBACN,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM;aAC1C,CAAC,CAAC;YACH,iBAAiB,CAAC,GAAG,EAAE,qBAAqB,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3E,IAAI,MAAM,KAAK,iBAAiB,EAAE,CAAC;gBACjC,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;YACpG,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACxI,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,SAAS,EAAE,6BAA6B,EAAE,SAAS,CAAC,wBAAwB,CAAC,CAAC;QACjH,CAAC,CAAC;QAEF,IAAI,CAAC,GAAG,CAAC,IAAI;YAAE,OAAO,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAChD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC;YAAE,OAAO,MAAM,CAAC,YAAY,CAAC,CAAC;QAC1D,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,OAAO,MAAM,CAAC,cAAc,CAAC,CAAC;QACnE,IAAI,EAAE,CAAC;IACT,CAAC,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;AAC/F,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,0BAA0B,CAAC,CAAC,WAAW,EAAE,CAAC;AAErG,wGAAwG;AACxG,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc,EAAE,OAAgB;IAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,aAAa,IAAI,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,CAAC;AAC9F,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,GAAY;IACxC,OAAO,GAAG,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAY,EAAE,KAAa;IAClD,OAAO,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,KAAK,CAAC;AACnC,CAAC;AAED;oEACoE;AACpE,MAAM,UAAU,kBAAkB,CAChC,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,iBAAiB,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;QACvC,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,oEAAoE,EACpE,SAAS,CAAC,wBAAwB,CACnC,CAAC;IACJ,CAAC;IACD,IAAI,EAAE,CAAC;AACT,CAAC;AACD,YAAY,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;AAE1D;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,OAAe;IAC5C,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QAED,qEAAqE;QACrE,uEAAuE;QACvE,qEAAqE;QACrE,kBAAkB;QAClB,IAAI,GAAG,CAAC,IAAI,CAAC,YAAY,KAAK,IAAI;YAAE,OAAO,IAAI,EAAE,CAAC;QAElD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,4DAA4D;YAC5D,2DAA2D;YAC3D,sEAAsE;YACtE,iBAAiB,CAAC,GAAG,EAAE,WAAW,OAAO,EAAE,CAAC,CAAC;YAC7C,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,wCAAwC,OAAO,GAAG,EAClD,SAAS,CAAC,wBAAwB,CACnC,CAAC;QACJ,CAAC;QAED,IAAI,EAAE,CAAC;IACT,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;AACnC,CAAC;AAED,8EAA8E;AAC9E,4BAA4B;AAC5B,EAAE;AACF,4EAA4E;AAC5E,sEAAsE;AACtE,8EAA8E;AAC9E,gFAAgF;AAChF,8EAA8E;AAC9E,6EAA6E;AAC7E,uDAAuD;AACvD,6EAA6E;AAC7E,oEAAoE;AACpE,mEAAmE;AACnE,EAAE;AACF,yEAAyE;AACzE,iDAAiD;AACjD,8EAA8E;AAE9E,MAAM,iCAAiC,GAAG,GAAG,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAClC,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,IAAI,EAAE,CAAC;KACvC,KAAK,CAAC,GAAG,CAAC;KACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;KACpB,MAAM,CAAC,OAAO,CAAC,CACnB,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,MAA4D;IACxF,IAAI,MAAM,EAAE,aAAa,KAAK,SAAS,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAC5F,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,sBAAsB,CAAC;QAAE,OAAO,SAAS,CAAC;IACrE,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,sBAAsB,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC;AACtE,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,oBAAoB,CAAC,MAAgD;IACnF,IAAI,oBAAoB,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAClD,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,OAAO,IAAI,KAAK,SAAS,IAAI,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC9D,CAAC;AA6BD;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAyB;IACxD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACvB,MAAM,OAAO,GAA4B;QACvC,QAAQ,EAAE,GAAG,IAAI,CAAC,WAAW,UAAU;QACvC,KAAK,EAAE,GAAG,IAAI,CAAC,WAAW,WAAW;QACrC,aAAa,EAAE,SAAS;QACxB,SAAS,EAAE,QAAQ;QACnB,IAAI;QACJ,OAAO,EAAE,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,OAAO;QAC7C,IAAI,EAAE,QAAQ;QACd,cAAc,EAAE,IAAI,CAAC,KAAK;QAC1B,gBAAgB,EAAE,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK;QAC5C,4EAA4E;QAC5E,6EAA6E;QAC7E,4EAA4E;QAC5E,2EAA2E;QAC3E,kDAAkD;QAClD,GAAG,EAAE,UAAU,EAAE;QACjB,yEAAyE;QACzE,+DAA+D;QAC/D,GAAG,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC9F,CAAC;IACF,uEAAuE;IACvE,yEAAyE;IACzE,qCAAqC;IACrC,OAAO,cAAc,CAAC,OAAkC,EAAE;QACxD,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,gBAAgB,EAAE,IAAI,CAAC,UAAU,IAAI,iCAAiC;QACtE,GAAG,qBAAqB,EAAE;KAC3B,CAAC,CAAC;AACL,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,oBAAoB,CAAC,IAAyB;IAC5D,OAAO,UAAU,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;AAC5C,CAAC;AAED,8GAA8G;AAC9G,MAAM,UAAU,kBAAkB,CAAC,GAAY;IAC7C,OAAO,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,SAAS,CAAC;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CAAC,GAAY;IACpD,OAAO,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,iBAAiB,CAAC;AACvD,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,uBAAuB,CAAC,GAAY,EAAE,WAAmB;IACvE,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,WAAW,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,sBAAsB,CAAC,GAAY;IACjD,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACpD,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACxE,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACzC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;QAC5D,MAAM,OAAO,GAAG,gBAAgB,CAAa,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,qBAAqB,EAAE,EAAE,CAAC,CAAC;QACxG,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,CAAC,aAAa,KAAK,SAAS,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC;YAAE,OAAO,KAAK,CAAC;QACvH,6EAA6E;QAC7E,gFAAgF;QAChF,uEAAuE;QACvE,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { tagRouteGate, type OrgAdminAssuranceMachines } from './route-table.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { JwksUnavailableError, UnknownKidError, platformJwksCache } from '../services/jwks-cache.js';\nimport {\n  SERVICE_SUBJECT_PREFIX,\n  ServiceKeyError,\n  isServiceKid,\n  serviceIdentity,\n  signServiceJwt,\n  verifyServiceJwt,\n} from '../services/service-keys.js';\nimport { AUTH_METHODS, PRINCIPAL_TYPES, TOKEN_USES, type AssuranceLevel, type JwtPayload } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { HttpRequest } from '../types/http.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { isOpaqueApiKey } from '../utils/api-key.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.js';\nimport { USER_TOKEN_ALGORITHM, decodeJwtHeader } from '../utils/jwk.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n\n/** Issuer/audience pinning, when the deployment configures them. Shared by both chains. */\nfunction issuerAudienceOptions(): { issuer?: string; audience?: string } {\n  return {\n    ...(process.env.JWT_ISSUER ? { issuer: process.env.JWT_ISSUER } : {}),\n    ...(process.env.JWT_AUDIENCE ? { audience: process.env.JWT_AUDIENCE } : {}),\n  };\n}\n\n/**\n * Verify a token that speaks for a PERSON — access, step-up, and the token an\n * opaque access key is exchanged for — against platform's published signing\n * keys.\n *\n * ES256 and a `kid` are both mandatory: no `kid` means no way to pick the right\n * key across a rotation, and any other algorithm is refused outright, which is\n * what makes \"no service accepts an HS256 user token\" a property of the code\n * rather than a convention. Key lookup goes through the shared JWKS cache\n * (10-minute refresh, one refetch on an unknown `kid`, brief negative cache).\n *\n * @throws {UnknownKidError} the key set is current and has no such key → 401.\n * @throws {JwksUnavailableError} the key set could not be obtained → 503; an\n *         unverifiable token is never treated as valid.\n */\nexport async function verifyUserJwt<T = JwtPayload>(token: string): Promise<T> {\n  const header = decodeJwtHeader(token);\n  if (header?.alg !== USER_TOKEN_ALGORITHM || !header.kid) {\n    throw new jwt.JsonWebTokenError(`User tokens must be signed with ${USER_TOKEN_ALGORITHM} and carry a kid`);\n  }\n  const key = await platformJwksCache().getKey(header.kid);\n  return jwt.verify(token, key, { algorithms: [USER_TOKEN_ALGORITHM], ...issuerAudienceOptions() }) as T;\n}\n\n/**\n * Verify ANY bearer token and return its claims.\n *\n * Since #14 there is no shared secret left: BOTH chains are ES256 with a `kid`,\n * so the dispatch is by **who owns the `kid`** rather than by algorithm — and\n * because a `kid` is an RFC 7638 thumbprint, ownership is a fact about the key,\n * not a claim the token makes about itself:\n *\n * - a `kid` published in the per-service key bundle → an INTERNAL SERVICE token\n *   ({@link signServiceToken}), verified with that service's key; its `sub` must\n *   name the same service, so one service can never speak for another.\n * - anything else → a platform-signed USER token, verified against platform's\n *   published JWKS. A token claiming `principalType: 'service'` is refused\n *   here: an internal identity may not ride the user signing key.\n *\n * Anything that is not ES256 with a `kid` fails in both chains, which is what\n * makes \"no HS256 token is accepted anywhere\" a property of the code.\n */\nexport async function verifyBearerToken(token: string): Promise<JwtPayload> {\n  const header = decodeJwtHeader(token);\n  if (!header?.alg) throw new jwt.JsonWebTokenError('Malformed token header');\n\n  if (header.kid && isServiceKid(header.kid)) {\n    const claims = verifyServiceJwt<JwtPayload>(token, { kid: header.kid, ...issuerAudienceOptions() });\n    if (claims.principalType !== 'service') {\n      emitCounter('service_key_non_service_token_rejected_total', { alg: header.alg });\n      throw new jwt.JsonWebTokenError('A service signing key may only mint a service principal');\n    }\n    return claims;\n  }\n\n  const claims = await verifyUserJwt(token);\n  if (claims.principalType === 'service') {\n    throw new jwt.JsonWebTokenError('Service principals may not be signed with the user signing key');\n  }\n  return claims;\n}\n\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n  /**\n   * Demand that the whole SESSION be at least this assurance level (#8).\n   *\n   * `minAssurance: 2` means the person authenticated with a second factor — a\n   * passkey with user verification, a password plus an authenticator code, or\n   * SSO through an IdP the org marked as enforcing MFA. A weaker token gets\n   * **401 `MFA_REQUIRED`**, which the client answers by sending the person to\n   * enrolment or to a stronger sign-in; refreshing cannot help, because `aal`\n   * lives on the session slot and a refresh never raises it.\n   *\n   * This is the SESSION-level counterpart to {@link requireStepUp}, which stays\n   * a fresh, per-action confirmation. Use both on the most dangerous routes.\n   *\n   * MACHINES NEVER SATISFY IT. A service principal, an org service account and\n   * an exchanged access key all get **403 `HUMAN_SESSION_REQUIRED`** — there is\n   * no person behind them to have presented a factor, so \"assurance\" is not a\n   * question their credential can answer. That is deliberately not a silent\n   * pass-through for internal services: a route that demands MFA is a route a\n   * human is doing something dangerous on.\n   */\n  minAssurance?: AssuranceLevel;\n  /**\n   * With {@link minAssurance}, additionally bound how long ago that sign-in\n   * happened (seconds, compared against the token's `auth_time`). A session that\n   * is MFA-grade but older than this gets **401 `REAUTH_REQUIRED`**. Ignored\n   * without `minAssurance` — \"how recent\" is only meaningful once \"how strong\"\n   * is being asked.\n   */\n  maxAge?: number;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  const gate = tagRouteGate((req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  }, { kind: 'auth' });\n  if (options.minAssurance) {\n    tagRouteGate(gate, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n  }\n  return gate;\n}\ntagRouteGate(requireAuth, { kind: 'auth' });\n\n/**\n * A source of the CURRENT `tokenVersion` for a user, backed by a store the\n * stateless services can read (in practice a Redis key the platform publishes\n * to on every privilege change). Registered via {@link setTokenRevocationStore}.\n *\n * `getCurrentVersion` returns the user's current version, or `null` when the\n * store has no entry — a miss is treated as \"no known revocation\" (fail-open):\n * revocation entries are published with a TTL matching the access-token\n * lifetime, so a missing entry means any token old enough to predate it has\n * already expired on its own.\n */\nexport interface TokenRevocationStore {\n  getCurrentVersion(userId: string): Promise<number | null>;\n  /**\n   * Whether one IMPERSONATION session (by token `jti`) has been ended early.\n   *\n   * Optional so a store that predates it still links — but a store WITHOUT it\n   * cannot answer, and an impersonation token is then REJECTED. Unlike\n   * `getCurrentVersion`, this is deliberately not fail-open: the platform ends a\n   * session when someone withdraws consent, and a withdrawn consent that keeps\n   * working in every other service is not withdrawn.\n   */\n  getSessionRevocation?(jti: string): Promise<SessionRevocationState>;\n}\n\n/**\n * `revoked`     — the session was ended; reject.\n * `live`        — no revocation recorded; allow.\n * `unavailable` — the store couldn't be read or can't answer; REJECT. Distinct\n *                 from `live` precisely so an outage can't read as \"not revoked\".\n */\nexport type SessionRevocationState = 'revoked' | 'live' | 'unavailable';\n\nlet tokenRevocationStore: TokenRevocationStore | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide token-revocation store.\n * When unset (the default), `requireAuth` performs NO revocation check (it relies\n * on the short access-token TTL); services opt in at boot by wiring their Redis\n * client. Platform keeps its own Mongo-backed check and need not register one.\n */\nexport function setTokenRevocationStore(store: TokenRevocationStore | undefined): void {\n  tokenRevocationStore = store;\n  if (store) revocationStoreMissingWarned = false; // re-arm if a store is (re)registered\n}\n\n/** One-shot guard so the \"revocation inactive\" warning doesn't flood the logs. */\nlet revocationStoreMissingWarned = false;\n\n/**\n * Returns true when `decoded` has been revoked per the registered store: its\n * embedded `tokenVersion` is strictly behind the store's current version.\n * Fail-open — any store error, a missing entry, or a token/store without a\n * usable version yields `false` (allow). Never throws.\n */\nasync function isTokenRevoked(decoded: JwtPayload): Promise<boolean> {\n  const store = tokenRevocationStore;\n  if (!store) {\n    // Make the \"revocation is OFF\" state OBSERVABLE: a service that verifies user\n    // tokens but forgot `setTokenRevocationStore()` silently disables the session\n    // kill-switch. Warn ONCE (only for a revocable user token) so a misconfigured\n    // boot surfaces in the logs instead of failing open invisibly.\n    if (!revocationStoreMissingWarned && decoded.sub && typeof decoded.tokenVersion === 'number') {\n      revocationStoreMissingWarned = true;\n      logger.warn('Token revocation store NOT registered — revocation checks are INACTIVE (setTokenRevocationStore was never called); revoked/compromised sessions stay valid until natural TTL');\n    }\n    return false;\n  }\n  if (!decoded.sub || typeof decoded.tokenVersion !== 'number') return false;\n  try {\n    const current = await store.getCurrentVersion(decoded.sub);\n    return current !== null && decoded.tokenVersion < current;\n  } catch {\n    // Fail-open: a revocation-store outage must not lock every user out.\n    return false;\n  }\n}\n\n/**\n * Resolve an impersonation session's revocation state. Never throws: any failure\n * — no store, a store that can't answer, a read error — is `unavailable`, which\n * callers treat as revoked.\n */\nasync function sessionRevocationState(jti: string): Promise<SessionRevocationState> {\n  const store = tokenRevocationStore;\n  if (!store?.getSessionRevocation) return 'unavailable';\n  try {\n    return await store.getSessionRevocation(jti);\n  } catch {\n    return 'unavailable';\n  }\n}\n\n/** An impersonation session token: it names the operator AND carries its own session id. */\nfunction isImpersonationSession(decoded: { impersonatorId?: unknown; jti?: unknown }): decoded is { impersonatorId: string; jti: string } {\n  return typeof decoded.impersonatorId === 'string' && typeof decoded.jti === 'string' && decoded.jti.length > 0;\n}\n\n/**\n * Public revocation check for routes that verify a platform JWT OUTSIDE\n * `requireAuth` (e.g. the image-registry `/token` mint path, which resolves\n * identity itself). Returns true when the token's `tokenVersion` is strictly\n * behind the store's current version. Fail-open (never throws) — a store outage\n * or a token/store without a usable version yields false (allow), matching\n * `requireAuth`. Pass the verified JWT claims (`sub`, `tokenVersion`).\n */\nexport async function isAccessTokenRevoked(\n  claims: { sub?: string; tokenVersion?: number; jti?: string; impersonatorId?: string },\n): Promise<boolean> {\n  // An impersonation session is revoked unless the store positively says live —\n  // including on this out-of-band path, or a revoked session could still mint\n  // registry tokens.\n  if (isImpersonationSession(claims) && await sessionRevocationState(claims.jti) !== 'live') return true;\n  return isTokenRevoked(claims as JwtPayload);\n}\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  // An OPAQUE ACCESS KEY (`pb_pat_…` / `pb_sa_…`) carries no claims and no\n  // signature, so it cannot be verified here. Trade it at platform for a\n  // short-lived JWT (cached in-process until it expires) and then verify that\n  // JWT on the normal path — services never read a key hash. See\n  // `services/api-key-exchange.ts`.\n  if (isOpaqueApiKey(parts[1])) {\n    void resolveApiKey(options, parts[1], req, res, next);\n    return;\n  }\n\n  // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n  // Express's error middleware — verification itself never rejects (it maps\n  // every failure to a response).\n  void verifyAndAttach(options, parts[1], req, res, next).catch(next);\n}\n\n/**\n * Exchange an opaque key for a JWT, then continue on the normal verification\n * path. A refused key is a 401; an unreachable platform is a 503 (never a pass —\n * an unverifiable credential is not an identity).\n */\nasync function resolveApiKey(\n  options: RequireAuthOptions,\n  key: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  // Loaded LAZILY, on the first key ever presented. A static import would put\n  // the HTTP client (and platform's address) into the import graph of every\n  // module that merely uses `requireAuth`, which both widens the boot graph and\n  // breaks any test that mocks `http-client.js` with a partial module.\n  const { exchangeApiKey, ApiKeyExchangeUnavailableError } = await import('../services/api-key-exchange.js');\n  let token: string;\n  try {\n    token = await exchangeApiKey(key);\n  } catch (error) {\n    if (error instanceof ApiKeyExchangeUnavailableError) {\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Access-key verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid or revoked access key', ErrorCode.TOKEN_INVALID);\n  }\n  await verifyAndAttach(options, token, req, res, next);\n}\n\nasync function verifyAndAttach(\n  options: RequireAuthOptions,\n  rawToken: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  try {\n    // Two chains, one entry point (see `verifyBearerToken`): a user token must\n    // be ES256 signed by platform and verified against its published JWKS; an\n    // internal service token stays on the shared secret and must declare itself\n    // a service principal. Both pin the algorithm (no alg-confusion, no\n    // `alg:none`) and both apply the optional issuer/audience binding.\n    const decoded = await verifyBearerToken(rawToken);\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role || !hasValidIdentityClaims(decoded)) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    // Service-token kill-switch: reject a service principal whose service has\n    // been added to the denylist. Rotating the shared JWT secret is the only\n    // other way to invalidate a service token before its (short) TTL — but that\n    // nukes EVERY service token fleet-wide. This lets one compromised/rogue\n    // service be cut off surgically. O(1) Set lookup, zero cost when the denylist\n    // is empty (the default), so it never taxes the S2S hot path unless armed.\n    if (isServiceTokenDenied(decoded)) {\n      emitCounter('service_token_denied_total', { service: serviceNameOf(decoded) ?? 'unknown' });\n      logger.warn('Rejected denylisted service token', { sub: decoded.sub });\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Service token revoked', ErrorCode.TOKEN_REVOKED);\n    }\n\n    req.user = { ...decoded };\n\n    // BOOTSTRAP-ADMIN ENROLMENT SESSION (#8, revision 4). Such a token exists so\n    // the install's only admin can enrol a factor; it is `aal: 1` and must not\n    // reach anything else. Platform — which owns the exception and knows which\n    // of its own routes `init-platform.sh` calls — allows an explicit few before\n    // this point (see its own `requireAuth`); in EVERY other service the answer\n    // is simply no, so the reach restriction holds without a per-service\n    // allowlist to keep in sync.\n    if (decoded.mfaEnrollmentPending === true) {\n      emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: 'bootstrap_session' });\n      recordAuthzDenial(req, 'mfa-enrolment');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Finish setting up two-factor authentication before using the rest of Pipeline Builder',\n        ErrorCode.MFA_ENROLLMENT_REQUIRED,\n      );\n    }\n\n    // Session-level assurance (`requireAuth({ minAssurance, maxAge })`).\n    if (options.minAssurance\n      && refuseForAssurance({ minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) }, decoded, req, res)) return;\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session-invalidation check for the stateless services: reject a token\n    // whose `tokenVersion` is behind the revocation store's current value (a\n    // privilege change the platform published). No store registered ⇒ this is a\n    // no-op and control passes straight through. Fail-open on any store error.\n    // An impersonation session is checked even when NO store is registered: the\n    // tokenVersion check below is a no-op without a store, but for a session\n    // that would silently mean \"never revoked\". Here no store ⇒ unavailable ⇒\n    // rejected. See `TokenRevocationStore.getSessionRevocation`.\n    const impersonation = isImpersonationSession(decoded);\n    if (impersonation || (tokenRevocationStore && decoded.sub && typeof decoded.tokenVersion === 'number')) {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — without it, that throw would surface as an\n      // unhandled rejection (this `next()` runs in a microtask, outside the\n      // surrounding try/catch and Express's per-layer dispatch). The checks\n      // themselves never reject, so the catch only ever sees a downstream error.\n      (async () => {\n        if (impersonation) {\n          const state = await sessionRevocationState(decoded.jti as string);\n          if (state !== 'live') {\n            return sendError(\n              res,\n              HttpStatus.UNAUTHORIZED,\n              state === 'revoked'\n                ? 'This impersonation session has been ended'\n                : 'This impersonation session could not be verified',\n              ErrorCode.TOKEN_REVOKED,\n            );\n          }\n        }\n        if (tokenRevocationStore && decoded.sub && typeof decoded.tokenVersion === 'number' && await isTokenRevoked(decoded)) {\n          return sendError(res, HttpStatus.UNAUTHORIZED, 'Session has been revoked; please sign in again', ErrorCode.TOKEN_REVOKED);\n        }\n        next();\n      })().catch(next);\n      return;\n    }\n\n    next();\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    // The signing keys couldn't be fetched, so the token's validity is UNKNOWN.\n    // Fail CLOSED with a retryable 503 — never a pass, and never a 401 that\n    // would send a legitimate client off to re-authenticate over our outage.\n    // Same reasoning for the SERVICE chain: no readable key bundle means no way\n    // to tell a peer's token from a forgery, so the request is refused with a\n    // retryable 503 rather than admitted or bounced to re-authenticate.\n    if (error instanceof JwksUnavailableError || error instanceof ServiceKeyError) {\n      logger.warn('Rejecting request: token signing keys unavailable', { error: error.message });\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Token verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n\n    if (error instanceof UnknownKidError || error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n/**\n * Whether a set of verified claims speaks for a PERSON's own session — the only\n * kind of credential an assurance level can be asserted about.\n *\n * Excludes all three machine shapes: an internal service principal, an org\n * service account, and any exchanged access key (`token_use: 'api_key'`, i.e. a\n * PAT or a service-account key), each of which authenticates a program holding a\n * secret rather than a person presenting factors.\n */\nexport function isHumanPrincipal(claims: Pick<JwtPayload, 'principalType' | 'token_use'> | undefined): boolean {\n  return claims?.principalType === 'user' && claims.token_use === 'access';\n}\n\n/** What an assurance gate demands. */\nexport interface AssuranceOptions {\n  minAssurance: AssuranceLevel;\n  maxAge?: number;\n}\n\n/**\n * Standalone assurance gate, for a service whose own `requireAuth` is not\n * api-core's (platform's is its own, because it reads Mongo). Compose it AFTER\n * authentication: `router.get('/x', requireAuth, requireAssurance({ minAssurance: 2 }), h)`.\n *\n * Identical rules and identical refusals to `requireAuth({ minAssurance })` —\n * that option simply calls the same check inline, so there is one implementation\n * of \"is this session MFA-grade\" in the codebase.\n */\nexport function requireAssurance(options: AssuranceOptions) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    if (refuseForAssurance(options, req.user as JwtPayload, req, res)) return;\n    next();\n  }, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n}\n\n/**\n * Handler-level twin of {@link requireAssurance}, for a route where only SOME\n * requests must be MFA-grade — e.g. a policy route on which TIGHTENING a setting\n * stays open to a single-factor session (so an admin without MFA can adopt it)\n * but LOOSENING it does not. Same rules and the same three refusals. Returns\n * true when the request was REFUSED (a response has been sent).\n */\nexport function refuseWeakSession(req: Request, res: Response, options: AssuranceOptions): boolean {\n  if (!req.user) {\n    sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    return true;\n  }\n  return refuseForAssurance(options, req.user as JwtPayload, req, res);\n}\n\n/** What {@link requireOrgAdminAssurance} demands of a route. */\nexport interface OrgAdminAssuranceOptions {\n  /** What a machine credential (PAT, service account, machine session) meets on\n   *  this route while the policy is on — see {@link OrgAdminAssuranceMachines}.\n   *  Required, so every route states its decision rather than inheriting one. */\n  machines: OrgAdminAssuranceMachines;\n}\n\n/** `details.reason` on a refusal by {@link requireOrgAdminAssurance}, so the UI\n *  can say it is the ORG's policy asking, not the route's own requirement. */\nexport const ORG_ADMIN_MFA_REASON = 'org_admin_policy';\n\n/**\n * The refusal {@link requireOrgAdminAssurance} would send for these claims, or\n * `undefined` when the request may proceed. Exported so a handler whose policy\n * applies to only PART of a route (e.g. `generate-token`, where opening a new\n * machine credential is gated but renewing an existing one is not) applies the\n * exact same rule rather than a copy of it.\n */\nexport function orgAdminAssuranceRefusal(\n  claims: JwtPayload | undefined,\n  options: OrgAdminAssuranceOptions,\n): { status: number; code: ErrorCode; message: string; reason: 'machine_principal' | 'weak_session' } | undefined {\n  // The claim is only ever `2`, and only when the policy is on (see JwtPayload).\n  if (!claims || claims.org_admin_aal !== 2) return undefined;\n  if (!isHumanPrincipal(claims)) {\n    if (options.machines === 'allow') return undefined;\n    return {\n      status: HttpStatus.FORBIDDEN,\n      code: ErrorCode.HUMAN_SESSION_REQUIRED,\n      reason: 'machine_principal',\n      message: 'Your organization requires two-factor authentication for this action — API keys and service accounts cannot perform it',\n    };\n  }\n  if ((claims.aal ?? 1) >= 2) return undefined;\n  return {\n    status: HttpStatus.UNAUTHORIZED,\n    code: ErrorCode.MFA_REQUIRED,\n    reason: 'weak_session',\n    message: 'Your organization requires two-factor authentication for administrative actions — sign in again with a passkey or an authenticator code',\n  };\n}\n\n/**\n * Apply {@link orgAdminAssuranceRefusal} and send its refusal. Returns true when\n * the request was REFUSED (a response has been sent). For handler-level use;\n * routes use {@link requireOrgAdminAssurance}.\n */\nexport function refuseForOrgAdminAssurance(req: Request, res: Response, options: OrgAdminAssuranceOptions): boolean {\n  const refusal = orgAdminAssuranceRefusal(req.user as JwtPayload | undefined, options);\n  if (!refusal) return false;\n  emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: `org_admin_${refusal.reason}` });\n  recordAuthzDenial(req, 'assurance:org-admin');\n  sendError(res, refusal.status, refusal.message, refusal.code, { reason: ORG_ADMIN_MFA_REASON });\n  return true;\n}\n\n/**\n * The org policy \"administrative actions require MFA\" (`adminActionsRequireMfa`).\n *\n * Unlike {@link requireAssurance}, the requirement is the ORG's choice, not the\n * route's: the gate reads the `org_admin_aal` claim, set at token issue from the\n * active org's policy (strictest across its ancestors), so a service that cannot\n * read the org document still enforces it. With the policy off the gate is a\n * no-op; with it on, a single-factor session is refused 401 `MFA_REQUIRED`\n * (with `details.reason: 'org_admin_policy'`) — the same code the client already\n * turns into \"enrol a factor / sign in with it\", never a sign-out.\n *\n * `machines` is decided per route (see {@link OrgAdminAssuranceMachines}): the\n * policy is about how strongly a PERSON's session was opened, so automation that\n * legitimately drives a route keeps working (`allow`), while a route that mints\n * a further credential refuses machines outright (`refuse`, 403\n * `HUMAN_SESSION_REQUIRED` — the same refusal `requireAssurance` gives them).\n */\nexport function requireOrgAdminAssurance(options: OrgAdminAssuranceOptions) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    if (refuseForOrgAdminAssurance(req, res, options)) return;\n    next();\n  }, { kind: 'orgAdminAssurance', machines: options.machines });\n}\n\n/**\n * Enforce `minAssurance` / `maxAge` on a verified token. Returns true when the\n * request was REFUSED (a response has been sent).\n *\n * Three distinct refusals, because the client's next move differs for each:\n * a machine must stop (403), a weak session must gain a factor (401\n * `MFA_REQUIRED` → enrolment, never a sign-out), and a stale one must simply\n * authenticate again (401 `REAUTH_REQUIRED`).\n */\nfunction refuseForAssurance(\n  options: AssuranceOptions,\n  decoded: JwtPayload,\n  req: Request,\n  res: Response,\n): boolean {\n  const minAssurance = options.minAssurance;\n  const refuse = (reason: string, status: number, message: string, code: ErrorCode): true => {\n    emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason });\n    recordAuthzDenial(req, `assurance:${minAssurance}`);\n    sendError(res, status, message, code);\n    return true;\n  };\n\n  if (!isHumanPrincipal(decoded)) {\n    return refuse(\n      'machine_principal', HttpStatus.FORBIDDEN,\n      'This action requires a person signed in with two-factor authentication — API keys and service accounts cannot perform it',\n      ErrorCode.HUMAN_SESSION_REQUIRED,\n    );\n  }\n  if ((decoded.aal ?? 1) < minAssurance) {\n    return refuse(\n      'weak_session', HttpStatus.UNAUTHORIZED,\n      'This action requires two-factor authentication — sign in again with a passkey or an authenticator code',\n      ErrorCode.MFA_REQUIRED,\n    );\n  }\n  if (options.maxAge !== undefined) {\n    const authTime = decoded.auth_time;\n    // No `auth_time` is not \"recent enough by default\" — `hasValidIdentityClaims`\n    // already requires it on a user token, so an absent one means a token this\n    // gate cannot reason about. Fail closed.\n    if (typeof authTime !== 'number' || Math.floor(Date.now() / 1000) - authTime > options.maxAge) {\n      return refuse(\n        'stale_session', HttpStatus.UNAUTHORIZED,\n        'This action requires a recent sign-in — please authenticate again',\n        ErrorCode.REAUTH_REQUIRED,\n      );\n    }\n  }\n  return false;\n}\n\n/**\n * Whether a verified token carries a well-formed identity: a known\n * `principalType` and `token_use`, and the claims that kind of principal must\n * have. Fails closed — a token minted before these claims existed, or one with a\n * contradictory combination, is not an identity any gate should reason about.\n *\n * - `service`: `token_use: 'access'` and a `service:<name>` subject (the name\n *   feeds the denylist and audit attribution).\n * - `user` / `service_account`: `amr` (known methods), `aal` and `auth_time`.\n */\nexport function hasValidIdentityClaims(decoded: Partial<JwtPayload>): boolean {\n  if (!decoded.principalType || !PRINCIPAL_TYPES.includes(decoded.principalType)) return false;\n  if (!decoded.token_use || !TOKEN_USES.includes(decoded.token_use)) return false;\n  if (decoded.principalType === 'service') {\n    return decoded.token_use === 'access'\n      && typeof decoded.sub === 'string'\n      && decoded.sub.startsWith(SERVICE_SUBJECT_PREFIX)\n      && decoded.sub.length > SERVICE_SUBJECT_PREFIX.length;\n  }\n  return Array.isArray(decoded.amr)\n    && decoded.amr.every((m) => AUTH_METHODS.includes(m))\n    && (decoded.aal === 1 || decoded.aal === 2)\n    && typeof decoded.auth_time === 'number';\n}\n\n/**\n * Whether the request's user holds `permission`. Superadmins implicitly hold\n * every permission. Reads the resolved `permissions` claim (set at token issue,\n * or re-derived per request by the platform).\n */\nexport function userHasPermission(req: Request, permission: Permission): boolean {\n  return hasPermission(req.user?.permissions, permission, req.user?.isSuperAdmin);\n}\n\n/**\n * Context passed to a registered authorization-denial auditor when a\n * state-changing request is rejected by `requirePermission` /\n * `requireSystemAdmin`.\n */\nexport interface AuthzDenialInfo {\n  /** The denied user's id (`sub`), if authenticated. */\n  actorId?: string;\n  actorEmail?: string;\n  /** The user's active org at denial time. */\n  orgId?: string;\n  /** HTTP method + path of the rejected request. */\n  method: string;\n  path: string;\n  /** What was required: the missing permission(s), or 'system-admin'. */\n  required: string;\n}\n\n/**\n * Optional sink for denied-authorization events. Left unset by default so\n * api-core stays decoupled from any audit transport — a service registers one\n * at boot (typically forwarding to its `RemoteAuditClient` as an\n * `authz.denied` event, or, on platform, to the local `audit()` helper).\n * MUST be best-effort: it is invoked inside the request path, so it must never\n * throw or block (the gate wraps the call in try/catch regardless).\n */\nlet authzDenialAuditor: ((info: AuthzDenialInfo) => void) | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide authorization-denial\n * auditor. Idempotent; the last registration wins.\n */\nexport function setAuthzDenialAuditor(fn: ((info: AuthzDenialInfo) => void) | undefined): void {\n  authzDenialAuditor = fn;\n}\n\n/**\n * Emit a denial event, best-effort. Only fires for state-changing (non-GET,\n * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and\n * would amplify audit volume under a scan. Never throws.\n *\n * The permission gates here call it themselves. Export it for data-driven checks\n * a route makes inline (cross-org access, service-only endpoints), so those 403s\n * reach the same `authz.denied` trail. `required` names what was missing.\n */\nexport function recordAuthzDenial(req: Request, required: string): void {\n  const auditor = authzDenialAuditor;\n  if (!auditor) return;\n  const method = req.method.toUpperCase();\n  if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return;\n  try {\n    auditor({\n      actorId: req.user?.sub,\n      actorEmail: req.user?.email,\n      orgId: req.user?.organizationId,\n      method,\n      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/**\n * Requires that the user hold AT LEAST ONE of the given permissions (or be a\n * superadmin). Use after requireAuth. Mirrors `requireRole`'s any-of semantics;\n * pass a single permission for a specific action, or several when any one of\n * them should grant access.\n */\nexport function requirePermission(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    // userHasPermission → hasPermission already grants superadmins every\n    // permission, so this single check covers both the superadmin bypass and\n    // the any-of membership test without re-inlining either.\n    if (permissions.some((p) => userHasPermission(req, p))) return next();\n    recordAuthzDenial(req, permissions.join(' or '));\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${permissions.join(' or ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }, { kind: 'permission', mode: 'any', permissions });\n}\n\n/**\n * Requires that the user hold EVERY one of the given permissions (or be a\n * superadmin) — the AND counterpart to `requirePermission`'s any-of. Use for a\n * sensitive action that legitimately demands two distinct capabilities at once\n * (e.g. a cross-surface operation), so the guarantee is explicit rather than\n * approximated by chaining two `requirePermission` gates. Superadmins bypass\n * (they implicitly hold every permission).\n */\nexport function requireAllPermissions(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    const missing = permissions.filter((p) => !userHasPermission(req, p));\n    if (missing.length === 0) return next();\n    recordAuthzDenial(req, permissions.join(' and '));\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${missing.join(' and ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }, { kind: 'permission', mode: 'all', permissions });\n}\n\n/**\n * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (`principalType: 'service'`). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    if (isServicePrincipal(req) || permissions.some((p) => userHasPermission(req, p))) return next();\n    recordAuthzDenial(req, permissions.join(' or '));\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${permissions.join(' or ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }, { kind: 'permission', mode: 'any', permissions, allowService: true });\n}\n\n/**\n * Gate an endpoint to internal service-to-service callers only (a\n * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    // 403 (not 400) — this is an authorization refusal; status must match the\n    // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).\n    return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\n}\ntagRouteGate(requireServicePrincipal, { kind: 'servicePrincipal' });\n\n/**\n * THE gate for an INTERNAL route (#14) — the one every `/internal/*` path, the\n * quota usage counters, the entity-event ingest and the audit ingest go through.\n *\n * Two rules, both fail-closed:\n *\n *  1. **No user token, ever.** Not a member's, not a superadmin's, not a\n *     service-account key's. An internal route is a peer-service API surface, so\n *     \"a sufficiently privileged human\" is not an acceptable caller — that\n *     equivalence is exactly how a browser-reachable path becomes a tenant\n *     boundary bug. `requireServicePrincipal` already refused users; this also\n *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around\n *     the individual internal routes.\n *  2. **Only the NAMED callers.** `callers` lists the services that legitimately\n *     call this route, and the name is cryptographically bound to the signing\n *     key (`services/service-keys.ts`), so this is an identity check rather than\n *     a claim check. It is the same allow-list the mesh policy names, at the\n *     layer that also holds in docker compose, where there is no mesh at all —\n *     the Istio `AuthorizationPolicy` is defence in depth on top, never the\n *     enforcement.\n *\n * Compose after `requireAuth` so `req.user` is populated. Refusals are counted\n * (`internal_route_refused_total`) and audited through the shared `authz.denied`\n * sink.\n */\nexport function requireInternalService(options: { callers: readonly string[] }) {\n  const allowed = new Set(options.callers);\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    const refuse = (reason: 'unauthenticated' | 'user_token' | 'wrong_caller'): void => {\n      emitCounter('internal_route_refused_total', {\n        service: serviceIdentity(),\n        route: req.route?.path ? `${req.method} ${req.baseUrl}${req.route.path}` : `${req.method} ${(req.originalUrl || req.url).split('?')[0]}`,\n        reason,\n        caller: serviceNameOf(req.user) ?? 'none',\n      });\n      recordAuthzDenial(req, `internal-service (${options.callers.join(', ')})`);\n      if (reason === 'unauthenticated') {\n        return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n      }\n      logger.warn('Refused an internal route', { reason, path: (req.originalUrl || req.url).split('?')[0], caller: serviceNameOf(req.user) });\n      return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n    };\n\n    if (!req.user) return refuse('unauthenticated');\n    if (!isServicePrincipal(req)) return refuse('user_token');\n    const caller = serviceNameOf(req.user);\n    if (!caller || !allowed.has(caller)) return refuse('wrong_caller');\n    next();\n  }, { kind: 'servicePrincipal' }, { kind: 'internalService', callers: [...options.callers] });\n}\n\n/**\n * The system tenant's canonical org **id** — a fixed, well-known ObjectId (NOT\n * the string 'system'). This is the single knob every service resolves the\n * system tenant through; override via the `SYSTEM_ORG_ID` env for alternate\n * installs. The system org's human identifier stays the slug/name 'system'\n * (see {@link SYSTEM_ORG_SLUG}); only its `_id` is this ObjectId.\n */\nexport const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || '000000000000000000000001').toLowerCase();\n\n/** The system org's well-known slug/name (the human identifier; its `_id` is {@link SYSTEM_ORG_ID}). */\nexport const SYSTEM_ORG_SLUG = 'system';\n\n/**\n * Check if an orgId or orgName/slug matches the system org. Use this instead of\n * comparing directly: the id is now an ObjectId ({@link SYSTEM_ORG_ID}) while the\n * name/slug is 'system' ({@link SYSTEM_ORG_SLUG}), so the two are compared against\n * their respective canonical values.\n */\nexport function isSystemOrgId(orgId?: string, orgName?: string): boolean {\n  return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_SLUG;\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT. The \"membership in the well-known 'system' org with role\n * admin/owner\" path was removed — it conflated a Pipeline Builder operator\n * with a real customer tenant in the data model, and meant any unintended\n * write that created a 'system'-named org could quietly grant cross-org\n * authority. The `system` org still exists as a *content holder* for shared\n * sample data; it just no longer confers privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/**\n * Whether the request's token carries a specific capability `scope` (e.g.\n * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine\n * identity — a normal interactive user token has no `scope` and returns false.\n */\nexport function hasScope(req: Request, scope: string): boolean {\n  return req.user?.scope === scope;\n}\n\n/** Requires a system admin — granted solely by the `isSuperAdmin` token claim\n *  (the org-membership path was removed). Use after requireAuth. */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    recordAuthzDenial(req, 'system-admin');\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\ntagRouteGate(requireSystemAdmin, { kind: 'systemAdmin' });\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      // Route feature-gate denials through the same audit sink as\n      // requirePermission / requireSystemAdmin so a probe for an\n      // unentitled capability leaves a trail (state-changing methods only).\n      recordAuthzDenial(req, `feature:${feature}`);\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  }, { kind: 'feature', feature });\n}\n\n// ---------------------------------------------------------------------------\n// Service-to-service tokens\n//\n// Inter-service HTTP calls (billing → message, platform → compliance, etc.)\n// need to satisfy the same `requireAuth` middleware as user requests.\n// `signServiceToken` mints a short-lived ES256 JWT signed with THIS service's\n// OWN key (see `services/service-keys.ts`), carrying `principalType: 'service'`\n// and naming the calling service via `sub: 'service:<name>'`. Gates branch on\n// the claim; the subject names — and since #14 the name is cryptographically\n// bound to the signing key, so it can also be trusted.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream `requireOrganization` /\n// `requireSystemAdmin` rely on the org/role embedded in the token.\n//\n// Tokens default to 5-minute TTL — long enough to survive a backend hop,\n// short enough that a leaked token is low-value.\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;\n\n/**\n * Denylist of service NAMES (the `<name>` in `sub: service:<name>`) whose tokens\n * `requireAuth` must reject. Read from `SERVICE_TOKEN_DENYLIST` (comma-separated)\n * at process start, so arming it is a config change + rollout — it cuts off a\n * compromised service WITHOUT rotating any key, and (unlike the pre-#14 shared\n * secret) without invalidating every other service's tokens as collateral.\n */\nconst serviceTokenDenylist = new Set(\n  (process.env.SERVICE_TOKEN_DENYLIST || '')\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean),\n);\n\n/**\n * The calling service's name for a SERVICE principal (`principalType: 'service'`),\n * else `undefined`. A user token never yields a name, whatever its `sub` says.\n */\nexport function serviceNameOf(claims: { principalType?: string; sub?: string } | undefined): string | undefined {\n  if (claims?.principalType !== 'service' || typeof claims.sub !== 'string') return undefined;\n  if (!claims.sub.startsWith(SERVICE_SUBJECT_PREFIX)) return undefined;\n  return claims.sub.slice(SERVICE_SUBJECT_PREFIX.length) || undefined;\n}\n\n/** True when the claims are a service principal whose service is on the denylist. */\nexport function isServiceTokenDenied(claims: { principalType?: string; sub?: string }): boolean {\n  if (serviceTokenDenylist.size === 0) return false;\n  const name = serviceNameOf(claims);\n  return name !== undefined && serviceTokenDenylist.has(name);\n}\n\nexport interface ServiceTokenOptions {\n  /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */\n  serviceName: string;\n  /** Active org context for the call. Use the target tenant's org id, or the\n   *  well-known `SYSTEM_ORG_ID` (an ObjectId) for system-wide ops — NOT the string\n   *  'system', which id-based system-org checks won't recognize. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n  /**\n   * Role the token carries (required — no implicit default). **Pass the LOWEST\n   * role the call actually needs** (`'member'` for read / data-plane calls) so a\n   * leaked service token can't perform admin actions in the target org.\n   * `isAdmin` is derived from this (admin|owner → true).\n   */\n  role: 'owner' | 'admin' | 'member';\n  /**\n   * Optional fine-grained permission claim. Prefer this + `role: 'member'` over a\n   * high role when a call needs ONE specific capability (e.g. `['plugins:write']`\n   * to push a plugin image) — the token then satisfies that permission gate\n   * WITHOUT carrying `isAdmin`, so a leaked token can't perform admin actions.\n   */\n  permissions?: Permission[];\n}\n\n/**\n * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.\n * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.\n * Scope it with `opts.role` — least privilege keeps a leaked token low-value.\n *\n * `opts.serviceName` must be THIS process's own identity (`SERVICE_NAME`): a\n * service holds only its own signing key, so minting a token that names another\n * service throws rather than producing one every peer would reject. That is the\n * one behaviour change #14 forces on callers — see `services/service-keys.ts`.\n */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role;\n  const payload: Omit<JwtPayload, 'sub'> = {\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    principalType: 'service',\n    token_use: 'access',\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n    // Unique token id on every mint. Combined with the short (300s default) TTL\n    // this gives each service token a distinct identity — the correlation handle\n    // for tracing which mint performed a cross-service action, and the building\n    // block for replay detection (a verifier can track seen jtis). It does NOT\n    // by itself prevent replay within the TTL window.\n    jti: randomUUID(),\n    // Least-privilege capability claim (optional) — lets a member-role token\n    // satisfy a specific permission gate without carrying isAdmin.\n    ...(opts.permissions && opts.permissions.length > 0 ? { permissions: opts.permissions } : {}),\n  };\n  // `sub`, `iat`/`exp` and the optional issuer/audience that requireAuth\n  // verifies are stamped by the signer, so there is exactly one place that\n  // decides what a service token says.\n  return signServiceJwt(payload as Record<string, unknown>, {\n    serviceName: opts.serviceName,\n    expiresInSeconds: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n    ...issuerAudienceOptions(),\n  });\n}\n\n/** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */\nexport function getServiceAuthHeader(opts: ServiceTokenOptions): string {\n  return `Bearer ${signServiceToken(opts)}`;\n}\n\n/** True when `req.user` is a service principal (`principalType: 'service'`, minted by `signServiceToken`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.principalType === 'service';\n}\n\n/**\n * True when `req.user` is an ORG SERVICE ACCOUNT (`principalType:\n * 'service_account'`) — a non-human principal owned by one org, authenticating\n * with a `pb_sa_…` key exchanged at platform.\n *\n * A service account is NOT an internal service principal: it holds org Roles and\n * is subject to every permission gate a member is. What it can never do is\n * satisfy a HUMAN-presence requirement — step-up (and any later assurance gate)\n * refuses it outright, because there is no person behind it to re-verify.\n */\nexport function isServiceAccountPrincipal(req: Request): boolean {\n  return req.user?.principalType === 'service_account';\n}\n\n/** True when `req.user` is the named internal service (e.g. `'billing'`). */\nexport function isServicePrincipalNamed(req: Request, serviceName: string): boolean {\n  return serviceNameOf(req.user) === serviceName;\n}\n\n/**\n * PRE-auth check: cryptographically verify the request carries a valid, signed\n * SERVICE token (`principalType: 'service'`). Unlike {@link isServicePrincipal}\n * (which reads the already-populated `req.user`), this verifies the bearer token\n * itself, so it is safe to call BEFORE `requireAuth` runs — e.g. the global rate\n * limiter's `skip`, which must not trust the spoofable `x-internal-service`\n * header. Mirrors `requireAuth`'s SERVICE chain exactly (the signer's own key,\n * resolved by `kid`, with the `sub`/signer agreement check and the optional\n * issuer/audience) and returns `false` on any missing/invalid/non-service token\n * — including any platform-signed USER token, whose `kid` is not in the service\n * bundle at all. Stays SYNCHRONOUS, which is why the per-service public keys are\n * distributed as a mounted bundle rather than fetched over HTTP.\n */\nexport function verifyServicePrincipal(req: Request): boolean {\n  const parts = req.headers.authorization?.split(' ');\n  if (!parts || parts.length !== 2 || parts[0] !== 'Bearer') return false;\n  try {\n    const header = decodeJwtHeader(parts[1]);\n    if (!header?.kid || !isServiceKid(header.kid)) return false;\n    const decoded = verifyServiceJwt<JwtPayload>(parts[1], { kid: header.kid, ...issuerAudienceOptions() });\n    if (decoded.type !== 'access' || decoded.principalType !== 'service' || !hasValidIdentityClaims(decoded)) return false;\n    // A denylisted (killed) service must NOT be treated as a trusted principal —\n    // otherwise it keeps the rate-limiter exemption even though requireAuth rejects\n    // it on real routes. Fold the kill-switch into the pre-auth check too.\n    return !isServiceTokenDenied(decoded);\n  } catch {\n    return false;\n  }\n}\n"]}