@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/helpers/support-calendar.js

@@ -0,0 +1,179 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * When a support case's first response is DUE.
+ *
+ * WHY A DEADLINE FUNCTION AND NOT A CLOCK. The targets are stated in business
+ * DAYS ("2 business days", "next business day"), and that choice is what makes
+ * this small. An hours-based target ("48 business hours") would need an
+ * accumulating within-day clock: pause at the end of the working day, resume at
+ * the start of the next, count elapsed working seconds, and decide what a case
+ * opened five minutes before closing is owed. A business-DAY target needs only
+ * one answer — given an open timestamp, what instant is the end of the Nth
+ * following working day — which is a pure function of a calendar.
+ *
+ * WHY THE RESULT IS FROZEN ONTO THE CASE. The caller stores this on
+ * `support_case.response_due_at` at open, exactly as it freezes `level`. Three
+ * things follow, and together they are the reason to do it this way:
+ *
+ *   - a holiday-list or working-week change after a case opens cannot move a
+ *     promise already made to a customer;
+ *   - the staff queue orders by a real deadline with no calendar arithmetic per
+ *     row;
+ *   - the standard/priority breach alert becomes CONTRACTUAL rather than the
+ *     operational "the queue is not being worked" guard it has to be today,
+ *     because a wall-clock quantile cannot express a business-day target at all
+ *     (a priority case raised at 17:01 on a Friday is not late until Monday
+ *     evening, about 79 wall-clock hours later).
+ *
+ * ONE PLATFORM CALENDAR, not the tenant's. With per-tenant timezones the same
+ * case raised at the same instant has a different deadline per customer, and the
+ * staff queue cannot be ordered by "most at risk" without computing per-tenant
+ * business time for every row. One clock, one ordering, one number to defend. A
+ * customer who cannot live with a business calendar at all is the PREMIUM
+ * customer, which is a cleaner upsell than silently running two dozen clocks.
+ */
+import { envInt, envStr } from '../utils/env.js';
+/**
+ * The measure behind each level's published target.
+ *
+ * Premium is `elapsed-hours` on purpose, and that is the whole of its 24×7
+ * claim: its clock does not stop for nights, weekends or holidays, so no
+ * calendar is consulted. It is also why premium is the one level whose target
+ * the wall-clock histogram can check directly.
+ */
+export const SUPPORT_TARGET_MEASURES = {
+    support_standard: { kind: 'business-days', days: 2 },
+    support_priority: { kind: 'business-days', days: 1 },
+    support_premium: { kind: 'elapsed-hours', hours: 8 },
+};
+/** `YYYY-MM-DD` and the weekday of an instant, as seen in `timeZone`. */
+function localParts(at, timeZone) {
+    // `en-CA` yields ISO-ordered date parts, which is the cheapest way to get a
+    // zone-correct YYYY-MM-DD without pulling a date library in.
+    const fmt = new Intl.DateTimeFormat('en-CA', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        hour12: false,
+        weekday: 'short',
+    });
+    const parts = new Map(fmt.formatToParts(at).map((p) => [p.type, p.value]));
+    const weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    return {
+        date: `${parts.get('year')}-${parts.get('month')}-${parts.get('day')}`,
+        weekday: Math.max(0, weekdays.indexOf(parts.get('weekday') ?? '')),
+        // `hour12: false` can render midnight as 24 in some engines.
+        hour: Number(parts.get('hour')) % 24,
+    };
+}
+/** The UTC instant of `hour:00` on local date `ymd` in `timeZone`. */
+function instantAtLocalHour(ymd, hour, timeZone) {
+    // Guess from the naive UTC reading, then correct by the zone's actual offset
+    // at that moment. One correction is enough: the residual error could only
+    // exceed an hour if the offset itself changed between the guess and the
+    // target, which no real zone does.
+    const guess = new Date(`${ymd}T${String(hour).padStart(2, '0')}:00:00Z`);
+    const seen = localParts(guess, timeZone);
+    const seenUtc = Date.parse(`${seen.date}T${String(seen.hour).padStart(2, '0')}:00:00Z`);
+    return new Date(guess.getTime() + (guess.getTime() - seenUtc));
+}
+/** Step one calendar day forward from a `YYYY-MM-DD`. */
+function nextYmd(ymd) {
+    const d = new Date(`${ymd}T12:00:00Z`);
+    d.setUTCDate(d.getUTCDate() + 1);
+    return d.toISOString().slice(0, 10);
+}
+const isWorkingDay = (ymd, weekday, cal) => cal.days.includes(weekday) && !cal.holidays.has(ymd);
+/** The weekday of a `YYYY-MM-DD`, read at local noon so no zone shifts the date. */
+const weekdayOf = (ymd, timeZone) => localParts(new Date(`${ymd}T12:00:00Z`), timeZone).weekday;
+/**
+ * The instant a first response is due, or null for a level with no target.
+ *
+ * For a business-day target: the close of the Nth working day AFTER the one the
+ * case was opened on. A case opened on a Friday with a next-business-day target
+ * is due at Monday's close, not Saturday's — Saturday is not a working day, so
+ * it is not counted. A case opened ON a non-working day starts counting from the
+ * next working day, which is the reading that favours the customer and is the
+ * only one that can be explained in a sentence.
+ *
+ * The day of opening is never itself the deadline, however early the case
+ * arrives. "Next business day" has to mean tomorrow, not "later today" — a case
+ * opened at 09:01 and one opened at 16:59 are owed the same thing, and anything
+ * else turns the target into an hours clock by the back door.
+ */
+export function responseDueAt(openedAt, level, cal = businessCalendar()) {
+    const measure = SUPPORT_TARGET_MEASURES[level];
+    if (!measure)
+        return null;
+    if (measure.kind === 'elapsed-hours') {
+        return new Date(openedAt.getTime() + measure.hours * 3600_000);
+    }
+    // No working days configured at all would otherwise spin forever. Treated as
+    // "no deadline" rather than a throw: a misconfigured calendar must not make
+    // opening a case fail.
+    if (cal.days.length === 0)
+        return null;
+    let ymd = localParts(openedAt, cal.timeZone).date;
+    let counted = 0;
+    // Bounded: 366 steps covers a year, which is far past any holiday list that
+    // is not itself a configuration error.
+    for (let step = 0; step < 366 && counted < measure.days; step += 1) {
+        ymd = nextYmd(ymd);
+        if (isWorkingDay(ymd, weekdayOf(ymd, cal.timeZone), cal))
+            counted += 1;
+    }
+    if (counted < measure.days)
+        return null;
+    return instantAtLocalHour(ymd, cal.endHour, cal.timeZone);
+}
+/** `1,2,3,4,5` → `[1,2,3,4,5]`, ignoring anything that is not a weekday index. */
+function parseDays(raw) {
+    const out = raw.split(',')
+        .map((v) => Number(v.trim()))
+        .filter((v) => Number.isInteger(v) && v >= 0 && v <= 6);
+    return [...new Set(out)].sort((a, b) => a - b);
+}
+/** `2026-12-25,2027-01-01` → a set, ignoring anything not `YYYY-MM-DD`. */
+function parseHolidays(raw) {
+    return new Set(raw.split(',').map((v) => v.trim()).filter((v) => /^\d{4}-\d{2}-\d{2}$/.test(v)));
+}
+/**
+ * The configured calendar.
+ *
+ * `SUPPORT_BUSINESS_HOURS_TZ` takes an **IANA zone**, default
+ * `America/New_York`, and NOT a fixed abbreviation like `EST`. `EST` is
+ * permanently UTC−5, so an `EST` setting would put the desk an hour out for the
+ * eight months of the year that are EDT — the same reason
+ * `ASK_SCHEDULE_TIMEZONE` takes an IANA zone for its cron windows. An
+ * unrecognised zone falls back to UTC rather than throwing, because a bad
+ * timezone must not stop cases being opened; it is validated here so the
+ * fallback is deliberate rather than an exception thrown from `Intl` deep inside
+ * a request.
+ *
+ * Every stored timestamp stays UTC. The zone is applied only to derive a
+ * deadline.
+ *
+ * Holidays are an explicit operator-maintained list rather than a library: a
+ * library pulls both a dependency and a holiday POLICY that cannot be explained
+ * to a customer disputing a deadline.
+ */
+export function businessCalendar() {
+    const configured = envStr('SUPPORT_BUSINESS_HOURS_TZ', 'America/New_York');
+    let timeZone = configured;
+    try {
+        new Intl.DateTimeFormat('en-CA', { timeZone: configured }).format(new Date());
+    }
+    catch {
+        timeZone = 'UTC';
+    }
+    return {
+        timeZone,
+        days: parseDays(envStr('SUPPORT_BUSINESS_HOURS_DAYS', '1,2,3,4,5')),
+        endHour: envInt('SUPPORT_BUSINESS_HOURS_END_HOUR', 17, { min: 0, max: 23 }),
+        holidays: parseHolidays(envStr('SUPPORT_BUSINESS_HOURS_HOLIDAYS', '')),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"support-calendar.js","sourceRoot":"","sources":["../../src/helpers/support-calendar.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * When a support case's first response is DUE.\n *\n * WHY A DEADLINE FUNCTION AND NOT A CLOCK. The targets are stated in business\n * DAYS (\"2 business days\", \"next business day\"), and that choice is what makes\n * this small. An hours-based target (\"48 business hours\") would need an\n * accumulating within-day clock: pause at the end of the working day, resume at\n * the start of the next, count elapsed working seconds, and decide what a case\n * opened five minutes before closing is owed. A business-DAY target needs only\n * one answer — given an open timestamp, what instant is the end of the Nth\n * following working day — which is a pure function of a calendar.\n *\n * WHY THE RESULT IS FROZEN ONTO THE CASE. The caller stores this on\n * `support_case.response_due_at` at open, exactly as it freezes `level`. Three\n * things follow, and together they are the reason to do it this way:\n *\n *   - a holiday-list or working-week change after a case opens cannot move a\n *     promise already made to a customer;\n *   - the staff queue orders by a real deadline with no calendar arithmetic per\n *     row;\n *   - the standard/priority breach alert becomes CONTRACTUAL rather than the\n *     operational \"the queue is not being worked\" guard it has to be today,\n *     because a wall-clock quantile cannot express a business-day target at all\n *     (a priority case raised at 17:01 on a Friday is not late until Monday\n *     evening, about 79 wall-clock hours later).\n *\n * ONE PLATFORM CALENDAR, not the tenant's. With per-tenant timezones the same\n * case raised at the same instant has a different deadline per customer, and the\n * staff queue cannot be ordered by \"most at risk\" without computing per-tenant\n * business time for every row. One clock, one ordering, one number to defend. A\n * customer who cannot live with a business calendar at all is the PREMIUM\n * customer, which is a cleaner upsell than silently running two dozen clocks.\n */\n\nimport { envInt, envStr } from '../utils/env.js';\n\n/** How a level's target is measured. */\nexport type SupportTargetKind =\n  /** N working days, ending at the close of the Nth. */\n  | { kind: 'business-days'; days: number }\n  /** N hours of wall clock, with no calendar applied at all. */\n  | { kind: 'elapsed-hours'; hours: number };\n\n/**\n * The measure behind each level's published target.\n *\n * Premium is `elapsed-hours` on purpose, and that is the whole of its 24×7\n * claim: its clock does not stop for nights, weekends or holidays, so no\n * calendar is consulted. It is also why premium is the one level whose target\n * the wall-clock histogram can check directly.\n */\nexport const SUPPORT_TARGET_MEASURES: Readonly<Record<string, SupportTargetKind>> = {\n  support_standard: { kind: 'business-days', days: 2 },\n  support_priority: { kind: 'business-days', days: 1 },\n  support_premium: { kind: 'elapsed-hours', hours: 8 },\n};\n\n/** The resolved business calendar. */\nexport interface BusinessCalendar {\n  /** IANA zone. Never a fixed abbreviation — see {@link businessCalendar}. */\n  timeZone: string;\n  /** Working weekdays, 0 = Sunday … 6 = Saturday. */\n  days: readonly number[];\n  /** The hour (0–23) at which a working day CLOSES, in `timeZone`. */\n  endHour: number;\n  /** Non-working dates, `YYYY-MM-DD` in `timeZone`. */\n  holidays: ReadonlySet<string>;\n}\n\n/** `YYYY-MM-DD` and the weekday of an instant, as seen in `timeZone`. */\nfunction localParts(at: Date, timeZone: string): { date: string; weekday: number; hour: number } {\n  // `en-CA` yields ISO-ordered date parts, which is the cheapest way to get a\n  // zone-correct YYYY-MM-DD without pulling a date library in.\n  const fmt = new Intl.DateTimeFormat('en-CA', {\n    timeZone,\n    year: 'numeric',\n    month: '2-digit',\n    day: '2-digit',\n    hour: '2-digit',\n    hour12: false,\n    weekday: 'short',\n  });\n  const parts = new Map(fmt.formatToParts(at).map((p) => [p.type, p.value]));\n  const weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];\n  return {\n    date: `${parts.get('year')}-${parts.get('month')}-${parts.get('day')}`,\n    weekday: Math.max(0, weekdays.indexOf(parts.get('weekday') ?? '')),\n    // `hour12: false` can render midnight as 24 in some engines.\n    hour: Number(parts.get('hour')) % 24,\n  };\n}\n\n/** The UTC instant of `hour:00` on local date `ymd` in `timeZone`. */\nfunction instantAtLocalHour(ymd: string, hour: number, timeZone: string): Date {\n  // Guess from the naive UTC reading, then correct by the zone's actual offset\n  // at that moment. One correction is enough: the residual error could only\n  // exceed an hour if the offset itself changed between the guess and the\n  // target, which no real zone does.\n  const guess = new Date(`${ymd}T${String(hour).padStart(2, '0')}:00:00Z`);\n  const seen = localParts(guess, timeZone);\n  const seenUtc = Date.parse(`${seen.date}T${String(seen.hour).padStart(2, '0')}:00:00Z`);\n  return new Date(guess.getTime() + (guess.getTime() - seenUtc));\n}\n\n/** Step one calendar day forward from a `YYYY-MM-DD`. */\nfunction nextYmd(ymd: string): string {\n  const d = new Date(`${ymd}T12:00:00Z`);\n  d.setUTCDate(d.getUTCDate() + 1);\n  return d.toISOString().slice(0, 10);\n}\n\nconst isWorkingDay = (ymd: string, weekday: number, cal: BusinessCalendar): boolean =>\n  cal.days.includes(weekday) && !cal.holidays.has(ymd);\n\n/** The weekday of a `YYYY-MM-DD`, read at local noon so no zone shifts the date. */\nconst weekdayOf = (ymd: string, timeZone: string): number =>\n  localParts(new Date(`${ymd}T12:00:00Z`), timeZone).weekday;\n\n/**\n * The instant a first response is due, or null for a level with no target.\n *\n * For a business-day target: the close of the Nth working day AFTER the one the\n * case was opened on. A case opened on a Friday with a next-business-day target\n * is due at Monday's close, not Saturday's — Saturday is not a working day, so\n * it is not counted. A case opened ON a non-working day starts counting from the\n * next working day, which is the reading that favours the customer and is the\n * only one that can be explained in a sentence.\n *\n * The day of opening is never itself the deadline, however early the case\n * arrives. \"Next business day\" has to mean tomorrow, not \"later today\" — a case\n * opened at 09:01 and one opened at 16:59 are owed the same thing, and anything\n * else turns the target into an hours clock by the back door.\n */\nexport function responseDueAt(\n  openedAt: Date,\n  level: string,\n  cal: BusinessCalendar = businessCalendar(),\n): Date | null {\n  const measure = SUPPORT_TARGET_MEASURES[level];\n  if (!measure) return null;\n  if (measure.kind === 'elapsed-hours') {\n    return new Date(openedAt.getTime() + measure.hours * 3600_000);\n  }\n  // No working days configured at all would otherwise spin forever. Treated as\n  // \"no deadline\" rather than a throw: a misconfigured calendar must not make\n  // opening a case fail.\n  if (cal.days.length === 0) return null;\n\n  let ymd = localParts(openedAt, cal.timeZone).date;\n  let counted = 0;\n  // Bounded: 366 steps covers a year, which is far past any holiday list that\n  // is not itself a configuration error.\n  for (let step = 0; step < 366 && counted < measure.days; step += 1) {\n    ymd = nextYmd(ymd);\n    if (isWorkingDay(ymd, weekdayOf(ymd, cal.timeZone), cal)) counted += 1;\n  }\n  if (counted < measure.days) return null;\n  return instantAtLocalHour(ymd, cal.endHour, cal.timeZone);\n}\n\n/** `1,2,3,4,5` → `[1,2,3,4,5]`, ignoring anything that is not a weekday index. */\nfunction parseDays(raw: string): number[] {\n  const out = raw.split(',')\n    .map((v) => Number(v.trim()))\n    .filter((v) => Number.isInteger(v) && v >= 0 && v <= 6);\n  return [...new Set(out)].sort((a, b) => a - b);\n}\n\n/** `2026-12-25,2027-01-01` → a set, ignoring anything not `YYYY-MM-DD`. */\nfunction parseHolidays(raw: string): Set<string> {\n  return new Set(raw.split(',').map((v) => v.trim()).filter((v) => /^\\d{4}-\\d{2}-\\d{2}$/.test(v)));\n}\n\n/**\n * The configured calendar.\n *\n * `SUPPORT_BUSINESS_HOURS_TZ` takes an **IANA zone**, default\n * `America/New_York`, and NOT a fixed abbreviation like `EST`. `EST` is\n * permanently UTC−5, so an `EST` setting would put the desk an hour out for the\n * eight months of the year that are EDT — the same reason\n * `ASK_SCHEDULE_TIMEZONE` takes an IANA zone for its cron windows. An\n * unrecognised zone falls back to UTC rather than throwing, because a bad\n * timezone must not stop cases being opened; it is validated here so the\n * fallback is deliberate rather than an exception thrown from `Intl` deep inside\n * a request.\n *\n * Every stored timestamp stays UTC. The zone is applied only to derive a\n * deadline.\n *\n * Holidays are an explicit operator-maintained list rather than a library: a\n * library pulls both a dependency and a holiday POLICY that cannot be explained\n * to a customer disputing a deadline.\n */\nexport function businessCalendar(): BusinessCalendar {\n  const configured = envStr('SUPPORT_BUSINESS_HOURS_TZ', 'America/New_York');\n  let timeZone = configured;\n  try {\n    new Intl.DateTimeFormat('en-CA', { timeZone: configured }).format(new Date());\n  } catch {\n    timeZone = 'UTC';\n  }\n  return {\n    timeZone,\n    days: parseDays(envStr('SUPPORT_BUSINESS_HOURS_DAYS', '1,2,3,4,5')),\n    endHour: envInt('SUPPORT_BUSINESS_HOURS_END_HOUR', 17, { min: 0, max: 23 }),\n    holidays: parseHolidays(envStr('SUPPORT_BUSINESS_HOURS_HOLIDAYS', '')),\n  };\n}\n"]}

package/lib/middleware/auth.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import jwt from 'jsonwebtoken';
 import { refuseForAssurance } from './assurance.js';
+import { runDeferredQuotaCheck } from './deferred-quota-check.js';
 import { hasValidIdentityClaims, verifyBearerToken } from './jwt-verify.js';
 import { recordAuthzDenial } from './permission-gates.js';
 import { checkRevocation, isImpersonationWriteBlocked, needsRevocationCheck } from './revocation.js';
@@ -170,11 +171,13 @@ async function verifyAndAttach(options, rawToken, req, res, next) {
             checkRevocation(decoded).then((refusal) => {
                 if (refusal)
                     return sendError(res, HttpStatus.UNAUTHORIZED, refusal, ErrorCode.TOKEN_REVOKED);
-                next();
+                runDeferredQuotaCheck(req, res, next);
             }).catch(next);
             return;
         }
-        next();
+        // The apiCalls check a mount armed (api-server `apiCallsQuota`) runs here,
+        // now that tenancy is JWT-authoritative; a plain next() where none was armed.
+        runDeferredQuotaCheck(req, res, next);
     }
     catch (error) {
         if (error instanceof jwt.TokenExpiredError) {
@@ -196,4 +199,4 @@ async function verifyAndAttach(options, rawToken, req, res, next) {
         return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireAuth`: bearer / access-key authentication, the checks every\n * verified request passes, and the tenant identity it attaches.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { refuseForAssurance } from './assurance.js';\nimport { hasValidIdentityClaims, verifyBearerToken } from './jwt-verify.js';\nimport { recordAuthzDenial } from './permission-gates.js';\nimport { checkRevocation, isImpersonationWriteBlocked, needsRevocationCheck } from './revocation.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { JwksUnavailableError, UnknownKidError } from '../services/jwks-cache.js';\nimport { ServiceKeyError, serviceIdentity } from '../services/service-keys.js';\nimport { type AssuranceLevel } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { HttpRequest } from '../types/http.js';\nimport { isOpaqueApiKey } from '../utils/api-key.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n  /**\n   * Demand that the whole SESSION be at least this assurance level.\n   *\n   * `minAssurance: 2` means the person authenticated with a second factor — a\n   * passkey with user verification, a password plus an authenticator code, or\n   * SSO through an IdP the org marked as enforcing MFA. A weaker token gets\n   * **401 `MFA_REQUIRED`**, which the client answers by sending the person to\n   * enrolment or to a stronger sign-in; refreshing cannot help, because `aal`\n   * lives on the session slot and a refresh never raises it.\n   *\n   * This is the SESSION-level counterpart to {@link requireStepUp}, which stays\n   * a fresh, per-action confirmation. Use both on the most dangerous routes.\n   *\n   * MACHINES NEVER SATISFY IT. A service principal, an org service account and\n   * an exchanged access key all get **403 `HUMAN_SESSION_REQUIRED`** — there is\n   * no person behind them to have presented a factor, so \"assurance\" is not a\n   * question their credential can answer. That is deliberately not a silent\n   * pass-through for internal services: a route that demands MFA is a route a\n   * human is doing something dangerous on.\n   */\n  minAssurance?: AssuranceLevel;\n  /**\n   * With {@link minAssurance}, additionally bound how long ago that sign-in\n   * happened (seconds, compared against the token's `auth_time`). A session that\n   * is MFA-grade but older than this gets **401 `REAUTH_REQUIRED`**. Ignored\n   * without `minAssurance` — \"how recent\" is only meaningful once \"how strong\"\n   * is being asked.\n   */\n  maxAge?: number;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  const gate = tagRouteGate((req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  }, { kind: 'auth' });\n  if (options.minAssurance) {\n    tagRouteGate(gate, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n  }\n  return gate;\n}\ntagRouteGate(requireAuth, { kind: 'auth' });\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  // An OPAQUE ACCESS KEY (`pb_pat_…` / `pb_sa_…`) carries no claims and no\n  // signature, so it cannot be verified here. Trade it at platform for a\n  // short-lived JWT (cached in-process until it expires) and then verify that\n  // JWT on the normal path — services never read a key hash. See\n  // `services/api-key-exchange.ts`.\n  if (isOpaqueApiKey(parts[1])) {\n    void resolveApiKey(options, parts[1], req, res, next);\n    return;\n  }\n\n  // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n  // Express's error middleware — verification itself never rejects (it maps\n  // every failure to a response).\n  void verifyAndAttach(options, parts[1], req, res, next).catch(next);\n}\n\n/**\n * Exchange an opaque key for a JWT, then continue on the normal verification\n * path. A refused key is a 401; an unreachable platform is a 503 (never a pass —\n * an unverifiable credential is not an identity).\n */\nasync function resolveApiKey(\n  options: RequireAuthOptions,\n  key: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  // Loaded LAZILY, on the first key ever presented. A static import would put\n  // the HTTP client (and platform's address) into the import graph of every\n  // module that merely uses `requireAuth`, which both widens the boot graph and\n  // breaks any test that mocks `http-client.js` with a partial module.\n  const { exchangeApiKey, ApiKeyExchangeUnavailableError } = await import('../services/api-key-exchange.js');\n  let token: string;\n  try {\n    token = await exchangeApiKey(key);\n  } catch (error) {\n    if (error instanceof ApiKeyExchangeUnavailableError) {\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Access-key verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid or revoked access key', ErrorCode.TOKEN_INVALID);\n  }\n  await verifyAndAttach(options, token, req, res, next);\n}\n\nasync function verifyAndAttach(\n  options: RequireAuthOptions,\n  rawToken: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  try {\n    // Two chains, one entry point (see `verifyBearerToken`): a user token must\n    // be ES256 signed by platform and verified against its published JWKS; an\n    // internal service token must be ES256 signed by that service's OWN key and\n    // declare itself a service principal. Both pin the algorithm (no\n    // alg-confusion, no `alg:none`) and both apply the optional issuer/audience\n    // binding.\n    const decoded = await verifyBearerToken(rawToken);\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role || !hasValidIdentityClaims(decoded)) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    // Service-token kill-switch: reject a service principal whose service has\n    // been added to the denylist. Otherwise the only way to invalidate a\n    // service's tokens before their (short) TTL is rotating that service's\n    // signing key; this cuts one compromised/rogue service off immediately. O(1) Set lookup, zero cost when the denylist\n    // is empty (the default), so it never taxes the S2S hot path unless armed.\n    if (isServiceTokenDenied(decoded)) {\n      emitCounter('service_token_denied_total', { service: serviceNameOf(decoded) ?? 'unknown' });\n      logger.warn('Rejected denylisted service token', { sub: decoded.sub });\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Service token revoked', ErrorCode.TOKEN_REVOKED);\n    }\n\n    req.user = { ...decoded };\n\n    // READ-ONLY IMPERSONATION. The token names the operator AND says it may only\n    // look: every service refuses a state change under it, not only platform —\n    // a support session that could write to plugin/compliance/billing is not\n    // read-only. Checked before any other gate so no route can forget it.\n    if (isImpersonationWriteBlocked(req.method, decoded)) {\n      if (req.method) recordAuthzDenial(req, 'impersonation-read-only');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Write requests are disabled during read-only impersonation. Stop impersonating to make changes.',\n        ErrorCode.IMPERSONATION_READ_ONLY,\n      );\n    }\n\n    // BOOTSTRAP-ADMIN ENROLMENT SESSION. Such a token exists so\n    // the install's only admin can enrol a factor; it is `aal: 1` and must not\n    // reach anything else. Platform — which owns the exception and knows which\n    // of its own routes `init-platform.sh` calls — allows an explicit few before\n    // this point (see its own `requireAuth`); in EVERY other service the answer\n    // is simply no, so the reach restriction holds without a per-service\n    // allowlist to keep in sync.\n    if (decoded.mfaEnrollmentPending === true) {\n      emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: 'bootstrap_session' });\n      recordAuthzDenial(req, 'mfa-enrolment');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Finish setting up two-factor authentication before using the rest of Pipeline Builder',\n        ErrorCode.MFA_ENROLLMENT_REQUIRED,\n      );\n    }\n\n    // Session-level assurance (`requireAuth({ minAssurance, maxAge })`).\n    if (options.minAssurance\n      && refuseForAssurance({ minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) }, decoded, req, res)) return;\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session invalidation (token-version store + impersonation-session\n    // liveness). No store registered ⇒ only impersonation sessions are checked.\n    if (needsRevocationCheck(decoded)) {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — this `next()` runs in a microtask, outside\n      // the surrounding try/catch. The check itself never rejects.\n      checkRevocation(decoded).then((refusal) => {\n        if (refusal) return sendError(res, HttpStatus.UNAUTHORIZED, refusal, ErrorCode.TOKEN_REVOKED);\n        next();\n      }).catch(next);\n      return;\n    }\n\n    next();\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    // The signing keys couldn't be fetched, so the token's validity is UNKNOWN.\n    // Fail CLOSED with a retryable 503 — never a pass, and never a 401 that\n    // would send a legitimate client off to re-authenticate over our outage.\n    // Same reasoning for the SERVICE chain: no readable key bundle means no way\n    // to tell a peer's token from a forgery, so the request is refused with a\n    // retryable 503 rather than admitted or bounced to re-authenticate.\n    if (error instanceof JwksUnavailableError || error instanceof ServiceKeyError) {\n      logger.warn('Rejecting request: token signing keys unavailable', { error: error.message });\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Token verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n\n    if (error instanceof UnknownKidError || error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireAuth`: bearer / access-key authentication, the checks every\n * verified request passes, and the tenant identity it attaches.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { refuseForAssurance } from './assurance.js';\nimport { runDeferredQuotaCheck } from './deferred-quota-check.js';\nimport { hasValidIdentityClaims, verifyBearerToken } from './jwt-verify.js';\nimport { recordAuthzDenial } from './permission-gates.js';\nimport { checkRevocation, isImpersonationWriteBlocked, needsRevocationCheck } from './revocation.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { JwksUnavailableError, UnknownKidError } from '../services/jwks-cache.js';\nimport { ServiceKeyError, serviceIdentity } from '../services/service-keys.js';\nimport { type AssuranceLevel } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { HttpRequest } from '../types/http.js';\nimport { isOpaqueApiKey } from '../utils/api-key.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n  /**\n   * Demand that the whole SESSION be at least this assurance level.\n   *\n   * `minAssurance: 2` means the person authenticated with a second factor — a\n   * passkey with user verification, a password plus an authenticator code, or\n   * SSO through an IdP the org marked as enforcing MFA. A weaker token gets\n   * **401 `MFA_REQUIRED`**, which the client answers by sending the person to\n   * enrolment or to a stronger sign-in; refreshing cannot help, because `aal`\n   * lives on the session slot and a refresh never raises it.\n   *\n   * This is the SESSION-level counterpart to {@link requireStepUp}, which stays\n   * a fresh, per-action confirmation. Use both on the most dangerous routes.\n   *\n   * MACHINES NEVER SATISFY IT. A service principal, an org service account and\n   * an exchanged access key all get **403 `HUMAN_SESSION_REQUIRED`** — there is\n   * no person behind them to have presented a factor, so \"assurance\" is not a\n   * question their credential can answer. That is deliberately not a silent\n   * pass-through for internal services: a route that demands MFA is a route a\n   * human is doing something dangerous on.\n   */\n  minAssurance?: AssuranceLevel;\n  /**\n   * With {@link minAssurance}, additionally bound how long ago that sign-in\n   * happened (seconds, compared against the token's `auth_time`). A session that\n   * is MFA-grade but older than this gets **401 `REAUTH_REQUIRED`**. Ignored\n   * without `minAssurance` — \"how recent\" is only meaningful once \"how strong\"\n   * is being asked.\n   */\n  maxAge?: number;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  const gate = tagRouteGate((req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  }, { kind: 'auth' });\n  if (options.minAssurance) {\n    tagRouteGate(gate, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n  }\n  return gate;\n}\ntagRouteGate(requireAuth, { kind: 'auth' });\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  // An OPAQUE ACCESS KEY (`pb_pat_…` / `pb_sa_…`) carries no claims and no\n  // signature, so it cannot be verified here. Trade it at platform for a\n  // short-lived JWT (cached in-process until it expires) and then verify that\n  // JWT on the normal path — services never read a key hash. See\n  // `services/api-key-exchange.ts`.\n  if (isOpaqueApiKey(parts[1])) {\n    void resolveApiKey(options, parts[1], req, res, next);\n    return;\n  }\n\n  // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n  // Express's error middleware — verification itself never rejects (it maps\n  // every failure to a response).\n  void verifyAndAttach(options, parts[1], req, res, next).catch(next);\n}\n\n/**\n * Exchange an opaque key for a JWT, then continue on the normal verification\n * path. A refused key is a 401; an unreachable platform is a 503 (never a pass —\n * an unverifiable credential is not an identity).\n */\nasync function resolveApiKey(\n  options: RequireAuthOptions,\n  key: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  // Loaded LAZILY, on the first key ever presented. A static import would put\n  // the HTTP client (and platform's address) into the import graph of every\n  // module that merely uses `requireAuth`, which both widens the boot graph and\n  // breaks any test that mocks `http-client.js` with a partial module.\n  const { exchangeApiKey, ApiKeyExchangeUnavailableError } = await import('../services/api-key-exchange.js');\n  let token: string;\n  try {\n    token = await exchangeApiKey(key);\n  } catch (error) {\n    if (error instanceof ApiKeyExchangeUnavailableError) {\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Access-key verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid or revoked access key', ErrorCode.TOKEN_INVALID);\n  }\n  await verifyAndAttach(options, token, req, res, next);\n}\n\nasync function verifyAndAttach(\n  options: RequireAuthOptions,\n  rawToken: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  try {\n    // Two chains, one entry point (see `verifyBearerToken`): a user token must\n    // be ES256 signed by platform and verified against its published JWKS; an\n    // internal service token must be ES256 signed by that service's OWN key and\n    // declare itself a service principal. Both pin the algorithm (no\n    // alg-confusion, no `alg:none`) and both apply the optional issuer/audience\n    // binding.\n    const decoded = await verifyBearerToken(rawToken);\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role || !hasValidIdentityClaims(decoded)) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    // Service-token kill-switch: reject a service principal whose service has\n    // been added to the denylist. Otherwise the only way to invalidate a\n    // service's tokens before their (short) TTL is rotating that service's\n    // signing key; this cuts one compromised/rogue service off immediately. O(1) Set lookup, zero cost when the denylist\n    // is empty (the default), so it never taxes the S2S hot path unless armed.\n    if (isServiceTokenDenied(decoded)) {\n      emitCounter('service_token_denied_total', { service: serviceNameOf(decoded) ?? 'unknown' });\n      logger.warn('Rejected denylisted service token', { sub: decoded.sub });\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Service token revoked', ErrorCode.TOKEN_REVOKED);\n    }\n\n    req.user = { ...decoded };\n\n    // READ-ONLY IMPERSONATION. The token names the operator AND says it may only\n    // look: every service refuses a state change under it, not only platform —\n    // a support session that could write to plugin/compliance/billing is not\n    // read-only. Checked before any other gate so no route can forget it.\n    if (isImpersonationWriteBlocked(req.method, decoded)) {\n      if (req.method) recordAuthzDenial(req, 'impersonation-read-only');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Write requests are disabled during read-only impersonation. Stop impersonating to make changes.',\n        ErrorCode.IMPERSONATION_READ_ONLY,\n      );\n    }\n\n    // BOOTSTRAP-ADMIN ENROLMENT SESSION. Such a token exists so\n    // the install's only admin can enrol a factor; it is `aal: 1` and must not\n    // reach anything else. Platform — which owns the exception and knows which\n    // of its own routes `init-platform.sh` calls — allows an explicit few before\n    // this point (see its own `requireAuth`); in EVERY other service the answer\n    // is simply no, so the reach restriction holds without a per-service\n    // allowlist to keep in sync.\n    if (decoded.mfaEnrollmentPending === true) {\n      emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: 'bootstrap_session' });\n      recordAuthzDenial(req, 'mfa-enrolment');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Finish setting up two-factor authentication before using the rest of Pipeline Builder',\n        ErrorCode.MFA_ENROLLMENT_REQUIRED,\n      );\n    }\n\n    // Session-level assurance (`requireAuth({ minAssurance, maxAge })`).\n    if (options.minAssurance\n      && refuseForAssurance({ minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) }, decoded, req, res)) return;\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session invalidation (token-version store + impersonation-session\n    // liveness). No store registered ⇒ only impersonation sessions are checked.\n    if (needsRevocationCheck(decoded)) {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — this `next()` runs in a microtask, outside\n      // the surrounding try/catch. The check itself never rejects.\n      checkRevocation(decoded).then((refusal) => {\n        if (refusal) return sendError(res, HttpStatus.UNAUTHORIZED, refusal, ErrorCode.TOKEN_REVOKED);\n        runDeferredQuotaCheck(req, res, next);\n      }).catch(next);\n      return;\n    }\n\n    // The apiCalls check a mount armed (api-server `apiCallsQuota`) runs here,\n    // now that tenancy is JWT-authoritative; a plain next() where none was armed.\n    runDeferredQuotaCheck(req, res, next);\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    // The signing keys couldn't be fetched, so the token's validity is UNKNOWN.\n    // Fail CLOSED with a retryable 503 — never a pass, and never a 401 that\n    // would send a legitimate client off to re-authenticate over our outage.\n    // Same reasoning for the SERVICE chain: no readable key bundle means no way\n    // to tell a peer's token from a forgery, so the request is refused with a\n    // retryable 503 rather than admitted or bounced to re-authenticate.\n    if (error instanceof JwksUnavailableError || error instanceof ServiceKeyError) {\n      logger.warn('Rejecting request: token signing keys unavailable', { error: error.message });\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Token verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n\n    if (error instanceof UnknownKidError || error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n"]}

package/lib/middleware/deferred-quota-check.d.ts

@@ -0,0 +1,5 @@
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+/** Arm `check` to run after this request authenticates. */
+export declare function armDeferredQuotaCheck(res: Response, check: RequestHandler): void;
+/** `requireAuth`'s `next()`: run the armed quota check, if any, then continue. */
+export declare function runDeferredQuotaCheck(req: Request, res: Response, next: NextFunction): void;

package/lib/middleware/deferred-quota-check.js

@@ -0,0 +1,33 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * A quota check armed at MOUNT time and run by `requireAuth` once the caller is
+ * verified.
+ *
+ * Why deferred: the apiCalls meter + check mount ONCE per service, ahead of its
+ * whole user surface (api-server `apiCallsQuota`), but authentication is per
+ * route — routers mix public, user and machine routes under one prefix. At mount
+ * time there is no verified org to check yet, and checking a header-derived or
+ * peeked one would hand a forged token a victim org's usage in the 429 body. So
+ * the mount only ARMS the check here, and `requireAuth` (api-core's, and
+ * platform's own) runs it at its single post-verification choke point, after
+ * the request identity has been re-derived from the JWT. A route that never
+ * authenticates never runs it — there is no org to bill.
+ *
+ * At most once per request: running it empties the slot, so a second
+ * `requireAuth` in the same chain is a plain `next()`.
+ */
+const SLOT = 'deferredQuotaCheck';
+/** Arm `check` to run after this request authenticates. */
+export function armDeferredQuotaCheck(res, check) {
+    res.locals[SLOT] = check;
+}
+/** `requireAuth`'s `next()`: run the armed quota check, if any, then continue. */
+export function runDeferredQuotaCheck(req, res, next) {
+    const check = res.locals?.[SLOT];
+    if (!check)
+        return next();
+    delete res.locals[SLOT];
+    void check(req, res, next);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/middleware/ecosystem-guard.d.ts

@@ -3,7 +3,7 @@
  *
  * Only the system org manages or approves the ecosystem. A route that exercises
  * a system-org-only permission (`plugins:moderate`, `publishers:verify`) must
- * therefore check three things, and {@link requireEcosystemPermission} composes
+ * therefore check three things, and {@link requireSystemOrgPermission} composes
  * them so no route can forget one:
  *
  *  1. {@link requireSystemOrg} — the caller's ACTIVE org is the system org. A
@@ -36,7 +36,7 @@ export declare const requireSystemOrg: (req: Request, res: Response, next: NextF
  * as an array, which Express flattens:
  *
  * ```ts
- * router.post('/requests/:id/approve', requireAuth, requireEcosystemPermission('plugins:moderate'),
+ * router.post('/requests/:id/approve', requireAuth, requireSystemOrgPermission('plugins:moderate'),
  *   requireStepUp, audited('plugin.request.approve'), handler);
  * ```
  *
@@ -44,4 +44,4 @@ export declare const requireSystemOrg: (req: Request, res: Response, next: NextF
  * system-org-only — a tenant permission behind this gate would be unreachable
  * for every tenant, which is always a wiring mistake.
  */
-export declare function requireEcosystemPermission(...permissions: Permission[]): RequestHandler[];
+export declare function requireSystemOrgPermission(...permissions: Permission[]): RequestHandler[];

package/lib/middleware/ecosystem-guard.js

@@ -36,7 +36,7 @@ export const requireSystemOrg = tagRouteGate(function requireSystemOrg(req, res,
  * as an array, which Express flattens:
  *
  * ```ts
- * router.post('/requests/:id/approve', requireAuth, requireEcosystemPermission('plugins:moderate'),
+ * router.post('/requests/:id/approve', requireAuth, requireSystemOrgPermission('plugins:moderate'),
  *   requireStepUp, audited('plugin.request.approve'), handler);
  * ```
  *
@@ -44,12 +44,12 @@ export const requireSystemOrg = tagRouteGate(function requireSystemOrg(req, res,
  * system-org-only — a tenant permission behind this gate would be unreachable
  * for every tenant, which is always a wiring mistake.
  */
-export function requireEcosystemPermission(...permissions) {
+export function requireSystemOrgPermission(...permissions) {
     if (permissions.length === 0)
-        throw new Error('requireEcosystemPermission needs at least one permission');
+        throw new Error('requireSystemOrgPermission needs at least one permission');
     const tenant = permissions.filter((p) => !isSystemOrgOnlyPermission(p));
     if (tenant.length > 0) {
-        throw new Error(`requireEcosystemPermission only takes system-org-only permissions; got ${tenant.join(', ')}`);
+        throw new Error(`requireSystemOrgPermission only takes system-org-only permissions; got ${tenant.join(', ')}`);
     }
     return [
         requireSystemOrg,
@@ -57,4 +57,4 @@ export function requireEcosystemPermission(...permissions) {
         requireAssurance({ minAssurance: 2 }),
     ];
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecosystem-guard.js","sourceRoot":"","sources":["../../src/middleware/ecosystem-guard.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAwBtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAmB,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD;+EAC+E;AAC/E,MAAM,UAAU,kBAAkB,CAAC,GAAY;IAC7C,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;AACjD,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,YAAY,CAAC,SAAS,gBAAgB,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB;IACpH,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;IACpG,CAAC;IACD,IAAI,kBAAkB,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,EAAE,CAAC;IAC3C,WAAW,CAAC,gCAAgC,EAAE,EAAE,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,aAAa,IAAI,SAAS,EAAE,CAAC,CAAC;IAClG,iBAAiB,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;IACrC,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,mGAAmG,EACnG,SAAS,CAAC,mBAAmB,CAC9B,CAAC;AACJ,CAAC,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAG,WAAyB;IACrE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;IAC1G,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,0EAA0E,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjH,CAAC;IACD,OAAO;QACL,gBAAgB;QAChB,iBAAiB,CAAC,GAAG,WAAW,CAAC;QACjC,gBAAgB,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;KAClB,CAAC;AACxB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The plugin-ecosystem governance gate (docs/runbooks/ecosystem-moderation.md).\n *\n * Only the system org manages or approves the ecosystem. A route that exercises\n * a system-org-only permission (`plugins:moderate`, `publishers:verify`) must\n * therefore check three things, and {@link requireEcosystemPermission} composes\n * them so no route can forget one:\n *\n *  1. {@link requireSystemOrg} — the caller's ACTIVE org is the system org. A\n *     token minted in a tenant org is refused even for the same person (and even\n *     for a superadmin: they switch to the system org to act on the ecosystem,\n *     so every governance decision is recorded with the system org's id).\n *  2. the permission itself (`requirePermission`, any-of);\n *  3. an MFA-grade session (`requireAssurance({ minAssurance: 2 })`), which also\n *     refuses every machine credential.\n *\n * The route-coverage governance check (`findSystemOrgGuardViolations` in\n * `testing/route-coverage.ts`) fails any route that gates on a system-org-only\n * permission without 1 and 3, so a hand-rolled chain cannot slip through.\n */\n\nimport type { NextFunction, Request, RequestHandler, Response } from 'express';\nimport { requireAssurance } from './assurance.js';\nimport { recordAuthzDenial, requirePermission } from './permission-gates.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isSystemOrgId } from './system-org.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { isSystemOrgOnlyPermission, type Permission } from '../types/permissions.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\n/** Whether the request's ACTIVE org (the token's `organizationId`) is the system\n *  org. Compared by id only — an org merely NAMED \"system\" never qualifies. */\nexport function isSystemOrgRequest(req: Request): boolean {\n  return isSystemOrgId(req.user?.organizationId);\n}\n\n/**\n * Require that the caller's active org is the system org. Compose after\n * `requireAuth`. Refusals are 403 `SYSTEM_ORG_REQUIRED`, counted\n * (`system_org_guard_refused_total`) and audited through the shared\n * `authz.denied` sink (`required: 'system-org'`).\n */\nexport const requireSystemOrg = tagRouteGate(function requireSystemOrg(req: Request, res: Response, next: NextFunction): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n  if (isSystemOrgRequest(req)) return next();\n  emitCounter('system_org_guard_refused_total', { principal: req.user.principalType ?? 'unknown' });\n  recordAuthzDenial(req, 'system-org');\n  return sendError(\n    res, HttpStatus.FORBIDDEN,\n    'This action is reserved for the system organization — switch to it to manage the plugin ecosystem',\n    ErrorCode.SYSTEM_ORG_REQUIRED,\n  );\n}, { kind: 'systemOrg' });\n\n/**\n * THE gate for an ecosystem-governance route: system org + (any of) the given\n * system-org-only permission(s) + an MFA-grade human session. Returns the chain\n * as an array, which Express flattens:\n *\n * ```ts\n * router.post('/requests/:id/approve', requireAuth, requireEcosystemPermission('plugins:moderate'),\n *   requireStepUp, audited('plugin.request.approve'), handler);\n * ```\n *\n * Throws at route-definition time when handed a permission that is NOT\n * system-org-only — a tenant permission behind this gate would be unreachable\n * for every tenant, which is always a wiring mistake.\n */\nexport function requireEcosystemPermission(...permissions: Permission[]): RequestHandler[] {\n  if (permissions.length === 0) throw new Error('requireEcosystemPermission needs at least one permission');\n  const tenant = permissions.filter((p) => !isSystemOrgOnlyPermission(p));\n  if (tenant.length > 0) {\n    throw new Error(`requireEcosystemPermission only takes system-org-only permissions; got ${tenant.join(', ')}`);\n  }\n  return [\n    requireSystemOrg,\n    requirePermission(...permissions),\n    requireAssurance({ minAssurance: 2 }),\n  ] as RequestHandler[];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecosystem-guard.js","sourceRoot":"","sources":["../../src/middleware/ecosystem-guard.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAwBtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAmB,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD;+EAC+E;AAC/E,MAAM,UAAU,kBAAkB,CAAC,GAAY;IAC7C,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;AACjD,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,YAAY,CAAC,SAAS,gBAAgB,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB;IACpH,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;IACpG,CAAC;IACD,IAAI,kBAAkB,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,EAAE,CAAC;IAC3C,WAAW,CAAC,gCAAgC,EAAE,EAAE,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,aAAa,IAAI,SAAS,EAAE,CAAC,CAAC;IAClG,iBAAiB,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;IACrC,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,mGAAmG,EACnG,SAAS,CAAC,mBAAmB,CAC9B,CAAC;AACJ,CAAC,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAG,WAAyB;IACrE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;IAC1G,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,0EAA0E,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjH,CAAC;IACD,OAAO;QACL,gBAAgB;QAChB,iBAAiB,CAAC,GAAG,WAAW,CAAC;QACjC,gBAAgB,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;KAClB,CAAC;AACxB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The plugin-ecosystem governance gate (docs/runbooks/ecosystem-moderation.md).\n *\n * Only the system org manages or approves the ecosystem. A route that exercises\n * a system-org-only permission (`plugins:moderate`, `publishers:verify`) must\n * therefore check three things, and {@link requireSystemOrgPermission} composes\n * them so no route can forget one:\n *\n *  1. {@link requireSystemOrg} — the caller's ACTIVE org is the system org. A\n *     token minted in a tenant org is refused even for the same person (and even\n *     for a superadmin: they switch to the system org to act on the ecosystem,\n *     so every governance decision is recorded with the system org's id).\n *  2. the permission itself (`requirePermission`, any-of);\n *  3. an MFA-grade session (`requireAssurance({ minAssurance: 2 })`), which also\n *     refuses every machine credential.\n *\n * The route-coverage governance check (`findSystemOrgGuardViolations` in\n * `testing/route-coverage.ts`) fails any route that gates on a system-org-only\n * permission without 1 and 3, so a hand-rolled chain cannot slip through.\n */\n\nimport type { NextFunction, Request, RequestHandler, Response } from 'express';\nimport { requireAssurance } from './assurance.js';\nimport { recordAuthzDenial, requirePermission } from './permission-gates.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isSystemOrgId } from './system-org.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { isSystemOrgOnlyPermission, type Permission } from '../types/permissions.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\n/** Whether the request's ACTIVE org (the token's `organizationId`) is the system\n *  org. Compared by id only — an org merely NAMED \"system\" never qualifies. */\nexport function isSystemOrgRequest(req: Request): boolean {\n  return isSystemOrgId(req.user?.organizationId);\n}\n\n/**\n * Require that the caller's active org is the system org. Compose after\n * `requireAuth`. Refusals are 403 `SYSTEM_ORG_REQUIRED`, counted\n * (`system_org_guard_refused_total`) and audited through the shared\n * `authz.denied` sink (`required: 'system-org'`).\n */\nexport const requireSystemOrg = tagRouteGate(function requireSystemOrg(req: Request, res: Response, next: NextFunction): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n  if (isSystemOrgRequest(req)) return next();\n  emitCounter('system_org_guard_refused_total', { principal: req.user.principalType ?? 'unknown' });\n  recordAuthzDenial(req, 'system-org');\n  return sendError(\n    res, HttpStatus.FORBIDDEN,\n    'This action is reserved for the system organization — switch to it to manage the plugin ecosystem',\n    ErrorCode.SYSTEM_ORG_REQUIRED,\n  );\n}, { kind: 'systemOrg' });\n\n/**\n * THE gate for an ecosystem-governance route: system org + (any of) the given\n * system-org-only permission(s) + an MFA-grade human session. Returns the chain\n * as an array, which Express flattens:\n *\n * ```ts\n * router.post('/requests/:id/approve', requireAuth, requireSystemOrgPermission('plugins:moderate'),\n *   requireStepUp, audited('plugin.request.approve'), handler);\n * ```\n *\n * Throws at route-definition time when handed a permission that is NOT\n * system-org-only — a tenant permission behind this gate would be unreachable\n * for every tenant, which is always a wiring mistake.\n */\nexport function requireSystemOrgPermission(...permissions: Permission[]): RequestHandler[] {\n  if (permissions.length === 0) throw new Error('requireSystemOrgPermission needs at least one permission');\n  const tenant = permissions.filter((p) => !isSystemOrgOnlyPermission(p));\n  if (tenant.length > 0) {\n    throw new Error(`requireSystemOrgPermission only takes system-org-only permissions; got ${tenant.join(', ')}`);\n  }\n  return [\n    requireSystemOrg,\n    requirePermission(...permissions),\n    requireAssurance({ minAssurance: 2 }),\n  ] as RequestHandler[];\n}\n"]}

package/lib/middleware/index.d.ts

@@ -5,8 +5,11 @@ export { requireAssurance, refuseWeakSession, refuseForOrgAdminAssurance, requir
 export { userHasPermission, setAuthzDenialAuditor, recordAuthzDenial, requirePermission, requireAllPermissions, requirePermissionOrService, requireServicePrincipal, requireInternalService, isSystemAdmin, hasScope, requireSystemAdmin, requireFeature, type AuthzDenialInfo, } from './permission-gates.js';
 export { isSystemOrgId, SYSTEM_ORG_ID, SYSTEM_ORG_SLUG, } from './system-org.js';
 export { serviceNameOf, isServiceTokenDenied, signServiceToken, getServiceAuthHeader, isServicePrincipal, isServiceAccountPrincipal, isServicePrincipalNamed, verifyServicePrincipal, } from './service-tokens.js';
-export { requireSystemOrg, requireEcosystemPermission } from './ecosystem-guard.js';
+export { requireSystemOrg, requireSystemOrgPermission } from './ecosystem-guard.js';
 export { mongoSanitize, MAX_SANITIZE_DEPTH, } from './mongo-sanitize.js';
 export { proposable, ASK_PROVENANCE_REFUSED_COUNTER, } from './ask-provenance.js';
 export { requireStepUp, type StepUpMethod, STRONG_STEP_UP_METHODS, } from './step-up.js';
-export { tagRouteGate, getRouteGates, audited, buildRouteTable, isWriteMethod, summarizeRouteTable, type RouteTableEntry, } from './route-table.js';
+export { tagRouteGate, getRouteGates, audited, dynamicAuthz, buildRouteTable, isWriteMethod, summarizeRouteTable, DYNAMIC_PRINCIPALS, type DynamicPrincipal, type RouteTableEntry, } from './route-table.js';
+export { armDeferredQuotaCheck, runDeferredQuotaCheck, } from './deferred-quota-check.js';
+export { ON_BEHALF_HEADER, ON_BEHALF_CALLERS, onBehalfHeaders, onBehalfCaller, type OnBehalfSubject, } from './on-behalf.js';
+export { QUOTA_EXEMPT_ROUTES, isQuotaExemptRoute, type QuotaExemptRoute, } from './quota-exempt-routes.js';

package/lib/middleware/index.js

@@ -7,9 +7,12 @@ export { requireAssurance, refuseWeakSession, refuseForOrgAdminAssurance, requir
 export { userHasPermission, setAuthzDenialAuditor, recordAuthzDenial, requirePermission, requireAllPermissions, requirePermissionOrService, requireServicePrincipal, requireInternalService, isSystemAdmin, hasScope, requireSystemAdmin, requireFeature, } from './permission-gates.js';
 export { isSystemOrgId, SYSTEM_ORG_ID, SYSTEM_ORG_SLUG, } from './system-org.js';
 export { serviceNameOf, isServiceTokenDenied, signServiceToken, getServiceAuthHeader, isServicePrincipal, isServiceAccountPrincipal, isServicePrincipalNamed, verifyServicePrincipal, } from './service-tokens.js';
-export { requireSystemOrg, requireEcosystemPermission } from './ecosystem-guard.js';
+export { requireSystemOrg, requireSystemOrgPermission } from './ecosystem-guard.js';
 export { mongoSanitize, MAX_SANITIZE_DEPTH, } from './mongo-sanitize.js';
 export { proposable, ASK_PROVENANCE_REFUSED_COUNTER, } from './ask-provenance.js';
 export { requireStepUp, STRONG_STEP_UP_METHODS, } from './step-up.js';
-export { tagRouteGate, getRouteGates, audited, buildRouteTable, isWriteMethod, summarizeRouteTable, } from './route-table.js';
-//# sourceMappingURL=data:application/json;base64,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
+export { tagRouteGate, getRouteGates, audited, dynamicAuthz, buildRouteTable, isWriteMethod, summarizeRouteTable, DYNAMIC_PRINCIPALS, } from './route-table.js';
+export { armDeferredQuotaCheck, runDeferredQuotaCheck, } from './deferred-quota-check.js';
+export { ON_BEHALF_HEADER, ON_BEHALF_CALLERS, onBehalfHeaders, onBehalfCaller, } from './on-behalf.js';
+export { QUOTA_EXEMPT_ROUTES, isQuotaExemptRoute, } from './quota-exempt-routes.js';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/middleware/on-behalf.d.ts

@@ -0,0 +1,37 @@
+import type { Request } from 'express';
+/** The header carrying the signed on-behalf marker (lower-case, as Node reads it). */
+export declare const ON_BEHALF_HEADER = "x-pb-on-behalf";
+/**
+ * Services whose on-behalf marker is honoured: the ones that forward a user's
+ * token as a matter of design. A marker signed by any other service — valid
+ * signature or not — is ignored, so a compromised peer that never forwards user
+ * tokens cannot start waiving its tenants' meters.
+ */
+export declare const ON_BEHALF_CALLERS: readonly string[];
+/** Who a marker vouches for. Defaults to the ambient request's verified principal. */
+export interface OnBehalfSubject {
+    /** The user (`sub`) whose token rides the same request. */
+    sub: string;
+    /** Their active org. */
+    organizationId: string;
+}
+/**
+ * Headers to add beside a forwarded user `Authorization` so the peer does not
+ * bill the hop a second time. Mint per call (the marker expires in 120 s).
+ *
+ * The subject defaults to the ambient audit context's VERIFIED principal (the
+ * inbound request this call serves). Returns `{}` — the hop is billed normally,
+ * the safe direction — when there is no user principal to vouch for, or when
+ * this process cannot sign (no service key).
+ */
+export declare function onBehalfHeaders(subject?: OnBehalfSubject): Record<string, string>;
+/**
+ * The internal service that vouched for this request with a VALID on-behalf
+ * marker, else `undefined`. Requires the request to be authenticated (`req.user`
+ * set by requireAuth) — the marker is only meaningful against a verified user.
+ *
+ * Every rejection of a PRESENT header is counted on
+ * `quota_on_behalf_rejected_total{reason}`: a forged header from a user lands
+ * there as `invalid` (no service key signs it), and the request is billed.
+ */
+export declare function onBehalfCaller(req: Request): string | undefined;