@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/middleware/route-table.js

@@ -18,6 +18,30 @@
  * only adds a symbol property; routing behaviour is unchanged.
  */
 import express from 'express';
+import { isQuotaExemptRoute } from './quota-exempt-routes.js';
+/**
+ * The CLOSED set of principal kinds a `dynamicAuthz` rule may admit.
+ *
+ * A route whose authority is resolved in the handler still has to say WHO can
+ * get through it. These are the kinds, deliberately coarse — the precise
+ * predicate lives in the prose rule and in the code:
+ *
+ *  - `superadmin`    — the `User.isSuperAdmin` flag (`isSystemAdmin(req)`).
+ *  - `system-org`    — a member of the system org holding a named permission;
+ *                      list the ids in `permissions` so the coverage scan and
+ *                      the contract can see them.
+ *  - `tenant-admin`  — an admin or owner of the target's own org, or of an
+ *                      ancestor of it. NOT a superadmin by virtue of the flag:
+ *                      several of these rules refuse the flag on purpose.
+ *  - `tenant-member` — any member of the target's org, admin or not.
+ *  - `subject`       — the very user the request is about (self-service).
+ *  - `service`       — a service principal / internal caller.
+ *  - `gateway`       — the ingress itself supplies the fact (the console
+ *                      `auth_request` passes the console class in a header).
+ */
+export const DYNAMIC_PRINCIPALS = [
+    'superadmin', 'system-org', 'tenant-admin', 'tenant-member', 'subject', 'service', 'gateway',
+];
 // Symbol.for, not Symbol(): a test that loads api-core twice (ESM + a
 // requireActual copy) must still see tags set by the other copy.
 const GATES = Symbol.for('pipeline-builder.route-gates');
@@ -47,6 +71,25 @@ export function getRouteGates(fn) {
  * `router.post('/', audited('pipeline.create'), handler)`. The handler still
  * emits the event itself.
  */
+/**
+ * Declare authorization that the handler resolves (see the `dynamicAuthz` gate).
+ * A no-op middleware, exactly like {@link audited}: it records the rule on the
+ * route table so the contract can print it.
+ *
+ * `rule` is read by a human, so it should name the real predicate — e.g.
+ * `'sysadmin, or an admin of an ancestor org of the target user'`.
+ */
+export function dynamicAuthz(rule, opts) {
+    if (opts.reachableBy.length === 0) {
+        throw new Error(`dynamicAuthz("${rule}") must name at least one principal kind in reachableBy`);
+    }
+    for (const p of opts.reachableBy) {
+        if (!DYNAMIC_PRINCIPALS.includes(p)) {
+            throw new Error(`dynamicAuthz("${rule}"): unknown principal "${p}" — one of ${DYNAMIC_PRINCIPALS.join(', ')}`);
+        }
+    }
+    return tagRouteGate(function dynamicAuthzRoute(_req, _res, next) { next(); }, { kind: 'dynamicAuthz', rule, reachableBy: [...opts.reachableBy], ...(opts.permissions && { permissions: [...opts.permissions] }) });
+}
 export function audited(...actions) {
     return tagRouteGate(function auditedRoute(_req, _res, next) { next(); }, { kind: 'audit', actions });
 }
@@ -106,6 +149,7 @@ function toEntry(method, path, gates) {
         permissions: [],
         systemAdmin: false,
         servicePrincipal: false,
+        dynamicAuthz: [],
         internalCallers: [],
         stepUp: false,
         stepUpMethods: [],
@@ -128,6 +172,14 @@ function toEntry(method, path, gates) {
             case 'servicePrincipal':
                 entry.servicePrincipal = true;
                 break;
+            case 'dynamicAuthz':
+                if (!entry.dynamicAuthz.includes(g.rule))
+                    entry.dynamicAuthz.push(g.rule);
+                entry.dynamicReachableBy = [...new Set([...(entry.dynamicReachableBy ?? []), ...g.reachableBy])].sort();
+                if (g.permissions?.length) {
+                    entry.dynamicPermissions = [...new Set([...(entry.dynamicPermissions ?? []), ...g.permissions])].sort();
+                }
+                break;
             case 'internalService':
                 for (const c of g.callers)
                     if (!entry.internalCallers.includes(c))
@@ -171,8 +223,26 @@ function toEntry(method, path, gates) {
                     if (!entry.audit.includes(a))
                         entry.audit.push(a);
                 break;
+            case 'quota': {
+                const quota = entry.quota ?? (entry.quota = { metered: [], checked: [] });
+                if (g.mode === 'meter')
+                    quota.metered.push(g.quotaType);
+                else if (!quota.checked.includes(g.quotaType))
+                    quota.checked.push(g.quotaType);
+                break;
+            }
         }
     }
+    // An exempt route's apiCalls meter + check skip it at runtime, so the table
+    // says what actually happens rather than what is mounted.
+    if (isQuotaExemptRoute(method, path)) {
+        const quota = entry.quota ?? { metered: [], checked: [] };
+        entry.quota = {
+            metered: quota.metered.filter((t) => t !== 'apiCalls'),
+            checked: quota.checked.filter((t) => t !== 'apiCalls'),
+            exempt: true,
+        };
+    }
     entry.internalCallers.sort();
     entry.stepUpMethods.sort();
     return entry;
@@ -229,7 +299,7 @@ export function isWriteMethod(method) {
 }
 /** Summary counts for a startup log line. */
 export function summarizeRouteTable(table) {
-    const gated = (e) => e.permissions.length > 0 || e.systemAdmin || e.servicePrincipal;
+    const gated = (e) => e.permissions.length > 0 || e.systemAdmin || e.servicePrincipal || e.dynamicAuthz.length > 0;
     const writes = table.filter((e) => isWriteMethod(e.method));
     return {
         routes: table.length,
@@ -239,4 +309,4 @@ export function summarizeRouteTable(table) {
         internal: table.filter((e) => e.internalCallers.length > 0).length,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-table.js","sourceRoot":"","sources":["../../src/middleware/route-table.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Introspectable route table.\n *\n * Authorization is split between router mounts (`app.use('/x', gate, router)`)\n * and individual routes, so grepping source can't prove that every route is\n * gated. Instead, every gate middleware in this package carries METADATA (what it\n * requires), and {@link buildRouteTable} walks an assembled Express app and\n * resolves, per method + path, the full chain of gates Express would run before\n * the handler: permissions, system-admin, service principal, step-up, feature,\n * token scope, and the audit actions the route declares via {@link audited}.\n *\n * Express 5 (router@2) does not keep a mount's path string on its layer, so this\n * module records it: on import it wraps `Router.prototype.use` to stamp each new\n * layer with the path it was mounted at. api-core is imported before any route\n * module registers a route, so every layer an app builds is stamped. The wrap\n * only adds a symbol property; routing behaviour is unchanged.\n */\n\nimport express from 'express';\nimport type { Permission } from '../types/permissions.js';\n\n/**\n * What a MACHINE credential (PAT, service account) meets on a route gated by\n * `requireOrgAdminAssurance` while the org's admin-MFA policy is on:\n *   - `allow`  — the route is legitimately machine-callable (automation that\n *                manages members, roles, billing…); the policy is about how\n *                strongly a PERSON's session was opened, so it does not apply;\n *   - `refuse` — only a person may do this while the policy is on (403\n *                `HUMAN_SESSION_REQUIRED`), e.g. minting another credential.\n */\nexport type OrgAdminAssuranceMachines = 'allow' | 'refuse';\n\n/** One requirement a gate middleware enforces. */\nexport type RouteGate =\n  | { kind: 'auth' }\n  | { kind: 'permission'; mode: 'any' | 'all'; permissions: readonly Permission[]; allowService?: boolean }\n  | { kind: 'systemAdmin' }\n  | { kind: 'servicePrincipal' }\n  /** An INTERNAL route: user tokens refused outright, only these services admitted. */\n  | { kind: 'internalService'; callers: readonly string[] }\n  | { kind: 'stepUp'; methods?: readonly string[] }\n  /** The whole SESSION must be MFA-grade (`requireAuth({ minAssurance })`), and\n   *  optionally no older than `maxAge` seconds. `exempt` names a carve-out the\n   *  gate applies to a narrow class of request (see `AssuranceOptions.exempt`),\n   *  so a route whose level is conditional says so on the table. */\n  | { kind: 'assurance'; minAssurance: 1 | 2; maxAge?: number; exempt?: string }\n  /** The session must be MFA-grade WHEN the org's `adminActionsRequireMfa`\n   *  policy is on (`requireOrgAdminAssurance`). `machines` says what a machine\n   *  credential meets on the route while the policy is on. */\n  | { kind: 'orgAdminAssurance'; machines: OrgAdminAssuranceMachines }\n  /** The caller's ACTIVE org must be the system org (`requireSystemOrg`) — the\n   *  plugin-ecosystem governance boundary (docs/runbooks/ecosystem-moderation.md). */\n  | { kind: 'systemOrg' }\n  | { kind: 'feature'; feature: string }\n  | { kind: 'scope'; scope: string }\n  | { kind: 'audit'; actions: readonly string[] };\n\n// Symbol.for, not Symbol(): a test that loads api-core twice (ESM + a\n// requireActual copy) must still see tags set by the other copy.\nconst GATES = Symbol.for('pipeline-builder.route-gates');\nconst LAYER_PATH = Symbol.for('pipeline-builder.layer-path');\nconst RECORDER_INSTALLED = Symbol.for('pipeline-builder.route-recorder');\n\ntype Tagged = { [GATES]?: RouteGate[] };\n\n/**\n * Attach gate metadata to a middleware function (appends to any existing tags)\n * and return the same function. Use it for a service-local gate so the route\n * table knows what it enforces — e.g. a handler-level `requireComplianceWrite`\n * tagged `{ kind: 'permission', mode: 'any', permissions: ['compliance:write'] }`.\n */\nexport function tagRouteGate<T extends object>(fn: T, ...gates: RouteGate[]): T {\n  const t = fn as T & Tagged;\n  Object.defineProperty(t, GATES, { value: [...(t[GATES] ?? []), ...gates], configurable: true, enumerable: false, writable: true });\n  return fn;\n}\n\n/** The gate metadata attached to a middleware function (empty when untagged). */\nexport function getRouteGates(fn: unknown): readonly RouteGate[] {\n  if (typeof fn !== 'function') return [];\n  return (fn as Tagged)[GATES] ?? [];\n}\n\n/**\n * Declare the audit action(s) a route emits. A no-op middleware whose only job\n * is to put the action on the route table, so the coverage test can require an\n * audit declaration on every write route. Place it in the route's chain:\n * `router.post('/', audited('pipeline.create'), handler)`. The handler still\n * emits the event itself.\n */\nexport function audited(...actions: string[]): (req: unknown, res: unknown, next: () => void) => void {\n  return tagRouteGate(function auditedRoute(_req: unknown, _res: unknown, next: () => void) { next(); }, { kind: 'audit', actions });\n}\n\n// ---------------------------------------------------------------------------\n// Mount-path recording\n// ---------------------------------------------------------------------------\n\ninterface Layer {\n  handle: unknown;\n  route?: { path: string | string[]; methods: Record<string, boolean>; stack: Array<{ method?: string; handle: unknown }> };\n  matchers: Array<(path: string) => unknown>;\n  /** router@2's \"mounted at '/' with end:false\" fast path — matches ANY path. */\n  slash?: boolean;\n  [LAYER_PATH]?: string;\n}\n\ninterface RouterLike { stack: Layer[] }\n\nfunction installRouteRecorder(): void {\n  const proto = (express.Router as unknown as { prototype: Record<string | symbol, unknown> }).prototype;\n  if (proto[RECORDER_INSTALLED]) return;\n  const originalUse = proto.use as (this: RouterLike, ...args: unknown[]) => unknown;\n  proto.use = function recordingUse(this: RouterLike, ...args: unknown[]): unknown {\n    const before = this.stack.length;\n    const result = originalUse.apply(this, args);\n    // Same path disambiguation as router@2's `use`: a leading non-function\n    // (possibly nested in arrays) is the path; otherwise the mount is '/'.\n    let first: unknown = args[0];\n    while (Array.isArray(first) && first.length > 0) first = first[0];\n    const path = typeof first === 'function' ? '/' : String(args[0]);\n    for (let i = before; i < this.stack.length; i++) {\n      Object.defineProperty(this.stack[i], LAYER_PATH, { value: path, enumerable: false, configurable: true });\n    }\n    return result;\n  };\n  Object.defineProperty(proto, RECORDER_INSTALLED, { value: true, enumerable: false });\n}\n\ninstallRouteRecorder();\n\n// ---------------------------------------------------------------------------\n// Table construction\n// ---------------------------------------------------------------------------\n\n/** Resolved requirements for one method + path. */\nexport interface RouteTableEntry {\n  method: string;\n  path: string;\n  /** Authentication runs before the handler (requireAuth). */\n  auth: boolean;\n  /** Each permission gate in the chain (all must pass; each is any-of or all-of). */\n  permissions: Array<{ mode: 'any' | 'all'; permissions: Permission[]; allowService: boolean }>;\n  systemAdmin: boolean;\n  servicePrincipal: boolean;\n  /**\n   * The services allowed to call this route when it is INTERNAL (`requireInternalService`).\n   * An empty array means the route is not internal — a user token may reach it,\n   * subject to the other gates. Sorted, so the generated table is stable.\n   */\n  internalCallers: string[];\n  stepUp: boolean;\n  /** When the step-up gate names the factors that may earn it (`['webauthn',\n   *  'totp']` on the most dangerous routes), the allowed methods. Empty means\n   *  any factor satisfies it. Sorted, so the generated table is stable. */\n  stepUpMethods: string[];\n  /** Highest `minAssurance` any gate in the chain demands; 0 when none does. */\n  minAssurance: 0 | 1 | 2;\n  /** Tightest `maxAge` (seconds) any assurance gate in the chain demands. */\n  maxAge?: number;\n  /**\n   * The named carve-outs the chain's assurance gates allow (sorted). Absent when\n   * there are none, so a table of routes without one is unchanged. A reviewer\n   * reading `minAssurance: 2` next to `assuranceExempt: [\"bootstrap-setup\"]`\n   * knows the level is required of everyone EXCEPT that named case.\n   */\n  assuranceExempt?: string[];\n  /**\n   * Present when the route requires an MFA-grade session WHEN the org's\n   * `adminActionsRequireMfa` policy is on (`requireOrgAdminAssurance`), with\n   * what a machine credential meets there. Absent (not `false`) otherwise, so\n   * the table of a service that uses no such gate is unchanged.\n   */\n  orgAdminAssurance?: { machines: OrgAdminAssuranceMachines };\n  /**\n   * Present (always `true`) when the chain runs `requireSystemOrg`: only a\n   * caller whose active org is the system org gets through. Absent otherwise,\n   * so the table of a service with no ecosystem-governance route is unchanged.\n   */\n  systemOrg?: true;\n  features: string[];\n  scopes: string[];\n  audit: string[];\n}\n\ninterface Candidate { layer: Layer; prefix: string }\n\nfunction joinPath(prefix: string, path: string): string {\n  const joined = `${prefix.replace(/\\/+$/, '')}/${path.replace(/^\\/+/, '')}`;\n  return joined.length > 1 ? joined.replace(/\\/+$/, '') : '/';\n}\n\nfunction isRouter(handle: unknown): handle is RouterLike {\n  return typeof handle === 'function' && Array.isArray((handle as Partial<RouterLike>).stack);\n}\n\n/**\n * Whether a middleware layer (mounted under `prefix`) runs for `fullPath`.\n * Mirrors `Layer.prototype.match`, including its fast path: a layer added with\n * no path (`router.use(gate)`) matches EVERY path under its router — which is\n * exactly how the shared `requirePermission` gates between two `router.use(...)`\n * mounts reach the routers registered after them.\n */\nfunction applies(c: Candidate, fullPath: string): boolean {\n  const base = c.prefix === '/' ? '' : c.prefix;\n  if (base && fullPath !== base && !fullPath.startsWith(`${base}/`)) return false;\n  if (c.layer.slash) return true;\n  const rel = fullPath.slice(base.length) || '/';\n  return c.layer.matchers.some((m) => m(rel) !== false);\n}\n\nfunction collectGates(fns: unknown[]): RouteGate[] {\n  return fns.flatMap((fn) => getRouteGates(fn));\n}\n\nfunction toEntry(method: string, path: string, gates: RouteGate[]): RouteTableEntry {\n  const entry: RouteTableEntry = {\n    method,\n    path,\n    auth: false,\n    permissions: [],\n    systemAdmin: false,\n    servicePrincipal: false,\n    internalCallers: [],\n    stepUp: false,\n    stepUpMethods: [],\n    minAssurance: 0,\n    features: [],\n    scopes: [],\n    audit: [],\n  };\n  for (const g of gates) {\n    switch (g.kind) {\n      case 'auth': entry.auth = true; break;\n      case 'permission': entry.permissions.push({ mode: g.mode, permissions: [...g.permissions], allowService: g.allowService === true }); break;\n      case 'systemAdmin': entry.systemAdmin = true; break;\n      case 'servicePrincipal': entry.servicePrincipal = true; break;\n      case 'internalService': for (const c of g.callers) if (!entry.internalCallers.includes(c)) entry.internalCallers.push(c); break;\n      case 'stepUp':\n        entry.stepUp = true;\n        for (const m of g.methods ?? []) if (!entry.stepUpMethods.includes(m)) entry.stepUpMethods.push(m);\n        break;\n      case 'assurance':\n        // Several gates may apply; the STRICTEST wins, since every one of them runs.\n        if (g.minAssurance > entry.minAssurance) entry.minAssurance = g.minAssurance;\n        if (g.maxAge !== undefined) entry.maxAge = entry.maxAge === undefined ? g.maxAge : Math.min(entry.maxAge, g.maxAge);\n        if (g.exempt !== undefined) {\n          entry.assuranceExempt = [...new Set([...(entry.assuranceExempt ?? []), g.exempt])].sort();\n        }\n        break;\n      case 'orgAdminAssurance':\n        // Strictest wins: one `refuse` in the chain refuses machines.\n        entry.orgAdminAssurance = {\n          machines: entry.orgAdminAssurance?.machines === 'refuse' || g.machines === 'refuse' ? 'refuse' : 'allow',\n        };\n        break;\n      case 'systemOrg': entry.systemOrg = true; break;\n      case 'feature': if (!entry.features.includes(g.feature)) entry.features.push(g.feature); break;\n      case 'scope': if (!entry.scopes.includes(g.scope)) entry.scopes.push(g.scope); break;\n      case 'audit': for (const a of g.actions) if (!entry.audit.includes(a)) entry.audit.push(a); break;\n    }\n  }\n  entry.internalCallers.sort();\n  entry.stepUpMethods.sort();\n  return entry;\n}\n\nfunction walk(stack: Layer[], prefix: string, inherited: Candidate[], out: RouteTableEntry[], seen: Set<string>): void {\n  const local: Candidate[] = [];\n  for (const layer of stack) {\n    if (layer.route) {\n      const paths = Array.isArray(layer.route.path) ? layer.route.path : [layer.route.path];\n      const methods = Object.keys(layer.route.methods).map((m) => (m === '_all' ? '*' : m.toUpperCase()));\n      for (const routePath of paths) {\n        const full = joinPath(prefix, String(routePath));\n        const chain = [...inherited, ...local].filter((c) => applies(c, full)).map((c) => c.layer.handle);\n        for (const method of methods) {\n          const key = `${method} ${full}`;\n          // First registration wins, as in Express: a later duplicate is unreachable.\n          if (seen.has(key)) continue;\n          seen.add(key);\n          const routeFns = layer.route.stack\n            .filter((l) => l.method === undefined || l.method.toUpperCase() === method || method === '*')\n            .map((l) => l.handle);\n          out.push(toEntry(method, full, collectGates([...chain, ...routeFns])));\n        }\n      }\n    } else if (isRouter(layer.handle)) {\n      const mountPath = joinPath(prefix, layer[LAYER_PATH] ?? '/');\n      // Middleware that runs before this router (ancestors + earlier siblings)\n      // is inherited; applicability is re-checked against each full route path.\n      walk(layer.handle.stack, mountPath, [...inherited, ...local], out, seen);\n    } else {\n      local.push({ layer, prefix });\n    }\n  }\n}\n\n/**\n * Build the route table of an assembled Express app (or router): one entry per\n * reachable method + path with every gate that runs before its handler.\n * HEAD is folded into GET, as Express does.\n */\nexport function buildRouteTable(app: unknown): RouteTableEntry[] {\n  const root = (app as { router?: RouterLike }).router ?? (app as RouterLike);\n  const out: RouteTableEntry[] = [];\n  if (!root || !Array.isArray(root.stack)) return out;\n  walk(root.stack, '/', [], out, new Set());\n  return out.sort((a, b) => (a.path === b.path ? a.method.localeCompare(b.method) : a.path.localeCompare(b.path)));\n}\n\n/** Whether a method mutates state (everything except GET/HEAD/OPTIONS). */\nexport function isWriteMethod(method: string): boolean {\n  return !['GET', 'HEAD', 'OPTIONS'].includes(method.toUpperCase());\n}\n\n/** Summary counts for a startup log line. */\nexport function summarizeRouteTable(table: readonly RouteTableEntry[]): { routes: number; writes: number; ungated: number; unaudited: number; internal: number } {\n  const gated = (e: RouteTableEntry): boolean => e.permissions.length > 0 || e.systemAdmin || e.servicePrincipal;\n  const writes = table.filter((e) => isWriteMethod(e.method));\n  return {\n    routes: table.length,\n    writes: writes.length,\n    ungated: table.filter((e) => !gated(e)).length,\n    unaudited: writes.filter((e) => e.audit.length === 0).length,\n    internal: table.filter((e) => e.internalCallers.length > 0).length,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-table.js","sourceRoot":"","sources":["../../src/middleware/route-table.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Introspectable route table.\n *\n * Authorization is split between router mounts (`app.use('/x', gate, router)`)\n * and individual routes, so grepping source can't prove that every route is\n * gated. Instead, every gate middleware in this package carries METADATA (what it\n * requires), and {@link buildRouteTable} walks an assembled Express app and\n * resolves, per method + path, the full chain of gates Express would run before\n * the handler: permissions, system-admin, service principal, step-up, feature,\n * token scope, and the audit actions the route declares via {@link audited}.\n *\n * Express 5 (router@2) does not keep a mount's path string on its layer, so this\n * module records it: on import it wraps `Router.prototype.use` to stamp each new\n * layer with the path it was mounted at. api-core is imported before any route\n * module registers a route, so every layer an app builds is stamped. The wrap\n * only adds a symbol property; routing behaviour is unchanged.\n */\n\nimport express from 'express';\nimport { isQuotaExemptRoute } from './quota-exempt-routes.js';\nimport type { Permission } from '../types/permissions.js';\n\n/**\n * What a MACHINE credential (PAT, service account) meets on a route gated by\n * `requireOrgAdminAssurance` while the org's admin-MFA policy is on:\n *   - `allow`  — the route is legitimately machine-callable (automation that\n *                manages members, roles, billing…); the policy is about how\n *                strongly a PERSON's session was opened, so it does not apply;\n *   - `refuse` — only a person may do this while the policy is on (403\n *                `HUMAN_SESSION_REQUIRED`), e.g. minting another credential.\n */\nexport type OrgAdminAssuranceMachines = 'allow' | 'refuse';\n\n/**\n * The CLOSED set of principal kinds a `dynamicAuthz` rule may admit.\n *\n * A route whose authority is resolved in the handler still has to say WHO can\n * get through it. These are the kinds, deliberately coarse — the precise\n * predicate lives in the prose rule and in the code:\n *\n *  - `superadmin`    — the `User.isSuperAdmin` flag (`isSystemAdmin(req)`).\n *  - `system-org`    — a member of the system org holding a named permission;\n *                      list the ids in `permissions` so the coverage scan and\n *                      the contract can see them.\n *  - `tenant-admin`  — an admin or owner of the target's own org, or of an\n *                      ancestor of it. NOT a superadmin by virtue of the flag:\n *                      several of these rules refuse the flag on purpose.\n *  - `tenant-member` — any member of the target's org, admin or not.\n *  - `subject`       — the very user the request is about (self-service).\n *  - `service`       — a service principal / internal caller.\n *  - `gateway`       — the ingress itself supplies the fact (the console\n *                      `auth_request` passes the console class in a header).\n */\nexport const DYNAMIC_PRINCIPALS = [\n  'superadmin', 'system-org', 'tenant-admin', 'tenant-member', 'subject', 'service', 'gateway',\n] as const;\nexport type DynamicPrincipal = typeof DYNAMIC_PRINCIPALS[number];\n\n/** One requirement a gate middleware enforces. */\nexport type RouteGate =\n  | { kind: 'auth' }\n  | { kind: 'permission'; mode: 'any' | 'all'; permissions: readonly Permission[]; allowService?: boolean }\n  | { kind: 'systemAdmin' }\n  /**\n   * Authorization the route CANNOT express statically, resolved in the handler.\n   *\n   * Some authority depends on the request: impersonation asks whether the caller\n   * is a sysadmin OR an admin of an ancestor of the TARGET user's org, which is\n   * only answerable once the target is known. Those gates were correct but\n   * invisible — the route table showed no requirement, and\n   * `docs/permission-contract.md` is derived from the table, so the artifact the\n   * repo calls its review surface read blank for the strongest privilege in the\n   * system.\n   *\n   * This records the requirement in prose AND as a closed set of principal\n   * kinds. It authorizes NOTHING; the handler still does the work. Its value is\n   * that a reviewer reading the contract sees a stated rule instead of an empty\n   * cell, and that removing the real check leaves a declaration behind that no\n   * longer matches.\n   *\n   * WHY `reachableBy` EXISTS BESIDE THE PROSE. Prose is unreviewable by a test,\n   * and one of these rules was wrong: the impersonation `decide` route declared\n   * \"a DIFFERENT sysadmin than the requester (two-person rule)\", which is only\n   * its break-glass branch — the ordinary branch is the tenant's named approver\n   * or a genuine tenant admin, and a sysadmin alone is explicitly REFUSED there.\n   * Nothing could notice, because the only machine-readable fields said\n   * `systemAdmin: false, permissions: []`. A closed set makes the author\n   * enumerate principals, lets the coverage scan assert the declaration exists,\n   * and lets \"which routes can the superadmin flag reach?\" be answered by a\n   * query instead of by reading six paragraphs.\n   */\n  | { kind: 'dynamicAuthz'; rule: string; reachableBy: readonly DynamicPrincipal[]; permissions?: readonly Permission[] }\n  | { kind: 'servicePrincipal' }\n  /** An INTERNAL route: user tokens refused outright, only these services admitted. */\n  | { kind: 'internalService'; callers: readonly string[] }\n  | { kind: 'stepUp'; methods?: readonly string[] }\n  /** The whole SESSION must be MFA-grade (`requireAuth({ minAssurance })`), and\n   *  optionally no older than `maxAge` seconds. `exempt` names a carve-out the\n   *  gate applies to a narrow class of request (see `AssuranceOptions.exempt`),\n   *  so a route whose level is conditional says so on the table. */\n  | { kind: 'assurance'; minAssurance: 1 | 2; maxAge?: number; exempt?: string }\n  /** The session must be MFA-grade WHEN the org's `adminActionsRequireMfa`\n   *  policy is on (`requireOrgAdminAssurance`). `machines` says what a machine\n   *  credential meets on the route while the policy is on. */\n  | { kind: 'orgAdminAssurance'; machines: OrgAdminAssuranceMachines }\n  /** The caller's ACTIVE org must be the system org (`requireSystemOrg`) — the\n   *  plugin-ecosystem governance boundary (docs/runbooks/ecosystem-moderation.md). */\n  | { kind: 'systemOrg' }\n  | { kind: 'feature'; feature: string }\n  | { kind: 'scope'; scope: string }\n  | { kind: 'audit'; actions: readonly string[] }\n  /** A quota middleware: `meter` increments the type once per 2xx\n   *  (`meterQuotaOnSuccess`), `check` 429s when the type is spent (`checkQuota`).\n   *  Recorded so the quota coverage check can see an unmetered user route — and a\n   *  route metered TWICE, which double-bills every call. */\n  | { kind: 'quota'; mode: 'meter' | 'check'; quotaType: string };\n\n// Symbol.for, not Symbol(): a test that loads api-core twice (ESM + a\n// requireActual copy) must still see tags set by the other copy.\nconst GATES = Symbol.for('pipeline-builder.route-gates');\nconst LAYER_PATH = Symbol.for('pipeline-builder.layer-path');\nconst RECORDER_INSTALLED = Symbol.for('pipeline-builder.route-recorder');\n\ntype Tagged = { [GATES]?: RouteGate[] };\n\n/**\n * Attach gate metadata to a middleware function (appends to any existing tags)\n * and return the same function. Use it for a service-local gate so the route\n * table knows what it enforces — e.g. a handler-level `requireComplianceWrite`\n * tagged `{ kind: 'permission', mode: 'any', permissions: ['compliance:write'] }`.\n */\nexport function tagRouteGate<T extends object>(fn: T, ...gates: RouteGate[]): T {\n  const t = fn as T & Tagged;\n  Object.defineProperty(t, GATES, { value: [...(t[GATES] ?? []), ...gates], configurable: true, enumerable: false, writable: true });\n  return fn;\n}\n\n/** The gate metadata attached to a middleware function (empty when untagged). */\nexport function getRouteGates(fn: unknown): readonly RouteGate[] {\n  if (typeof fn !== 'function') return [];\n  return (fn as Tagged)[GATES] ?? [];\n}\n\n/**\n * Declare the audit action(s) a route emits. A no-op middleware whose only job\n * is to put the action on the route table, so the coverage test can require an\n * audit declaration on every write route. Place it in the route's chain:\n * `router.post('/', audited('pipeline.create'), handler)`. The handler still\n * emits the event itself.\n */\n/**\n * Declare authorization that the handler resolves (see the `dynamicAuthz` gate).\n * A no-op middleware, exactly like {@link audited}: it records the rule on the\n * route table so the contract can print it.\n *\n * `rule` is read by a human, so it should name the real predicate — e.g.\n * `'sysadmin, or an admin of an ancestor org of the target user'`.\n */\nexport function dynamicAuthz(\n  rule: string,\n  opts: { reachableBy: readonly DynamicPrincipal[]; permissions?: readonly Permission[] },\n): (req: unknown, res: unknown, next: () => void) => void {\n  if (opts.reachableBy.length === 0) {\n    throw new Error(`dynamicAuthz(\"${rule}\") must name at least one principal kind in reachableBy`);\n  }\n  for (const p of opts.reachableBy) {\n    if (!DYNAMIC_PRINCIPALS.includes(p)) {\n      throw new Error(`dynamicAuthz(\"${rule}\"): unknown principal \"${p}\" — one of ${DYNAMIC_PRINCIPALS.join(', ')}`);\n    }\n  }\n  return tagRouteGate(\n    function dynamicAuthzRoute(_req: unknown, _res: unknown, next: () => void) { next(); },\n    { kind: 'dynamicAuthz', rule, reachableBy: [...opts.reachableBy], ...(opts.permissions && { permissions: [...opts.permissions] }) },\n  );\n}\n\nexport function audited(...actions: string[]): (req: unknown, res: unknown, next: () => void) => void {\n  return tagRouteGate(function auditedRoute(_req: unknown, _res: unknown, next: () => void) { next(); }, { kind: 'audit', actions });\n}\n\n// ---------------------------------------------------------------------------\n// Mount-path recording\n// ---------------------------------------------------------------------------\n\ninterface Layer {\n  handle: unknown;\n  route?: { path: string | string[]; methods: Record<string, boolean>; stack: Array<{ method?: string; handle: unknown }> };\n  matchers: Array<(path: string) => unknown>;\n  /** router@2's \"mounted at '/' with end:false\" fast path — matches ANY path. */\n  slash?: boolean;\n  [LAYER_PATH]?: string;\n}\n\ninterface RouterLike { stack: Layer[] }\n\nfunction installRouteRecorder(): void {\n  const proto = (express.Router as unknown as { prototype: Record<string | symbol, unknown> }).prototype;\n  if (proto[RECORDER_INSTALLED]) return;\n  const originalUse = proto.use as (this: RouterLike, ...args: unknown[]) => unknown;\n  proto.use = function recordingUse(this: RouterLike, ...args: unknown[]): unknown {\n    const before = this.stack.length;\n    const result = originalUse.apply(this, args);\n    // Same path disambiguation as router@2's `use`: a leading non-function\n    // (possibly nested in arrays) is the path; otherwise the mount is '/'.\n    let first: unknown = args[0];\n    while (Array.isArray(first) && first.length > 0) first = first[0];\n    const path = typeof first === 'function' ? '/' : String(args[0]);\n    for (let i = before; i < this.stack.length; i++) {\n      Object.defineProperty(this.stack[i], LAYER_PATH, { value: path, enumerable: false, configurable: true });\n    }\n    return result;\n  };\n  Object.defineProperty(proto, RECORDER_INSTALLED, { value: true, enumerable: false });\n}\n\ninstallRouteRecorder();\n\n// ---------------------------------------------------------------------------\n// Table construction\n// ---------------------------------------------------------------------------\n\n/** Resolved requirements for one method + path. */\nexport interface RouteTableEntry {\n  method: string;\n  path: string;\n  /** Authentication runs before the handler (requireAuth). */\n  auth: boolean;\n  /** Each permission gate in the chain (all must pass; each is any-of or all-of). */\n  permissions: Array<{ mode: 'any' | 'all'; permissions: Permission[]; allowService: boolean }>;\n  systemAdmin: boolean;\n  servicePrincipal: boolean;\n  /** Authorization the HANDLER resolves, in prose — see the `dynamicAuthz` gate.\n   *  Empty when the route's authority is fully expressed by the gates above. */\n  dynamicAuthz: string[];\n  /** The principal kinds those dynamic rules admit, deduped and sorted. Absent\n   *  when the route declares no dynamic rule, so tables without one are\n   *  unchanged. This is the machine-readable half of `dynamicAuthz`: it is how\n   *  \"which routes can the superadmin flag reach?\" is answerable without\n   *  reading prose. */\n  dynamicReachableBy?: DynamicPrincipal[];\n  /** Permission ids a dynamic rule consults inside the handler, deduped and\n   *  sorted. Absent when none does. These are REAL enforcement — the coverage\n   *  scan counts a `userHasPermission(req, 'x')` in a controller — so the\n   *  contract should not read as though the route asked for nothing. */\n  dynamicPermissions?: Permission[];\n  /**\n   * The services allowed to call this route when it is INTERNAL (`requireInternalService`).\n   * An empty array means the route is not internal — a user token may reach it,\n   * subject to the other gates. Sorted, so the generated table is stable.\n   */\n  internalCallers: string[];\n  stepUp: boolean;\n  /** When the step-up gate names the factors that may earn it (`['webauthn',\n   *  'totp']` on the most dangerous routes), the allowed methods. Empty means\n   *  any factor satisfies it. Sorted, so the generated table is stable. */\n  stepUpMethods: string[];\n  /** Highest `minAssurance` any gate in the chain demands; 0 when none does. */\n  minAssurance: 0 | 1 | 2;\n  /** Tightest `maxAge` (seconds) any assurance gate in the chain demands. */\n  maxAge?: number;\n  /**\n   * The named carve-outs the chain's assurance gates allow (sorted). Absent when\n   * there are none, so a table of routes without one is unchanged. A reviewer\n   * reading `minAssurance: 2` next to `assuranceExempt: [\"bootstrap-setup\"]`\n   * knows the level is required of everyone EXCEPT that named case.\n   */\n  assuranceExempt?: string[];\n  /**\n   * Present when the route requires an MFA-grade session WHEN the org's\n   * `adminActionsRequireMfa` policy is on (`requireOrgAdminAssurance`), with\n   * what a machine credential meets there. Absent (not `false`) otherwise, so\n   * the table of a service that uses no such gate is unchanged.\n   */\n  orgAdminAssurance?: { machines: OrgAdminAssuranceMachines };\n  /**\n   * Present (always `true`) when the chain runs `requireSystemOrg`: only a\n   * caller whose active org is the system org gets through. Absent otherwise,\n   * so the table of a service with no ecosystem-governance route is unchanged.\n   */\n  systemOrg?: true;\n  features: string[];\n  scopes: string[];\n  audit: string[];\n  /**\n   * The quota middleware in the chain: the types metered (once per 2xx) and\n   * checked (429 when spent). `metered` is NOT deduped — a type listed twice is\n   * metered twice, which the coverage check flags. `exempt` marks a route on the\n   * fleet-wide `QUOTA_EXEMPT_ROUTES` list, where the `apiCalls` meter and check\n   * are no-ops at runtime (so `apiCalls` is left out of both lists). Absent when\n   * the chain has no quota middleware and the route is not exempt.\n   */\n  quota?: { metered: string[]; checked: string[]; exempt?: true };\n}\n\ninterface Candidate { layer: Layer; prefix: string }\n\nfunction joinPath(prefix: string, path: string): string {\n  const joined = `${prefix.replace(/\\/+$/, '')}/${path.replace(/^\\/+/, '')}`;\n  return joined.length > 1 ? joined.replace(/\\/+$/, '') : '/';\n}\n\nfunction isRouter(handle: unknown): handle is RouterLike {\n  return typeof handle === 'function' && Array.isArray((handle as Partial<RouterLike>).stack);\n}\n\n/**\n * Whether a middleware layer (mounted under `prefix`) runs for `fullPath`.\n * Mirrors `Layer.prototype.match`, including its fast path: a layer added with\n * no path (`router.use(gate)`) matches EVERY path under its router — which is\n * exactly how the shared `requirePermission` gates between two `router.use(...)`\n * mounts reach the routers registered after them.\n */\nfunction applies(c: Candidate, fullPath: string): boolean {\n  const base = c.prefix === '/' ? '' : c.prefix;\n  if (base && fullPath !== base && !fullPath.startsWith(`${base}/`)) return false;\n  if (c.layer.slash) return true;\n  const rel = fullPath.slice(base.length) || '/';\n  return c.layer.matchers.some((m) => m(rel) !== false);\n}\n\nfunction collectGates(fns: unknown[]): RouteGate[] {\n  return fns.flatMap((fn) => getRouteGates(fn));\n}\n\nfunction toEntry(method: string, path: string, gates: RouteGate[]): RouteTableEntry {\n  const entry: RouteTableEntry = {\n    method,\n    path,\n    auth: false,\n    permissions: [],\n    systemAdmin: false,\n    servicePrincipal: false,\n    dynamicAuthz: [],\n    internalCallers: [],\n    stepUp: false,\n    stepUpMethods: [],\n    minAssurance: 0,\n    features: [],\n    scopes: [],\n    audit: [],\n  };\n  for (const g of gates) {\n    switch (g.kind) {\n      case 'auth': entry.auth = true; break;\n      case 'permission': entry.permissions.push({ mode: g.mode, permissions: [...g.permissions], allowService: g.allowService === true }); break;\n      case 'systemAdmin': entry.systemAdmin = true; break;\n      case 'servicePrincipal': entry.servicePrincipal = true; break;\n      case 'dynamicAuthz':\n        if (!entry.dynamicAuthz.includes(g.rule)) entry.dynamicAuthz.push(g.rule);\n        entry.dynamicReachableBy = [...new Set([...(entry.dynamicReachableBy ?? []), ...g.reachableBy])].sort();\n        if (g.permissions?.length) {\n          entry.dynamicPermissions = [...new Set([...(entry.dynamicPermissions ?? []), ...g.permissions])].sort();\n        }\n        break;\n      case 'internalService': for (const c of g.callers) if (!entry.internalCallers.includes(c)) entry.internalCallers.push(c); break;\n      case 'stepUp':\n        entry.stepUp = true;\n        for (const m of g.methods ?? []) if (!entry.stepUpMethods.includes(m)) entry.stepUpMethods.push(m);\n        break;\n      case 'assurance':\n        // Several gates may apply; the STRICTEST wins, since every one of them runs.\n        if (g.minAssurance > entry.minAssurance) entry.minAssurance = g.minAssurance;\n        if (g.maxAge !== undefined) entry.maxAge = entry.maxAge === undefined ? g.maxAge : Math.min(entry.maxAge, g.maxAge);\n        if (g.exempt !== undefined) {\n          entry.assuranceExempt = [...new Set([...(entry.assuranceExempt ?? []), g.exempt])].sort();\n        }\n        break;\n      case 'orgAdminAssurance':\n        // Strictest wins: one `refuse` in the chain refuses machines.\n        entry.orgAdminAssurance = {\n          machines: entry.orgAdminAssurance?.machines === 'refuse' || g.machines === 'refuse' ? 'refuse' : 'allow',\n        };\n        break;\n      case 'systemOrg': entry.systemOrg = true; break;\n      case 'feature': if (!entry.features.includes(g.feature)) entry.features.push(g.feature); break;\n      case 'scope': if (!entry.scopes.includes(g.scope)) entry.scopes.push(g.scope); break;\n      case 'audit': for (const a of g.actions) if (!entry.audit.includes(a)) entry.audit.push(a); break;\n      case 'quota': {\n        const quota = entry.quota ?? (entry.quota = { metered: [], checked: [] });\n        if (g.mode === 'meter') quota.metered.push(g.quotaType);\n        else if (!quota.checked.includes(g.quotaType)) quota.checked.push(g.quotaType);\n        break;\n      }\n    }\n  }\n  // An exempt route's apiCalls meter + check skip it at runtime, so the table\n  // says what actually happens rather than what is mounted.\n  if (isQuotaExemptRoute(method, path)) {\n    const quota = entry.quota ?? { metered: [], checked: [] };\n    entry.quota = {\n      metered: quota.metered.filter((t) => t !== 'apiCalls'),\n      checked: quota.checked.filter((t) => t !== 'apiCalls'),\n      exempt: true,\n    };\n  }\n  entry.internalCallers.sort();\n  entry.stepUpMethods.sort();\n  return entry;\n}\n\nfunction walk(stack: Layer[], prefix: string, inherited: Candidate[], out: RouteTableEntry[], seen: Set<string>): void {\n  const local: Candidate[] = [];\n  for (const layer of stack) {\n    if (layer.route) {\n      const paths = Array.isArray(layer.route.path) ? layer.route.path : [layer.route.path];\n      const methods = Object.keys(layer.route.methods).map((m) => (m === '_all' ? '*' : m.toUpperCase()));\n      for (const routePath of paths) {\n        const full = joinPath(prefix, String(routePath));\n        const chain = [...inherited, ...local].filter((c) => applies(c, full)).map((c) => c.layer.handle);\n        for (const method of methods) {\n          const key = `${method} ${full}`;\n          // First registration wins, as in Express: a later duplicate is unreachable.\n          if (seen.has(key)) continue;\n          seen.add(key);\n          const routeFns = layer.route.stack\n            .filter((l) => l.method === undefined || l.method.toUpperCase() === method || method === '*')\n            .map((l) => l.handle);\n          out.push(toEntry(method, full, collectGates([...chain, ...routeFns])));\n        }\n      }\n    } else if (isRouter(layer.handle)) {\n      const mountPath = joinPath(prefix, layer[LAYER_PATH] ?? '/');\n      // Middleware that runs before this router (ancestors + earlier siblings)\n      // is inherited; applicability is re-checked against each full route path.\n      walk(layer.handle.stack, mountPath, [...inherited, ...local], out, seen);\n    } else {\n      local.push({ layer, prefix });\n    }\n  }\n}\n\n/**\n * Build the route table of an assembled Express app (or router): one entry per\n * reachable method + path with every gate that runs before its handler.\n * HEAD is folded into GET, as Express does.\n */\nexport function buildRouteTable(app: unknown): RouteTableEntry[] {\n  const root = (app as { router?: RouterLike }).router ?? (app as RouterLike);\n  const out: RouteTableEntry[] = [];\n  if (!root || !Array.isArray(root.stack)) return out;\n  walk(root.stack, '/', [], out, new Set());\n  return out.sort((a, b) => (a.path === b.path ? a.method.localeCompare(b.method) : a.path.localeCompare(b.path)));\n}\n\n/** Whether a method mutates state (everything except GET/HEAD/OPTIONS). */\nexport function isWriteMethod(method: string): boolean {\n  return !['GET', 'HEAD', 'OPTIONS'].includes(method.toUpperCase());\n}\n\n/** Summary counts for a startup log line. */\nexport function summarizeRouteTable(table: readonly RouteTableEntry[]): { routes: number; writes: number; ungated: number; unaudited: number; internal: number } {\n  const gated = (e: RouteTableEntry): boolean => e.permissions.length > 0 || e.systemAdmin || e.servicePrincipal || e.dynamicAuthz.length > 0;\n  const writes = table.filter((e) => isWriteMethod(e.method));\n  return {\n    routes: table.length,\n    writes: writes.length,\n    ungated: table.filter((e) => !gated(e)).length,\n    unaudited: writes.filter((e) => e.audit.length === 0).length,\n    internal: table.filter((e) => e.internalCallers.length > 0).length,\n  };\n}\n"]}

package/lib/middleware/service-tokens.d.ts

@@ -38,6 +38,14 @@ export interface ServiceTokenOptions {
      * WITHOUT carrying `isAdmin`, so a leaked token can't perform admin actions.
      */
     permissions?: Permission[];
+    /**
+     * Signed claim (`auditCrossOrg: true`) letting an `/audit/events` delivery name
+     * an `affectedOrgId` outside the token's org. Set ONLY by the remote-audit
+     * client, and only when the event's verified inbound principal was a
+     * superadmin or a system-org member — never from call-site input. Means
+     * nothing to any other route.
+     */
+    auditCrossOrg?: boolean;
 }
 /**
  * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.

package/lib/middleware/service-tokens.js

@@ -20,8 +20,9 @@ import { decodeJwtHeader } from '../utils/jwk.js';
 // the claim; the subject names — and since #14 the name is cryptographically
 // bound to the signing key, so it can also be trusted.
 // `requireAuth` accepts these tokens transparently — they pass `decoded.sub`
-// and `decoded.role` checks, and downstream `requireOrganization` /
-// `requireSystemAdmin` rely on the org/role embedded in the token.
+// and `decoded.role` checks, and the downstream org/role gates
+// (`requireOrgMembership` in platform's controller helpers, `requireSystemAdmin`)
+// rely on the org/role embedded in the token.
 //
 // Tokens default to 5-minute TTL — long enough to survive a backend hop,
 // short enough that a leaked token is low-value.
@@ -87,6 +88,7 @@ export function signServiceToken(opts) {
         // Least-privilege capability claim (optional) — lets a member-role token
         // satisfy a specific permission gate without carrying isAdmin.
         ...(opts.permissions && opts.permissions.length > 0 ? { permissions: opts.permissions } : {}),
+        ...(opts.auditCrossOrg ? { auditCrossOrg: true } : {}),
     };
     // `sub`, `iat`/`exp` and the optional issuer/audience that requireAuth
     // verifies are stamped by the signer, so there is exactly one place that
@@ -155,4 +157,4 @@ export function verifyServicePrincipal(req) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-tokens.js","sourceRoot":"","sources":["../../src/middleware/service-tokens.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Service-to-service tokens and service-principal checks.\n */\n\nimport { randomUUID } from 'crypto';\nimport type { Request } from 'express';\nimport { hasValidIdentityClaims, issuerAudienceOptions } from './jwt-verify.js';\nimport { SERVICE_SUBJECT_PREFIX, isServiceKid, signServiceJwt, verifyServiceJwt } from '../services/service-keys.js';\nimport { type JwtPayload } from '../types/common.js';\nimport { type Permission } from '../types/permissions.js';\nimport { decodeJwtHeader } from '../utils/jwk.js';\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 without invalidating every\n * 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":"service-tokens.js","sourceRoot":"","sources":["../../src/middleware/service-tokens.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Service-to-service tokens and service-principal checks.\n */\n\nimport { randomUUID } from 'crypto';\nimport type { Request } from 'express';\nimport { hasValidIdentityClaims, issuerAudienceOptions } from './jwt-verify.js';\nimport { SERVICE_SUBJECT_PREFIX, isServiceKid, signServiceJwt, verifyServiceJwt } from '../services/service-keys.js';\nimport { type JwtPayload } from '../types/common.js';\nimport { type Permission } from '../types/permissions.js';\nimport { decodeJwtHeader } from '../utils/jwk.js';\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 the downstream org/role gates\n// (`requireOrgMembership` in platform's controller helpers, `requireSystemAdmin`)\n// 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 without invalidating every\n * 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   * Signed claim (`auditCrossOrg: true`) letting an `/audit/events` delivery name\n   * an `affectedOrgId` outside the token's org. Set ONLY by the remote-audit\n   * client, and only when the event's verified inbound principal was a\n   * superadmin or a system-org member — never from call-site input. Means\n   * nothing to any other route.\n   */\n  auditCrossOrg?: boolean;\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    ...(opts.auditCrossOrg ? { auditCrossOrg: true as const } : {}),\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"]}

package/lib/middleware/step-up.js

@@ -1,6 +1,7 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { verifyUserJwt } from './jwt-verify.js';
+import { recordAuthzDenial } from './permission-gates.js';
 import { tagRouteGate } from './route-table.js';
 import { isServiceAccountPrincipal, isServicePrincipal } from './service-tokens.js';
 import { createEnvRedisClient, createRedisReadyGate } from '../services/env-redis.js';
@@ -142,6 +143,7 @@ async function _requireStepUp(options, req, res, next) {
     // so "a machine credential never satisfies an assurance requirement" is a
     // property of this gate, not a side effect of how step-up tokens are minted.
     if (isServiceAccountPrincipal(req)) {
+        recordAuthzDenial(req, 'step-up (STEP_UP_NOT_AVAILABLE: service account)');
         sendError(res, 403, 'A service account cannot perform this action — it requires a person to re-verify', 'STEP_UP_NOT_AVAILABLE');
         return;
     }
@@ -160,10 +162,16 @@ async function _requireStepUp(options, req, res, next) {
         payload = await verifyStepUpToken(token);
     }
     catch {
+        // A presented-but-unverifiable token (forged, expired, wrong key) is on the
+        // trail; a MISSING one (STEP_UP_REQUIRED above) is the UI's normal first
+        // attempt and is not.
+        recordAuthzDenial(req, 'step-up (STEP_UP_INVALID)');
         sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');
         return;
     }
     if (payload.sub !== callerSub) {
+        // Someone else's step-up token replayed on this session — never a UI bug.
+        recordAuthzDenial(req, 'step-up (STEP_UP_MISMATCH)');
         sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');
         return;
     }
@@ -171,11 +179,13 @@ async function _requireStepUp(options, req, res, next) {
     // earned by the wrong factor can still be spent on a route that accepts it —
     // burning it here would make the refusal destructive as well as confusing.
     if (options.methods && !(payload.method && options.methods.includes(payload.method))) {
+        recordAuthzDenial(req, `step-up (STEP_UP_METHOD_REQUIRED: ${options.methods.join(' or ')}, got ${payload.method ?? 'none'})`);
         sendError(res, 401, 'This action must be confirmed with a passkey or an authenticator code', 'STEP_UP_METHOD_REQUIRED', { methods: [...options.methods] });
         return;
     }
     try {
         if (!(await consumeStepUpJti(payload.jti, payload.exp))) {
+            recordAuthzDenial(req, 'step-up (STEP_UP_REPLAY)');
             sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');
             return;
         }
@@ -187,4 +197,4 @@ async function _requireStepUp(options, req, res, next) {
     }
     next();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user;\n * platform mints a short-lived (60s) `step-up` JWT with the SAME ES256 signing\n * key it mints access tokens with, so these services verify it through the same\n * JWKS. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, so the verify + single-use jti live in api-core where any\n * service can require them.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { verifyUserJwt } from './jwt-verify.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceAccountPrincipal, isServicePrincipal } from './service-tokens.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/**\n * How a step-up token was earned. Mirrors platform's `StepUpMethod`; kept here\n * as its own union so a verifier can name the factors it accepts without\n * importing platform.\n */\nexport type StepUpMethod = 'password' | 'webauthn' | 'totp' | 'reauth';\n\n/**\n * The factors that count as a SECOND FACTOR, for routes that may only be\n * unlocked by one (#8: impersonation, KMS, IdP settings, platform admin).\n *\n * A password or a provider re-auth proves the same single factor the session was\n * already opened with, so on those routes they are not enough: the point is that\n * someone holding only a stolen session — or only a stolen password — cannot\n * proceed.\n */\nexport const STRONG_STEP_UP_METHODS: readonly StepUpMethod[] = ['webauthn', 'totp'];\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  /** Which factor earned it. Absent only on a token minted before the claim\n   *  existed, which a method-restricted gate treats as \"not proven\". */\n  method?: StepUpMethod;\n  iat: number;\n  exp: number;\n}\n\n/** Options for {@link requireStepUp}. */\nexport interface RequireStepUpOptions {\n  /** Restrict which factors may earn the step-up (e.g. {@link STRONG_STEP_UP_METHODS}).\n   *  Omitted means any factor the platform will issue a token for. */\n  methods?: readonly StepUpMethod[];\n}\n\n/**\n * Verify a step-up token: a valid ES256 signature from one of platform's\n * published signing keys, issuer and audience when configured, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token is signed by the same\n * key and carries the same `sub`, so without asserting the step-up shape it\n * would bypass the gate. Throws on any failure (an unfetchable key set included:\n * an unverifiable token is not a step-up). Does NOT bind to a caller —\n * `requireStepUp` does the `sub` match and single-use consume.\n *\n * Delegates to `requireAuth`'s own primitive (`verifyUserJwt`) rather than\n * re-implementing it. The hand-rolled copy this replaced dropped TWO of its\n * guards: it never pinned issuer/audience, and its previous-secret retry had no\n * expiry/not-before carve-out, so an EXPIRED token surfaced as a signature error.\n */\nexport async function verifyStepUpToken(token: string): Promise<StepUpTokenPayload> {\n  const payload = await verifyUserJwt<StepUpTokenPayload>(token);\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\ntype JtiRedis = ReadyAwareRedis & { set: (...args: unknown[]) => Promise<unknown> };\nlet _redis: JtiRedis | null | undefined;\nlet _redisReady: (() => Promise<void>) | undefined;\n/**\n * The jti client, built lazily. The env client has no offline queue, so a SET on\n * a connection that isn't up yet is rejected — the FIRST step-up on every pod\n * would fail. Wait (bounded, never rejecting) for readiness before\n * handing it out; a genuinely down Redis still fails closed on the SET below.\n */\nasync function redis(): Promise<JtiRedis | null> {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<JtiRedis>('step-up-jti');\n    _redisReady = _redis ? createRedisReadyGate(_redis) : undefined;\n  }\n  if (_redisReady) await _redisReady();\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Hard ceiling on the process-local jti set.\n *\n * The 30s sweep alone does NOT bound it: entries only leave once their token's\n * TTL has passed, so a burst of step-up traffic (or a flood of distinct forged\n * jtis on a Redis-less deployment) grows the map faster than the sweep drains\n * it. This is a replay guard, so shedding the OLDEST entries is the safe\n * direction: the worst case is that a long-expired jti could be replayed, and\n * expiry is enforced independently by the token's own `exp`.\n */\nconst MEM_JTI_MAX = 10_000;\n\n/** Drop the soonest-to-expire entries until the map is under the ceiling. */\nfunction evictOldestJti(): void {\n  if (memJti.size < MEM_JTI_MAX) return;\n  const byExpiry = [...memJti.entries()].sort((a, b) => a[1] - b[1]);\n  const excess = memJti.size - MEM_JTI_MAX + 1;\n  for (let i = 0; i < excess; i += 1) memJti.delete(byExpiry[i][0]);\n}\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = await redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  evictOldestJti();\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n *\n * Use directly (`router.post('/x', requireAuth, requireStepUp, h)`) for the\n * ordinary any-factor gate, or call it with `{ methods }` to demand that the\n * confirmation was earned by a specific factor — `requireStepUp({ methods:\n * STRONG_STEP_UP_METHODS })` on the routes where a password re-prompt is not a\n * meaningful second proof.\n */\nexport function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void>;\nexport function requireStepUp(options: RequireStepUpOptions): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireStepUp(\n  reqOrOptions: Request | RequireStepUpOptions,\n  res?: Response,\n  next?: NextFunction,\n): Promise<void> | ((req: Request, res: Response, next: NextFunction) => void) {\n  // The direct form RETURNS the promise (Express ignores it; a test awaits it),\n  // so composing the gate as `router.post('/x', requireStepUp, h)` behaves\n  // exactly as it did before the options form existed.\n  if (res && next && 'headers' in reqOrOptions) {\n    return _requireStepUp({}, reqOrOptions as Request, res, next);\n  }\n  const options = reqOrOptions as RequireStepUpOptions;\n  return tagRouteGate(\n    (reqInner: Request, resInner: Response, nextInner: NextFunction) => {\n      void _requireStepUp(options, reqInner, resInner, nextInner);\n    },\n    { kind: 'stepUp', ...(options.methods ? { methods: [...options.methods] } : {}) },\n  );\n}\ntagRouteGate(requireStepUp, { kind: 'stepUp' });\n\nasync function _requireStepUp(options: RequireStepUpOptions, req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with a SERVICE's own ES256 key,\n  // which no external client holds, so this can't be spoofed to skip\n  // step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  // An ORG SERVICE ACCOUNT is the opposite case: it is subject to every gate a\n  // member is, and there is no person behind it to re-verify — so it can NEVER\n  // pass step-up. Refuse explicitly (rather than letting it fall through to the\n  // `sub`-bound token check, which would fail with a confusing STEP_UP_MISMATCH)\n  // so \"a machine credential never satisfies an assurance requirement\" is a\n  // property of this gate, not a side effect of how step-up tokens are minted.\n  if (isServiceAccountPrincipal(req)) {\n    sendError(res, 403, 'A service account cannot perform this action — it requires a person to re-verify', 'STEP_UP_NOT_AVAILABLE');\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = await verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  // Factor restriction. Checked BEFORE the jti is consumed, so a token\n  // earned by the wrong factor can still be spent on a route that accepts it —\n  // burning it here would make the refusal destructive as well as confusing.\n  if (options.methods && !(payload.method && options.methods.includes(payload.method))) {\n    sendError(\n      res, 401,\n      'This action must be confirmed with a passkey or an authenticator code',\n      'STEP_UP_METHOD_REQUIRED',\n      { methods: [...options.methods] },\n    );\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user;\n * platform mints a short-lived (60s) `step-up` JWT with the SAME ES256 signing\n * key it mints access tokens with, so these services verify it through the same\n * JWKS. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, so the verify + single-use jti live in api-core where any\n * service can require them.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { verifyUserJwt } from './jwt-verify.js';\nimport { recordAuthzDenial } from './permission-gates.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceAccountPrincipal, isServicePrincipal } from './service-tokens.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/**\n * How a step-up token was earned. Mirrors platform's `StepUpMethod`; kept here\n * as its own union so a verifier can name the factors it accepts without\n * importing platform.\n */\nexport type StepUpMethod = 'password' | 'webauthn' | 'totp' | 'reauth';\n\n/**\n * The factors that count as a SECOND FACTOR, for routes that may only be\n * unlocked by one (#8: impersonation, KMS, IdP settings, platform admin).\n *\n * A password or a provider re-auth proves the same single factor the session was\n * already opened with, so on those routes they are not enough: the point is that\n * someone holding only a stolen session — or only a stolen password — cannot\n * proceed.\n */\nexport const STRONG_STEP_UP_METHODS: readonly StepUpMethod[] = ['webauthn', 'totp'];\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  /** Which factor earned it. Absent only on a token minted before the claim\n   *  existed, which a method-restricted gate treats as \"not proven\". */\n  method?: StepUpMethod;\n  iat: number;\n  exp: number;\n}\n\n/** Options for {@link requireStepUp}. */\nexport interface RequireStepUpOptions {\n  /** Restrict which factors may earn the step-up (e.g. {@link STRONG_STEP_UP_METHODS}).\n   *  Omitted means any factor the platform will issue a token for. */\n  methods?: readonly StepUpMethod[];\n}\n\n/**\n * Verify a step-up token: a valid ES256 signature from one of platform's\n * published signing keys, issuer and audience when configured, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token is signed by the same\n * key and carries the same `sub`, so without asserting the step-up shape it\n * would bypass the gate. Throws on any failure (an unfetchable key set included:\n * an unverifiable token is not a step-up). Does NOT bind to a caller —\n * `requireStepUp` does the `sub` match and single-use consume.\n *\n * Delegates to `requireAuth`'s own primitive (`verifyUserJwt`) rather than\n * re-implementing it. The hand-rolled copy this replaced dropped TWO of its\n * guards: it never pinned issuer/audience, and its previous-secret retry had no\n * expiry/not-before carve-out, so an EXPIRED token surfaced as a signature error.\n */\nexport async function verifyStepUpToken(token: string): Promise<StepUpTokenPayload> {\n  const payload = await verifyUserJwt<StepUpTokenPayload>(token);\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\ntype JtiRedis = ReadyAwareRedis & { set: (...args: unknown[]) => Promise<unknown> };\nlet _redis: JtiRedis | null | undefined;\nlet _redisReady: (() => Promise<void>) | undefined;\n/**\n * The jti client, built lazily. The env client has no offline queue, so a SET on\n * a connection that isn't up yet is rejected — the FIRST step-up on every pod\n * would fail. Wait (bounded, never rejecting) for readiness before\n * handing it out; a genuinely down Redis still fails closed on the SET below.\n */\nasync function redis(): Promise<JtiRedis | null> {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<JtiRedis>('step-up-jti');\n    _redisReady = _redis ? createRedisReadyGate(_redis) : undefined;\n  }\n  if (_redisReady) await _redisReady();\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Hard ceiling on the process-local jti set.\n *\n * The 30s sweep alone does NOT bound it: entries only leave once their token's\n * TTL has passed, so a burst of step-up traffic (or a flood of distinct forged\n * jtis on a Redis-less deployment) grows the map faster than the sweep drains\n * it. This is a replay guard, so shedding the OLDEST entries is the safe\n * direction: the worst case is that a long-expired jti could be replayed, and\n * expiry is enforced independently by the token's own `exp`.\n */\nconst MEM_JTI_MAX = 10_000;\n\n/** Drop the soonest-to-expire entries until the map is under the ceiling. */\nfunction evictOldestJti(): void {\n  if (memJti.size < MEM_JTI_MAX) return;\n  const byExpiry = [...memJti.entries()].sort((a, b) => a[1] - b[1]);\n  const excess = memJti.size - MEM_JTI_MAX + 1;\n  for (let i = 0; i < excess; i += 1) memJti.delete(byExpiry[i][0]);\n}\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = await redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  evictOldestJti();\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n *\n * Use directly (`router.post('/x', requireAuth, requireStepUp, h)`) for the\n * ordinary any-factor gate, or call it with `{ methods }` to demand that the\n * confirmation was earned by a specific factor — `requireStepUp({ methods:\n * STRONG_STEP_UP_METHODS })` on the routes where a password re-prompt is not a\n * meaningful second proof.\n */\nexport function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void>;\nexport function requireStepUp(options: RequireStepUpOptions): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireStepUp(\n  reqOrOptions: Request | RequireStepUpOptions,\n  res?: Response,\n  next?: NextFunction,\n): Promise<void> | ((req: Request, res: Response, next: NextFunction) => void) {\n  // The direct form RETURNS the promise (Express ignores it; a test awaits it),\n  // so composing the gate as `router.post('/x', requireStepUp, h)` behaves\n  // exactly as it did before the options form existed.\n  if (res && next && 'headers' in reqOrOptions) {\n    return _requireStepUp({}, reqOrOptions as Request, res, next);\n  }\n  const options = reqOrOptions as RequireStepUpOptions;\n  return tagRouteGate(\n    (reqInner: Request, resInner: Response, nextInner: NextFunction) => {\n      void _requireStepUp(options, reqInner, resInner, nextInner);\n    },\n    { kind: 'stepUp', ...(options.methods ? { methods: [...options.methods] } : {}) },\n  );\n}\ntagRouteGate(requireStepUp, { kind: 'stepUp' });\n\nasync function _requireStepUp(options: RequireStepUpOptions, req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with a SERVICE's own ES256 key,\n  // which no external client holds, so this can't be spoofed to skip\n  // step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  // An ORG SERVICE ACCOUNT is the opposite case: it is subject to every gate a\n  // member is, and there is no person behind it to re-verify — so it can NEVER\n  // pass step-up. Refuse explicitly (rather than letting it fall through to the\n  // `sub`-bound token check, which would fail with a confusing STEP_UP_MISMATCH)\n  // so \"a machine credential never satisfies an assurance requirement\" is a\n  // property of this gate, not a side effect of how step-up tokens are minted.\n  if (isServiceAccountPrincipal(req)) {\n    recordAuthzDenial(req, 'step-up (STEP_UP_NOT_AVAILABLE: service account)');\n    sendError(res, 403, 'A service account cannot perform this action — it requires a person to re-verify', 'STEP_UP_NOT_AVAILABLE');\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = await verifyStepUpToken(token);\n  } catch {\n    // A presented-but-unverifiable token (forged, expired, wrong key) is on the\n    // trail; a MISSING one (STEP_UP_REQUIRED above) is the UI's normal first\n    // attempt and is not.\n    recordAuthzDenial(req, 'step-up (STEP_UP_INVALID)');\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    // Someone else's step-up token replayed on this session — never a UI bug.\n    recordAuthzDenial(req, 'step-up (STEP_UP_MISMATCH)');\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  // Factor restriction. Checked BEFORE the jti is consumed, so a token\n  // earned by the wrong factor can still be spent on a route that accepts it —\n  // burning it here would make the refusal destructive as well as confusing.\n  if (options.methods && !(payload.method && options.methods.includes(payload.method))) {\n    recordAuthzDenial(req, `step-up (STEP_UP_METHOD_REQUIRED: ${options.methods.join(' or ')}, got ${payload.method ?? 'none'})`);\n    sendError(\n      res, 401,\n      'This action must be confirmed with a passkey or an authenticator code',\n      'STEP_UP_METHOD_REQUIRED',\n      { methods: [...options.methods] },\n    );\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      recordAuthzDenial(req, 'step-up (STEP_UP_REPLAY)');\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}

package/lib/services/ai-call-weight.d.ts

@@ -0,0 +1,24 @@
+/** Largest weight one model may carry — one call can never reserve more than this many units. */
+export declare const MAX_AI_CALL_WEIGHT = 100;
+/**
+ * Parse `AI_MODEL_WEIGHTS` — a JSON object of `key → integer weight` — into
+ * lower-cased entries. A malformed value is IGNORED (logged), never fatal: the
+ * weights are an optional pricing lever and every call still meters at 1.
+ */
+export declare function parseAiModelWeights(raw: string | undefined): Record<string, number>;
+/**
+ * How many `aiCalls` units one call on `{ provider, modelId }` reserves.
+ *
+ * MODEL-CLASS WEIGHTING is OFF by default: with `AI_MODEL_WEIGHTS` unset every
+ * model weighs 1 — except the self-hosted provider, which weighs 0 (see
+ * {@link BUILT_IN_WEIGHTS}). Matching, first hit wins:
+ *  1. a key equal to the PROVIDER id (`"openai-compatible": 0`, `"bedrock": 2`);
+ *  2. the LONGEST key contained in the model id (`"opus": 3` matches
+ *     `claude-opus-4-1`; `"sonnet": 1`, `"haiku": 1`).
+ * No match → 1. A weight of 0 means the call reserves nothing (it is still
+ * recorded in the usage ledger with its tokens).
+ */
+export declare function aiCallWeight(selection: {
+    provider: string;
+    modelId: string;
+}): number;