@pipeline-builder/api-core 4.1.2 → 4.1.4

package/lib/middleware/index.d.ts

@@ -1,3 +1,4 @@
 export * from './auth.js';
 export * from './mongo-sanitize.js';
 export * from './step-up.js';
+export * from './route-table.js';

package/lib/middleware/index.js

@@ -3,4 +3,5 @@
 export * from './auth.js';
 export * from './mongo-sanitize.js';
 export * from './step-up.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9hdXRoLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbW9uZ28tc2FuaXRpemUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGVwLXVwLmpzJztcbiJdfQ==
+export * from './route-table.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2F1dGguanMnO1xuZXhwb3J0ICogZnJvbSAnLi9tb25nby1zYW5pdGl6ZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3N0ZXAtdXAuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yb3V0ZS10YWJsZS5qcyc7XG4iXX0=

package/lib/middleware/route-table.d.ts

@@ -0,0 +1,104 @@
+import type { Permission } from '../types/permissions.js';
+/** One requirement a gate middleware enforces. */
+export type RouteGate = {
+    kind: 'auth';
+} | {
+    kind: 'permission';
+    mode: 'any' | 'all';
+    permissions: readonly Permission[];
+    allowService?: boolean;
+} | {
+    kind: 'systemAdmin';
+} | {
+    kind: 'servicePrincipal';
+}
+/** An INTERNAL route: user tokens refused outright, only these services admitted. */
+ | {
+    kind: 'internalService';
+    callers: readonly string[];
+} | {
+    kind: 'stepUp';
+    methods?: readonly string[];
+}
+/** The whole SESSION must be MFA-grade (`requireAuth({ minAssurance })`), and
+ *  optionally no older than `maxAge` seconds. */
+ | {
+    kind: 'assurance';
+    minAssurance: 1 | 2;
+    maxAge?: number;
+} | {
+    kind: 'feature';
+    feature: string;
+} | {
+    kind: 'scope';
+    scope: string;
+} | {
+    kind: 'audit';
+    actions: readonly string[];
+};
+/**
+ * Attach gate metadata to a middleware function (appends to any existing tags)
+ * and return the same function. Use it for a service-local gate so the route
+ * table knows what it enforces — e.g. a handler-level `requireComplianceWrite`
+ * tagged `{ kind: 'permission', mode: 'any', permissions: ['compliance:write'] }`.
+ */
+export declare function tagRouteGate<T extends object>(fn: T, ...gates: RouteGate[]): T;
+/** The gate metadata attached to a middleware function (empty when untagged). */
+export declare function getRouteGates(fn: unknown): readonly RouteGate[];
+/**
+ * Declare the audit action(s) a route emits. A no-op middleware whose only job
+ * is to put the action on the route table, so the coverage test can require an
+ * audit declaration on every write route. Place it in the route's chain:
+ * `router.post('/', audited('pipeline.create'), handler)`. The handler still
+ * emits the event itself.
+ */
+export declare function audited(...actions: string[]): (req: unknown, res: unknown, next: () => void) => void;
+/** Resolved requirements for one method + path. */
+export interface RouteTableEntry {
+    method: string;
+    path: string;
+    /** Authentication runs before the handler (requireAuth). */
+    auth: boolean;
+    /** Each permission gate in the chain (all must pass; each is any-of or all-of). */
+    permissions: Array<{
+        mode: 'any' | 'all';
+        permissions: Permission[];
+        allowService: boolean;
+    }>;
+    systemAdmin: boolean;
+    servicePrincipal: boolean;
+    /**
+     * The services allowed to call this route when it is INTERNAL (`requireInternalService`).
+     * An empty array means the route is not internal — a user token may reach it,
+     * subject to the other gates. Sorted, so the generated table is stable.
+     */
+    internalCallers: string[];
+    stepUp: boolean;
+    /** When the step-up gate names the factors that may earn it (`['webauthn',
+     *  'totp']` on the most dangerous routes), the allowed methods. Empty means
+     *  any factor satisfies it. Sorted, so the generated table is stable. */
+    stepUpMethods: string[];
+    /** Highest `minAssurance` any gate in the chain demands; 0 when none does. */
+    minAssurance: 0 | 1 | 2;
+    /** Tightest `maxAge` (seconds) any assurance gate in the chain demands. */
+    maxAge?: number;
+    features: string[];
+    scopes: string[];
+    audit: string[];
+}
+/**
+ * Build the route table of an assembled Express app (or router): one entry per
+ * reachable method + path with every gate that runs before its handler.
+ * HEAD is folded into GET, as Express does.
+ */
+export declare function buildRouteTable(app: unknown): RouteTableEntry[];
+/** Whether a method mutates state (everything except GET/HEAD/OPTIONS). */
+export declare function isWriteMethod(method: string): boolean;
+/** Summary counts for a startup log line. */
+export declare function summarizeRouteTable(table: readonly RouteTableEntry[]): {
+    routes: number;
+    writes: number;
+    ungated: number;
+    unaudited: number;
+    internal: number;
+};

package/lib/middleware/route-table.js

@@ -0,0 +1,230 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Introspectable route table.
+ *
+ * Authorization is split between router mounts (`app.use('/x', gate, router)`)
+ * and individual routes, so grepping source can't prove that every route is
+ * gated. Instead, every gate middleware in this package carries METADATA (what it
+ * requires), and {@link buildRouteTable} walks an assembled Express app and
+ * resolves, per method + path, the full chain of gates Express would run before
+ * the handler: permissions, system-admin, service principal, step-up, feature,
+ * token scope, and the audit actions the route declares via {@link audited}.
+ *
+ * Express 5 (router@2) does not keep a mount's path string on its layer, so this
+ * module records it: on import it wraps `Router.prototype.use` to stamp each new
+ * layer with the path it was mounted at. api-core is imported before any route
+ * module registers a route, so every layer an app builds is stamped. The wrap
+ * only adds a symbol property; routing behaviour is unchanged.
+ */
+import express from 'express';
+// 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');
+const LAYER_PATH = Symbol.for('pipeline-builder.layer-path');
+const RECORDER_INSTALLED = Symbol.for('pipeline-builder.route-recorder');
+/**
+ * Attach gate metadata to a middleware function (appends to any existing tags)
+ * and return the same function. Use it for a service-local gate so the route
+ * table knows what it enforces — e.g. a handler-level `requireComplianceWrite`
+ * tagged `{ kind: 'permission', mode: 'any', permissions: ['compliance:write'] }`.
+ */
+export function tagRouteGate(fn, ...gates) {
+    const t = fn;
+    Object.defineProperty(t, GATES, { value: [...(t[GATES] ?? []), ...gates], configurable: true, enumerable: false, writable: true });
+    return fn;
+}
+/** The gate metadata attached to a middleware function (empty when untagged). */
+export function getRouteGates(fn) {
+    if (typeof fn !== 'function')
+        return [];
+    return fn[GATES] ?? [];
+}
+/**
+ * Declare the audit action(s) a route emits. A no-op middleware whose only job
+ * is to put the action on the route table, so the coverage test can require an
+ * audit declaration on every write route. Place it in the route's chain:
+ * `router.post('/', audited('pipeline.create'), handler)`. The handler still
+ * emits the event itself.
+ */
+export function audited(...actions) {
+    return tagRouteGate(function auditedRoute(_req, _res, next) { next(); }, { kind: 'audit', actions });
+}
+function installRouteRecorder() {
+    const proto = express.Router.prototype;
+    if (proto[RECORDER_INSTALLED])
+        return;
+    const originalUse = proto.use;
+    proto.use = function recordingUse(...args) {
+        const before = this.stack.length;
+        const result = originalUse.apply(this, args);
+        // Same path disambiguation as router@2's `use`: a leading non-function
+        // (possibly nested in arrays) is the path; otherwise the mount is '/'.
+        let first = args[0];
+        while (Array.isArray(first) && first.length > 0)
+            first = first[0];
+        const path = typeof first === 'function' ? '/' : String(args[0]);
+        for (let i = before; i < this.stack.length; i++) {
+            Object.defineProperty(this.stack[i], LAYER_PATH, { value: path, enumerable: false, configurable: true });
+        }
+        return result;
+    };
+    Object.defineProperty(proto, RECORDER_INSTALLED, { value: true, enumerable: false });
+}
+installRouteRecorder();
+function joinPath(prefix, path) {
+    const joined = `${prefix.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+    return joined.length > 1 ? joined.replace(/\/+$/, '') : '/';
+}
+function isRouter(handle) {
+    return typeof handle === 'function' && Array.isArray(handle.stack);
+}
+/**
+ * Whether a middleware layer (mounted under `prefix`) runs for `fullPath`.
+ * Mirrors `Layer.prototype.match`, including its fast path: a layer added with
+ * no path (`router.use(gate)`) matches EVERY path under its router — which is
+ * exactly how the shared `requirePermission` gates between two `router.use(...)`
+ * mounts reach the routers registered after them.
+ */
+function applies(c, fullPath) {
+    const base = c.prefix === '/' ? '' : c.prefix;
+    if (base && fullPath !== base && !fullPath.startsWith(`${base}/`))
+        return false;
+    if (c.layer.slash)
+        return true;
+    const rel = fullPath.slice(base.length) || '/';
+    return c.layer.matchers.some((m) => m(rel) !== false);
+}
+function collectGates(fns) {
+    return fns.flatMap((fn) => getRouteGates(fn));
+}
+function toEntry(method, path, gates) {
+    const entry = {
+        method,
+        path,
+        auth: false,
+        permissions: [],
+        systemAdmin: false,
+        servicePrincipal: false,
+        internalCallers: [],
+        stepUp: false,
+        stepUpMethods: [],
+        minAssurance: 0,
+        features: [],
+        scopes: [],
+        audit: [],
+    };
+    for (const g of gates) {
+        switch (g.kind) {
+            case 'auth':
+                entry.auth = true;
+                break;
+            case 'permission':
+                entry.permissions.push({ mode: g.mode, permissions: [...g.permissions], allowService: g.allowService === true });
+                break;
+            case 'systemAdmin':
+                entry.systemAdmin = true;
+                break;
+            case 'servicePrincipal':
+                entry.servicePrincipal = true;
+                break;
+            case 'internalService':
+                for (const c of g.callers)
+                    if (!entry.internalCallers.includes(c))
+                        entry.internalCallers.push(c);
+                break;
+            case 'stepUp':
+                entry.stepUp = true;
+                for (const m of g.methods ?? [])
+                    if (!entry.stepUpMethods.includes(m))
+                        entry.stepUpMethods.push(m);
+                break;
+            case 'assurance':
+                // Several gates may apply; the STRICTEST wins, since every one of them runs.
+                if (g.minAssurance > entry.minAssurance)
+                    entry.minAssurance = g.minAssurance;
+                if (g.maxAge !== undefined)
+                    entry.maxAge = entry.maxAge === undefined ? g.maxAge : Math.min(entry.maxAge, g.maxAge);
+                break;
+            case 'feature':
+                if (!entry.features.includes(g.feature))
+                    entry.features.push(g.feature);
+                break;
+            case 'scope':
+                if (!entry.scopes.includes(g.scope))
+                    entry.scopes.push(g.scope);
+                break;
+            case 'audit':
+                for (const a of g.actions)
+                    if (!entry.audit.includes(a))
+                        entry.audit.push(a);
+                break;
+        }
+    }
+    entry.internalCallers.sort();
+    entry.stepUpMethods.sort();
+    return entry;
+}
+function walk(stack, prefix, inherited, out, seen) {
+    const local = [];
+    for (const layer of stack) {
+        if (layer.route) {
+            const paths = Array.isArray(layer.route.path) ? layer.route.path : [layer.route.path];
+            const methods = Object.keys(layer.route.methods).map((m) => (m === '_all' ? '*' : m.toUpperCase()));
+            for (const routePath of paths) {
+                const full = joinPath(prefix, String(routePath));
+                const chain = [...inherited, ...local].filter((c) => applies(c, full)).map((c) => c.layer.handle);
+                for (const method of methods) {
+                    const key = `${method} ${full}`;
+                    // First registration wins, as in Express: a later duplicate is unreachable.
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    const routeFns = layer.route.stack
+                        .filter((l) => l.method === undefined || l.method.toUpperCase() === method || method === '*')
+                        .map((l) => l.handle);
+                    out.push(toEntry(method, full, collectGates([...chain, ...routeFns])));
+                }
+            }
+        }
+        else if (isRouter(layer.handle)) {
+            const mountPath = joinPath(prefix, layer[LAYER_PATH] ?? '/');
+            // Middleware that runs before this router (ancestors + earlier siblings)
+            // is inherited; applicability is re-checked against each full route path.
+            walk(layer.handle.stack, mountPath, [...inherited, ...local], out, seen);
+        }
+        else {
+            local.push({ layer, prefix });
+        }
+    }
+}
+/**
+ * Build the route table of an assembled Express app (or router): one entry per
+ * reachable method + path with every gate that runs before its handler.
+ * HEAD is folded into GET, as Express does.
+ */
+export function buildRouteTable(app) {
+    const root = app.router ?? app;
+    const out = [];
+    if (!root || !Array.isArray(root.stack))
+        return out;
+    walk(root.stack, '/', [], out, new Set());
+    return out.sort((a, b) => (a.path === b.path ? a.method.localeCompare(b.method) : a.path.localeCompare(b.path)));
+}
+/** Whether a method mutates state (everything except GET/HEAD/OPTIONS). */
+export function isWriteMethod(method) {
+    return !['GET', 'HEAD', 'OPTIONS'].includes(method.toUpperCase());
+}
+/** Summary counts for a startup log line. */
+export function summarizeRouteTable(table) {
+    const gated = (e) => e.permissions.length > 0 || e.systemAdmin || e.servicePrincipal;
+    const writes = table.filter((e) => isWriteMethod(e.method));
+    return {
+        routes: table.length,
+        writes: writes.length,
+        ungated: table.filter((e) => !gated(e)).length,
+        unaudited: writes.filter((e) => e.audit.length === 0).length,
+        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/** 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. */\n  | { kind: 'assurance'; minAssurance: 1 | 2; maxAge?: number }\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  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        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"]}

package/lib/middleware/step-up.d.ts

@@ -2,9 +2,10 @@
  * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the
  * stateless api services, mirroring the platform middleware of the same name.
  *
- * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user's
- * password; platform mints a short-lived (60s) `step-up` JWT signed with the
- * SAME `JWT_SECRET` these services already verify access tokens with. The UI
+ * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user;
+ * platform mints a short-lived (60s) `step-up` JWT with the SAME ES256 signing
+ * key it mints access tokens with, so these services verify it through the same
+ * JWKS. The UI
  * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;
  * this middleware verifies it, binds it to the caller (`sub` match), and
  * consumes its `jti` once (Redis-backed cross-instance when configured, else a
@@ -15,30 +16,54 @@
  * verify + single-use jti into api-core so any service can require it.
  */
 import type { Request, Response, NextFunction } from 'express';
+/**
+ * How a step-up token was earned. Mirrors platform's `StepUpMethod`; kept here
+ * as its own union so a verifier can name the factors it accepts without
+ * importing platform.
+ */
+export type StepUpMethod = 'password' | 'webauthn' | 'totp' | 'reauth';
+/**
+ * The factors that count as a SECOND FACTOR, for routes that may only be
+ * unlocked by one (#8: impersonation, KMS, IdP settings, platform admin).
+ *
+ * A password or a provider re-auth proves the same single factor the session was
+ * already opened with, so on those routes they are not enough: the point is that
+ * someone holding only a stolen session — or only a stolen password — cannot
+ * proceed.
+ */
+export declare const STRONG_STEP_UP_METHODS: readonly StepUpMethod[];
 /** Payload of a platform-issued step-up token (see platform issueStepUpToken). */
 export interface StepUpTokenPayload {
     type: 'step-up';
     sub: string;
     jti: string;
+    /** Which factor earned it. Absent only on a token minted before the claim
+     *  existed, which a method-restricted gate treats as "not proven". */
+    method?: StepUpMethod;
     iat: number;
     exp: number;
 }
+/** Options for {@link requireStepUp}. */
+export interface RequireStepUpOptions {
+    /** Restrict which factors may earn the step-up (e.g. {@link STRONG_STEP_UP_METHODS}).
+     *  Omitted means any factor the platform will issue a token for. */
+    methods?: readonly StepUpMethod[];
+}
 /**
- * Verify a step-up token: valid signature (primary `JWT_SECRET`, or
- * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, issuer and
- * audience when configured, AND the `type: 'step-up'` + `jti` claims — a plain
- * access token shares the secret and `sub`, so without asserting the step-up
- * shape it would bypass the gate. Throws on any failure. Does NOT bind to a
- * caller — `requireStepUp` does the `sub` match and single-use consume.
+ * Verify a step-up token: a valid ES256 signature from one of platform's
+ * published signing keys, issuer and audience when configured, AND the
+ * `type: 'step-up'` + `jti` claims — a plain access token is signed by the same
+ * key and carries the same `sub`, so without asserting the step-up shape it
+ * would bypass the gate. Throws on any failure (an unfetchable key set included:
+ * an unverifiable token is not a step-up). Does NOT bind to a caller —
+ * `requireStepUp` does the `sub` match and single-use consume.
  *
- * Delegates to `requireAuth`'s own primitives rather than re-implementing them.
- * The hand-rolled copy this replaced dropped TWO of their guards: it never
- * pinned issuer/audience (so a step-up token from any other system sharing
- * `JWT_SECRET` was accepted wherever `JWT_ISSUER`/`JWT_AUDIENCE` are set), and
- * its previous-secret retry had no expiry/not-before carve-out, so an EXPIRED
- * token was retried and surfaced as a signature error instead of an expiry one.
+ * Delegates to `requireAuth`'s own primitive (`verifyUserJwt`) rather than
+ * re-implementing it. The hand-rolled copy this replaced dropped TWO of its
+ * guards: it never pinned issuer/audience, and its previous-secret retry had no
+ * expiry/not-before carve-out, so an EXPIRED token surfaced as a signature error.
  */
-export declare function verifyStepUpToken(token: string): StepUpTokenPayload;
+export declare function verifyStepUpToken(token: string): Promise<StepUpTokenPayload>;
 /**
  * Consume a step-up `jti` exactly once. Returns true if this call claimed it
  * (first use), false if it was already consumed (replay). `expEpochSeconds` is
@@ -48,5 +73,12 @@ export declare function consumeStepUpJti(jti: string, expEpochSeconds: number):
 /**
  * Express middleware: require a valid, caller-bound, single-use step-up token in
  * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).
+ *
+ * Use directly (`router.post('/x', requireAuth, requireStepUp, h)`) for the
+ * ordinary any-factor gate, or call it with `{ methods }` to demand that the
+ * confirmation was earned by a specific factor — `requireStepUp({ methods:
+ * STRONG_STEP_UP_METHODS })` on the routes where a password re-prompt is not a
+ * meaningful second proof.
  */
 export declare function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void>;
+export declare function requireStepUp(options: RequireStepUpOptions): (req: Request, res: Response, next: NextFunction) => void;