@pipeline-builder/api-core 5.2.6 → 5.2.7

package/lib/types/audit-events.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/build-catalog.d.ts

@@ -114,6 +114,71 @@ export declare const BUILD_SIZE_CATALOG: Readonly<Record<BuildSize, BuildSizeMet
  * operator never bought into. Pinned against the `QuotaTier` union by a test.
  */
 export declare const BUILD_TIER_LADDER: readonly QuotaTier[];
+/**
+ * How many of a tier's builds run AT ONCE, across every org on that tier
+ * (`PLUGIN_BUILD_CONCURRENCY_<TIER>` overrides each row).
+ *
+ * TIER-keyed, not class-keyed, and that is the queue topology rather than a
+ * simplification: there is one BullMQ `Worker` per tier queue and both
+ * scheduling classes are served by it, so a per-class figure here could not be
+ * honoured — it would either duplicate this number or invite someone to set a
+ * value the worker cannot act on.
+ *
+ * **A ladder, not one figure.** This is the AGGREGATE bound that makes a tier's
+ * advertised per-build capacity deliverable: the cap is reachable by a single
+ * tenant, and the number of tenants reaching for it concurrently is limited
+ * here, where it can be tuned without touching the price list.
+ *
+ * It lived as a bare literal map inside the build worker until now, which is
+ * exactly how `docs/environment-variables.md` came to describe a global default
+ * that the code had stopped honouring — a figure no catalog exposes is a figure
+ * the documentation drifts away from. It sits beside `slotsByTier` and
+ * `minTier` because it is the third tier-keyed build figure, not a different
+ * kind of thing.
+ *
+ * **Distinct from the per-org slot cap, and the LOWER of the two binds.** This
+ * is pod capacity (every concurrent build drives the same buildkitd); the slot
+ * cap is fairness between tenants sharing this queue. A tier whose concurrency
+ * sits below its slot cap cannot reach that cap at all, which is why the worker
+ * warns about it on start.
+ *
+ * Monotonic across the PAID rungs only. `unlimited` sits at the bottom, not the
+ * top: it is not a purchased tier but the absence of billing, which correlates
+ * with the smallest hardware — see its own note below.
+ */
+export declare const BUILD_TIER_CONCURRENCY: Readonly<Record<QuotaTier, number>>;
+/**
+ * What ONE replica may run at once if every tier queue is busy: the SUM of the
+ * ladder, because a replica starts one BullMQ Worker per tier and each carries
+ * its own concurrency.
+ *
+ * This number was never written down, and that is the point of writing it down.
+ * The incident arithmetic everyone reasoned with — "8 replicas x 4 = 32" — is
+ * the single-tier case (a catalogue load is all system-org). A mixed fleet
+ * reaches `replicas x this`, which is 13 per replica and 104 across the eight a
+ * plugin deployment scales to. The ladder's rows therefore set a fleet ceiling
+ * that nothing declared and nobody chose.
+ *
+ * `PLUGIN_MAX_BUILDS_PER_REPLICA` defaults to this, so raising a tier row cannot
+ * silently raise what one replica puts on its single buildkitd sidecar — it
+ * binds at this figure and the worker says so on start.
+ */
+export declare const BUILD_LADDER_CONCURRENCY_SUM: number;
+/**
+ * This tier's default worker concurrency. Falls back to the `developer` row for
+ * an unrecognised tier, matching `buildSlotsFor` — a bad tier string must not
+ * hand out the most generous figure in the table.
+ */
+export declare function buildWorkerConcurrencyFor(tier: QuotaTier): number;
+/**
+ * The env var that overrides {@link buildWorkerConcurrencyFor} for one tier.
+ *
+ * Derived rather than written out six times: the per-tier reads used to be six
+ * near-identical `envInt` lines, where a wrong cross-reference
+ * (`pro: envInt('…_PRO', tierDefault.team)`) silently takes another tier's
+ * default and no type can catch it.
+ */
+export declare function buildConcurrencyEnvVar(tier: QuotaTier): string;
 /** This size's credit/vCPU multiplier; `1` for anything unrecognised. */
 export declare function buildSizeMultiplier(size: string): number;
 /** `Small` … `X-Large`; the raw id for anything unrecognised. */

package/lib/types/build-catalog.js

@@ -80,9 +80,103 @@ export const BUILD_SIZE_CATALOG = {
 export const BUILD_TIER_LADDER = [
     'developer', 'pro', 'team', 'business', 'enterprise', 'unlimited',
 ];
+/**
+ * How many of a tier's builds run AT ONCE, across every org on that tier
+ * (`PLUGIN_BUILD_CONCURRENCY_<TIER>` overrides each row).
+ *
+ * TIER-keyed, not class-keyed, and that is the queue topology rather than a
+ * simplification: there is one BullMQ `Worker` per tier queue and both
+ * scheduling classes are served by it, so a per-class figure here could not be
+ * honoured — it would either duplicate this number or invite someone to set a
+ * value the worker cannot act on.
+ *
+ * **A ladder, not one figure.** This is the AGGREGATE bound that makes a tier's
+ * advertised per-build capacity deliverable: the cap is reachable by a single
+ * tenant, and the number of tenants reaching for it concurrently is limited
+ * here, where it can be tuned without touching the price list.
+ *
+ * It lived as a bare literal map inside the build worker until now, which is
+ * exactly how `docs/environment-variables.md` came to describe a global default
+ * that the code had stopped honouring — a figure no catalog exposes is a figure
+ * the documentation drifts away from. It sits beside `slotsByTier` and
+ * `minTier` because it is the third tier-keyed build figure, not a different
+ * kind of thing.
+ *
+ * **Distinct from the per-org slot cap, and the LOWER of the two binds.** This
+ * is pod capacity (every concurrent build drives the same buildkitd); the slot
+ * cap is fairness between tenants sharing this queue. A tier whose concurrency
+ * sits below its slot cap cannot reach that cap at all, which is why the worker
+ * warns about it on start.
+ *
+ * Monotonic across the PAID rungs only. `unlimited` sits at the bottom, not the
+ * top: it is not a purchased tier but the absence of billing, which correlates
+ * with the smallest hardware — see its own note below.
+ */
+export const BUILD_TIER_CONCURRENCY = {
+    developer: 1,
+    pro: 2,
+    team: 2,
+    business: 3,
+    enterprise: 4,
+    /**
+     * ONE, and the lowest row — deliberately NOT the most generous.
+     *
+     * `unlimited` means "billing is not configured", which in practice is a
+     * single-node install (local, minikube, a fresh cluster), and it is also the
+     * SYSTEM ORG's tier — the org that loads the whole sample catalogue on first
+     * boot. Giving it 4 handed the highest concurrency to the tier most likely to
+     * be running on the smallest hardware.
+     *
+     * It cost an install: 8 plugin replicas x 4 = 32 concurrent builds, each
+     * asking the image registry to sign a 7-17 MiB SBOM against its 1 GiB limit.
+     * The registry was OOMKilled, and because its `/token` endpoint is also the
+     * registry login, the pushes failed too — 107 of 117 plugins never came up.
+     * The earlier default of 1 (then a global knob) had produced 95 of 119.
+     *
+     * Raise it per deployment with `PLUGIN_BUILD_CONCURRENCY_UNLIMITED` once the
+     * registry's memory and a signing bound say the fan-in is safe.
+     */
+    unlimited: 1,
+};
 // ---------------------------------------------------------------------------
 // Accessors
 // ---------------------------------------------------------------------------
+/**
+ * What ONE replica may run at once if every tier queue is busy: the SUM of the
+ * ladder, because a replica starts one BullMQ Worker per tier and each carries
+ * its own concurrency.
+ *
+ * This number was never written down, and that is the point of writing it down.
+ * The incident arithmetic everyone reasoned with — "8 replicas x 4 = 32" — is
+ * the single-tier case (a catalogue load is all system-org). A mixed fleet
+ * reaches `replicas x this`, which is 13 per replica and 104 across the eight a
+ * plugin deployment scales to. The ladder's rows therefore set a fleet ceiling
+ * that nothing declared and nobody chose.
+ *
+ * `PLUGIN_MAX_BUILDS_PER_REPLICA` defaults to this, so raising a tier row cannot
+ * silently raise what one replica puts on its single buildkitd sidecar — it
+ * binds at this figure and the worker says so on start.
+ */
+export const BUILD_LADDER_CONCURRENCY_SUM = BUILD_TIER_LADDER.reduce((n, tier) => n + BUILD_TIER_CONCURRENCY[tier], 0);
+/**
+ * This tier's default worker concurrency. Falls back to the `developer` row for
+ * an unrecognised tier, matching `buildSlotsFor` — a bad tier string must not
+ * hand out the most generous figure in the table.
+ */
+export function buildWorkerConcurrencyFor(tier) {
+    return BUILD_TIER_CONCURRENCY[tier] ?? BUILD_TIER_CONCURRENCY.developer;
+}
+/**
+ * The env var that overrides {@link buildWorkerConcurrencyFor} for one tier.
+ *
+ * Derived rather than written out six times: the per-tier reads used to be six
+ * near-identical `envInt` lines, where a wrong cross-reference
+ * (`pro: envInt('…_PRO', tierDefault.team)`) silently takes another tier's
+ * default and no type can catch it.
+ */
+export function buildConcurrencyEnvVar(tier) {
+    return `PLUGIN_BUILD_CONCURRENCY_${tier.toUpperCase()}`;
+}
 /** This size's credit/vCPU multiplier; `1` for anything unrecognised. */
 export function buildSizeMultiplier(size) {
     return BUILD_SIZE_CATALOG[size]?.multiplier ?? 1;
@@ -155,4 +249,4 @@ export function tierAllowsBuildSize(tier, size) {
 export function buildSizesForTier(tier) {
     return BUILD_SIZES.filter((s) => tierAllowsBuildSize(tier, s));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-catalog.js","sourceRoot":"","sources":["../../src/types/build-catalog.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What a build's CLASS and SIZE are called, what they cost, and which tier may\n * ask for them (D11/D13).\n *\n * ONE module instead of six tables. The facts used to live in\n * `wire-vocabulary.ts` (the two id lists and the size multipliers),\n * `quota-tiers.ts` (which tier gets which size, and the per-class slot counts)\n * and a hand-maintained mirror of all four in `frontend/src/lib/build-shape.ts`\n * — held together by a test that parsed this package's TypeScript SOURCE with\n * regexes to detect drift. This is the same move `quota-catalog.ts` made for the\n * five frontend label maps, and for the same reason: the browser imports the\n * catalog directly, so there is nothing left to drift.\n *\n * DEPENDENCY-FREE, and that is a constraint rather than a happy accident. Only\n * type-only imports, which are erased, so this module loads in a browser; the\n * moment it reads an env var it stops being importable by the frontend and the\n * mirror comes back. Everything here is therefore a DEFAULT. The env overlay\n * (`PLUGIN_MAX_BUILDS_<TIER>_<CLASS>`, `PLUGIN_BUILDKIT_ADDR_SIZE_<SUFFIX>`)\n * lives server-side, which is the same split the tier presets already use: a\n * hardcoded fallback plus a `/config` overlay.\n *\n * IDS ARE ARITHMETIC, LABELS ARE WORDS. `0.5x` carries its own multiplier, so\n * `buildSizeMultiplier` is checkable by eye and the credit math is\n * self-documenting; `Small` / `Standard` / `Medium` / `Large` / `X-Large` is what\n * a person reads. Keeping them separate is also what makes a rename cheap: a\n * label is one line here, with no wire value, Redis key, metric label or ledger\n * string to migrate.\n */\n\nimport type { QuotaTier } from './quota-tiers.js';\n\n// ---------------------------------------------------------------------------\n// Scheduling class — WHEN a build starts\n// ---------------------------------------------------------------------------\n\n/**\n * `flexible` rather than `batch`, `deferred` or `small`.\n *\n * It names what the CUSTOMER trades — a flexible start time — instead of what\n * the platform does with it, and it does not read as a demotion: this class is\n * available on every tier including free, and `deferred` sounds broken while\n * `low priority` sounds like a penalty. `small` was rejected outright because it\n * is a magnitude word on a latency dimension — `{ buildClass: 'small',\n * buildSize: '2x' }` is legal and unreadable.\n */\nexport const BUILD_CLASSES = ['standard', 'flexible'] as const;\nexport type BuildClass = (typeof BUILD_CLASSES)[number];\n\nexport interface BuildClassMeta {\n  /** What a person reads. */\n  label: string;\n  /** The trade, said in one line beside the control. */\n  blurb: string;\n  /**\n   * In-flight builds one ORG may hold in this class, per tier — the DEFAULT for\n   * `PLUGIN_MAX_BUILDS_<TIER>_<CLASS>`.\n   *\n   * Graded by tier rather than one flat figure: a single figure gave a Developer\n   * org the same three in-flight builds as an Enterprise one, which made the\n   * per-org semaphore the one place in the build path that ignored what the\n   * tenant pays for. `flexible` has more headroom than `standard` on every row,\n   * because the cheap class is where the room has to be for it to smooth\n   * anything — a row where they were equal would make the class pointless to\n   * choose.\n   */\n  slotsByTier: Readonly<Record<QuotaTier, number>>;\n}\n\nexport const BUILD_CLASS_CATALOG: Readonly<Record<BuildClass, BuildClassMeta>> = {\n  standard: {\n    label: 'Standard',\n    blurb: 'Starts as soon as a slot is free. Use it for anything you are waiting on.',\n    slotsByTier: {\n      developer: 1,\n      pro: 2,\n      team: 3,\n      business: 5,\n      enterprise: 8,\n      // Billing disabled: nothing is capped, so the ceiling is the pool itself.\n      unlimited: 8,\n    },\n  },\n  flexible: {\n    label: 'Flexible',\n    blurb: 'Starts later, in exchange for more builds at once. Same cost per build.',\n    slotsByTier: {\n      developer: 3,\n      pro: 4,\n      team: 6,\n      business: 10,\n      enterprise: 16,\n      unlimited: 16,\n    },\n  },\n};\n\n// ---------------------------------------------------------------------------\n// Machine size — HOW MUCH CPU a build gets\n// ---------------------------------------------------------------------------\n\nexport const BUILD_SIZES = ['0.5x', '1x', '2x', '4x', '8x'] as const;\nexport type BuildSize = (typeof BUILD_SIZES)[number];\n\nexport interface BuildSizeMeta {\n  /** What a person reads: Small … X-Large. */\n  label: string;\n  /** vCPU relative to the deployment's base figure, and the credit rate. */\n  multiplier: number;\n  /**\n   * Lowest tier that may REQUEST this size; `null` means every tier may.\n   *\n   * One field per size rather than a row per tier, and that makes the ladder's\n   * monotonicity STRUCTURAL: a row-per-tier table can express \"Team has 4x but\n   * Business does not\" and needed a test to forbid it. This shape cannot.\n   */\n  minTier: QuotaTier | null;\n  /**\n   * The class this size pairs with unless the caller says otherwise.\n   *\n   * Why `0.5x` defaults to `flexible`: a half-speed build takes roughly twice as\n   * long and therefore HOLDS ITS SLOT twice as long. On Developer — one standard\n   * slot — one cheap build would block the only urgent-fix slot for double the\n   * time. Defaulting it to the class with three slots means it cannot.\n   */\n  defaultClass: BuildClass;\n  /**\n   * Suffix of this size's buildkitd pool override\n   * (`PLUGIN_BUILDKIT_ADDR_SIZE_<SUFFIX>`).\n   *\n   * Declared rather than derived from the id, because deriving it produces\n   * ILLEGAL NAMES: `'0.5x'.toUpperCase()` gives `0.5X` and a dot cannot appear in\n   * an environment variable name (the same reason `x-large` was rejected as an\n   * id — `..._X-LARGE` is not an identifier either).\n   */\n  envSuffix: string;\n}\n\n/**\n * The size ladder.\n *\n * A size is a BIGGER DAEMON, not a flag: `buildctl` has no per-build CPU option,\n * because the CPU a build may use is the buildkitd POD's limit. So every rung\n * above or below `1x` needs a pool of its own, and a rung with no pool is\n * REFUSED rather than silently served at `1x` — in both directions. Serving\n * `4x` from the shared daemon would charge four times for one times the speed;\n * serving `0.5x` from it would hand every tenant full speed at half price.\n */\nexport const BUILD_SIZE_CATALOG: Readonly<Record<BuildSize, BuildSizeMeta>> = {\n  // Available to EVERY tier, deliberately. It is a budget option, not a\n  // restriction: the free tier gains a real choice (spend less) instead of a\n  // list of locks. The arithmetic is honest in one direction — a CPU-bound build\n  // takes twice as long at half the vCPU and costs the SAME, while an I/O-bound\n  // one costs about half. So Small can never cost more than Standard, and can\n  // cost half (assuming slowdown is at most linear, which memory pressure can\n  // break).\n  '0.5x': { label: 'Small', multiplier: 0.5, minTier: null, defaultClass: 'flexible', envSuffix: 'HALF' },\n  '1x': { label: 'Standard', multiplier: 1, minTier: null, defaultClass: 'standard', envSuffix: '1X' },\n  '2x': { label: 'Medium', multiplier: 2, minTier: 'team', defaultClass: 'standard', envSuffix: '2X' },\n  '4x': { label: 'Large', multiplier: 4, minTier: 'business', defaultClass: 'standard', envSuffix: '4X' },\n  '8x': { label: 'X-Large', multiplier: 8, minTier: 'enterprise', defaultClass: 'standard', envSuffix: '8X' },\n};\n\n/**\n * The tier ladder, ascending, for evaluating {@link BuildSizeMeta.minTier}.\n *\n * Declared here because a dependency-free module cannot import `VALID_TIERS` (it\n * is derived from the env-reading tier table). `unlimited` sits at the top so\n * the no-billing install gates nothing — a gate there would invent a limit the\n * operator never bought into. Pinned against the `QuotaTier` union by a test.\n */\nexport const BUILD_TIER_LADDER: readonly QuotaTier[] = [\n  'developer', 'pro', 'team', 'business', 'enterprise', 'unlimited',\n];\n\n// ---------------------------------------------------------------------------\n// Accessors\n// ---------------------------------------------------------------------------\n\n/** This size's credit/vCPU multiplier; `1` for anything unrecognised. */\nexport function buildSizeMultiplier(size: string): number {\n  return BUILD_SIZE_CATALOG[size as BuildSize]?.multiplier ?? 1;\n}\n\n/** `Small` … `X-Large`; the raw id for anything unrecognised. */\nexport function buildSizeLabel(size: string): string {\n  return BUILD_SIZE_CATALOG[size as BuildSize]?.label ?? size;\n}\n\n/** `Standard` / `Flexible`; the raw id for anything unrecognised. */\nexport function buildClassLabel(buildClass: string): string {\n  return BUILD_CLASS_CATALOG[buildClass as BuildClass]?.label ?? buildClass;\n}\n\n/**\n * Env-var suffix of this size's buildkitd pool override.\n *\n * Declared in the catalog rather than derived, because deriving it produces\n * ILLEGAL NAMES: `'0.5x'.toUpperCase()` is `0.5X`, and a dot cannot appear in an\n * environment variable name. (It is the same reason `x-large` was rejected as an\n * id — `..._X-LARGE` is not an identifier either.) Falls back to `1X`, the\n * shared daemon, for an unrecognised size.\n */\nexport function buildSizeEnvSuffix(size: string): string {\n  return BUILD_SIZE_CATALOG[size as BuildSize]?.envSuffix ?? '1X';\n}\n\n/** The class this size runs in unless the caller overrides it. */\nexport function defaultClassForSize(size: string): BuildClass {\n  return BUILD_SIZE_CATALOG[size as BuildSize]?.defaultClass ?? 'standard';\n}\n\n/**\n * How much longer a build at this size may run before the timeout kills it.\n *\n * Scales UP below `1x` and never down above it, and the asymmetry is the point:\n * the timeout is a SAFETY bound on a runaway build, not a budget. At half the\n * vCPU a ten-minute build becomes about twenty and would die on a 15-minute\n * bound — so Small would quietly fail long builds (as a `retryable` failure, so\n * the tenant is not charged, but it is retried twice and dead-lettered). Scaling\n * it DOWN at `4x` would instead break I/O-bound builds that gain nothing from\n * the extra CPU.\n */\nexport function buildTimeoutFactor(size: string): number {\n  return Math.max(1, 1 / buildSizeMultiplier(size));\n}\n\n/** In-flight builds one org on `tier` may hold in `buildClass` (the default). */\nexport function buildSlotsFor(tier: QuotaTier, buildClass: BuildClass): number {\n  const meta = BUILD_CLASS_CATALOG[buildClass] ?? BUILD_CLASS_CATALOG.standard;\n  return meta.slotsByTier[tier] ?? meta.slotsByTier.developer;\n}\n\n/** Both classes' slot counts for one tier — the per-tier reading the UI wants. */\nexport function buildSlotsByClass(tier: QuotaTier): Readonly<Record<BuildClass, number>> {\n  return {\n    standard: buildSlotsFor(tier, 'standard'),\n    flexible: buildSlotsFor(tier, 'flexible'),\n  };\n}\n\n/** Whether `tier` may request `size`. */\nexport function tierAllowsBuildSize(tier: QuotaTier, size: string): boolean {\n  const meta = BUILD_SIZE_CATALOG[size as BuildSize];\n  if (!meta) return false;\n  if (meta.minTier === null) return true;\n  const have = BUILD_TIER_LADDER.indexOf(tier);\n  // An unrecognised tier gets the FLOOR of the ladder — the smallest allowance,\n  // never everything. Same conservative call `tierForQueueName` makes.\n  if (have < 0) return false;\n  return have >= BUILD_TIER_LADDER.indexOf(meta.minTier);\n}\n\n/** Every size `tier` may request, ascending. */\nexport function buildSizesForTier(tier: QuotaTier): readonly BuildSize[] {\n  return BUILD_SIZES.filter((s) => tierAllowsBuildSize(tier, s));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-catalog.js","sources":["../../src/types/build-catalog.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What a build's CLASS and SIZE are called, what they cost, and which tier may\n * ask for them (D11/D13).\n *\n * ONE module instead of six tables. The facts used to live in\n * `wire-vocabulary.ts` (the two id lists and the size multipliers),\n * `quota-tiers.ts` (which tier gets which size, and the per-class slot counts)\n * and a hand-maintained mirror of all four in `frontend/src/lib/build-shape.ts`\n * — held together by a test that parsed this package's TypeScript SOURCE with\n * regexes to detect drift. This is the same move `quota-catalog.ts` made for the\n * five frontend label maps, and for the same reason: the browser imports the\n * catalog directly, so there is nothing left to drift.\n *\n * DEPENDENCY-FREE, and that is a constraint rather than a happy accident. Only\n * type-only imports, which are erased, so this module loads in a browser; the\n * moment it reads an env var it stops being importable by the frontend and the\n * mirror comes back. Everything here is therefore a DEFAULT. The env overlay\n * (`PLUGIN_MAX_BUILDS_<TIER>_<CLASS>`, `PLUGIN_BUILDKIT_ADDR_SIZE_<SUFFIX>`)\n * lives server-side, which is the same split the tier presets already use: a\n * hardcoded fallback plus a `/config` overlay.\n *\n * IDS ARE ARITHMETIC, LABELS ARE WORDS. `0.5x` carries its own multiplier, so\n * `buildSizeMultiplier` is checkable by eye and the credit math is\n * self-documenting; `Small` / `Standard` / `Medium` / `Large` / `X-Large` is what\n * a person reads. Keeping them separate is also what makes a rename cheap: a\n * label is one line here, with no wire value, Redis key, metric label or ledger\n * string to migrate.\n */\n\nimport type { QuotaTier } from './quota-tiers.js';\n\n// ---------------------------------------------------------------------------\n// Scheduling class — WHEN a build starts\n// ---------------------------------------------------------------------------\n\n/**\n * `flexible` rather than `batch`, `deferred` or `small`.\n *\n * It names what the CUSTOMER trades — a flexible start time — instead of what\n * the platform does with it, and it does not read as a demotion: this class is\n * available on every tier including free, and `deferred` sounds broken while\n * `low priority` sounds like a penalty. `small` was rejected outright because it\n * is a magnitude word on a latency dimension — `{ buildClass: 'small',\n * buildSize: '2x' }` is legal and unreadable.\n */\nexport const BUILD_CLASSES = ['standard', 'flexible'] as const;\nexport type BuildClass = (typeof BUILD_CLASSES)[number];\n\nexport interface BuildClassMeta {\n  /** What a person reads. */\n  label: string;\n  /** The trade, said in one line beside the control. */\n  blurb: string;\n  /**\n   * In-flight builds one ORG may hold in this class, per tier — the DEFAULT for\n   * `PLUGIN_MAX_BUILDS_<TIER>_<CLASS>`.\n   *\n   * Graded by tier rather than one flat figure: a single figure gave a Developer\n   * org the same three in-flight builds as an Enterprise one, which made the\n   * per-org semaphore the one place in the build path that ignored what the\n   * tenant pays for. `flexible` has more headroom than `standard` on every row,\n   * because the cheap class is where the room has to be for it to smooth\n   * anything — a row where they were equal would make the class pointless to\n   * choose.\n   */\n  slotsByTier: Readonly<Record<QuotaTier, number>>;\n}\n\nexport const BUILD_CLASS_CATALOG: Readonly<Record<BuildClass, BuildClassMeta>> = {\n  standard: {\n    label: 'Standard',\n    blurb: 'Starts as soon as a slot is free. Use it for anything you are waiting on.',\n    slotsByTier: {\n      developer: 1,\n      pro: 2,\n      team: 3,\n      business: 5,\n      enterprise: 8,\n      // Billing disabled: nothing is capped, so the ceiling is the pool itself.\n      unlimited: 8,\n    },\n  },\n  flexible: {\n    label: 'Flexible',\n    blurb: 'Starts later, in exchange for more builds at once. Same cost per build.',\n    slotsByTier: {\n      developer: 3,\n      pro: 4,\n      team: 6,\n      business: 10,\n      enterprise: 16,\n      unlimited: 16,\n    },\n  },\n};\n\n// ---------------------------------------------------------------------------\n// Machine size — HOW MUCH CPU a build gets\n// ---------------------------------------------------------------------------\n\nexport const BUILD_SIZES = ['0.5x', '1x', '2x', '4x', '8x'] as const;\nexport type BuildSize = (typeof BUILD_SIZES)[number];\n\nexport interface BuildSizeMeta {\n  /** What a person reads: Small … X-Large. */\n  label: string;\n  /** vCPU relative to the deployment's base figure, and the credit rate. */\n  multiplier: number;\n  /**\n   * Lowest tier that may REQUEST this size; `null` means every tier may.\n   *\n   * One field per size rather than a row per tier, and that makes the ladder's\n   * monotonicity STRUCTURAL: a row-per-tier table can express \"Team has 4x but\n   * Business does not\" and needed a test to forbid it. This shape cannot.\n   */\n  minTier: QuotaTier | null;\n  /**\n   * The class this size pairs with unless the caller says otherwise.\n   *\n   * Why `0.5x` defaults to `flexible`: a half-speed build takes roughly twice as\n   * long and therefore HOLDS ITS SLOT twice as long. On Developer — one standard\n   * slot — one cheap build would block the only urgent-fix slot for double the\n   * time. Defaulting it to the class with three slots means it cannot.\n   */\n  defaultClass: BuildClass;\n  /**\n   * Suffix of this size's buildkitd pool override\n   * (`PLUGIN_BUILDKIT_ADDR_SIZE_<SUFFIX>`).\n   *\n   * Declared rather than derived from the id, because deriving it produces\n   * ILLEGAL NAMES: `'0.5x'.toUpperCase()` gives `0.5X` and a dot cannot appear in\n   * an environment variable name (the same reason `x-large` was rejected as an\n   * id — `..._X-LARGE` is not an identifier either).\n   */\n  envSuffix: string;\n}\n\n/**\n * The size ladder.\n *\n * A size is a BIGGER DAEMON, not a flag: `buildctl` has no per-build CPU option,\n * because the CPU a build may use is the buildkitd POD's limit. So every rung\n * above or below `1x` needs a pool of its own, and a rung with no pool is\n * REFUSED rather than silently served at `1x` — in both directions. Serving\n * `4x` from the shared daemon would charge four times for one times the speed;\n * serving `0.5x` from it would hand every tenant full speed at half price.\n */\nexport const BUILD_SIZE_CATALOG: Readonly<Record<BuildSize, BuildSizeMeta>> = {\n  // Available to EVERY tier, deliberately. It is a budget option, not a\n  // restriction: the free tier gains a real choice (spend less) instead of a\n  // list of locks. The arithmetic is honest in one direction — a CPU-bound build\n  // takes twice as long at half the vCPU and costs the SAME, while an I/O-bound\n  // one costs about half. So Small can never cost more than Standard, and can\n  // cost half (assuming slowdown is at most linear, which memory pressure can\n  // break).\n  '0.5x': { label: 'Small', multiplier: 0.5, minTier: null, defaultClass: 'flexible', envSuffix: 'HALF' },\n  '1x': { label: 'Standard', multiplier: 1, minTier: null, defaultClass: 'standard', envSuffix: '1X' },\n  '2x': { label: 'Medium', multiplier: 2, minTier: 'team', defaultClass: 'standard', envSuffix: '2X' },\n  '4x': { label: 'Large', multiplier: 4, minTier: 'business', defaultClass: 'standard', envSuffix: '4X' },\n  '8x': { label: 'X-Large', multiplier: 8, minTier: 'enterprise', defaultClass: 'standard', envSuffix: '8X' },\n};\n\n/**\n * The tier ladder, ascending, for evaluating {@link BuildSizeMeta.minTier}.\n *\n * Declared here because a dependency-free module cannot import `VALID_TIERS` (it\n * is derived from the env-reading tier table). `unlimited` sits at the top so\n * the no-billing install gates nothing — a gate there would invent a limit the\n * operator never bought into. Pinned against the `QuotaTier` union by a test.\n */\nexport const BUILD_TIER_LADDER: readonly QuotaTier[] = [\n  'developer', 'pro', 'team', 'business', 'enterprise', 'unlimited',\n];\n\n/**\n * How many of a tier's builds run AT ONCE, across every org on that tier\n * (`PLUGIN_BUILD_CONCURRENCY_<TIER>` overrides each row).\n *\n * TIER-keyed, not class-keyed, and that is the queue topology rather than a\n * simplification: there is one BullMQ `Worker` per tier queue and both\n * scheduling classes are served by it, so a per-class figure here could not be\n * honoured — it would either duplicate this number or invite someone to set a\n * value the worker cannot act on.\n *\n * **A ladder, not one figure.** This is the AGGREGATE bound that makes a tier's\n * advertised per-build capacity deliverable: the cap is reachable by a single\n * tenant, and the number of tenants reaching for it concurrently is limited\n * here, where it can be tuned without touching the price list.\n *\n * It lived as a bare literal map inside the build worker until now, which is\n * exactly how `docs/environment-variables.md` came to describe a global default\n * that the code had stopped honouring — a figure no catalog exposes is a figure\n * the documentation drifts away from. It sits beside `slotsByTier` and\n * `minTier` because it is the third tier-keyed build figure, not a different\n * kind of thing.\n *\n * **Distinct from the per-org slot cap, and the LOWER of the two binds.** This\n * is pod capacity (every concurrent build drives the same buildkitd); the slot\n * cap is fairness between tenants sharing this queue. A tier whose concurrency\n * sits below its slot cap cannot reach that cap at all, which is why the worker\n * warns about it on start.\n *\n * Monotonic across the PAID rungs only. `unlimited` sits at the bottom, not the\n * top: it is not a purchased tier but the absence of billing, which correlates\n * with the smallest hardware — see its own note below.\n */\nexport const BUILD_TIER_CONCURRENCY: Readonly<Record<QuotaTier, number>> = {\n  developer: 1,\n  pro: 2,\n  team: 2,\n  business: 3,\n  enterprise: 4,\n  /**\n   * ONE, and the lowest row — deliberately NOT the most generous.\n   *\n   * `unlimited` means \"billing is not configured\", which in practice is a\n   * single-node install (local, minikube, a fresh cluster), and it is also the\n   * SYSTEM ORG's tier — the org that loads the whole sample catalogue on first\n   * boot. Giving it 4 handed the highest concurrency to the tier most likely to\n   * be running on the smallest hardware.\n   *\n   * It cost an install: 8 plugin replicas x 4 = 32 concurrent builds, each\n   * asking the image registry to sign a 7-17 MiB SBOM against its 1 GiB limit.\n   * The registry was OOMKilled, and because its `/token` endpoint is also the\n   * registry login, the pushes failed too — 107 of 117 plugins never came up.\n   * The earlier default of 1 (then a global knob) had produced 95 of 119.\n   *\n   * Raise it per deployment with `PLUGIN_BUILD_CONCURRENCY_UNLIMITED` once the\n   * registry's memory and a signing bound say the fan-in is safe.\n   */\n  unlimited: 1,\n};\n\n// ---------------------------------------------------------------------------\n// Accessors\n// ---------------------------------------------------------------------------\n\n/**\n * What ONE replica may run at once if every tier queue is busy: the SUM of the\n * ladder, because a replica starts one BullMQ Worker per tier and each carries\n * its own concurrency.\n *\n * This number was never written down, and that is the point of writing it down.\n * The incident arithmetic everyone reasoned with — \"8 replicas x 4 = 32\" — is\n * the single-tier case (a catalogue load is all system-org). A mixed fleet\n * reaches `replicas x this`, which is 13 per replica and 104 across the eight a\n * plugin deployment scales to. The ladder's rows therefore set a fleet ceiling\n * that nothing declared and nobody chose.\n *\n * `PLUGIN_MAX_BUILDS_PER_REPLICA` defaults to this, so raising a tier row cannot\n * silently raise what one replica puts on its single buildkitd sidecar — it\n * binds at this figure and the worker says so on start.\n */\nexport const BUILD_LADDER_CONCURRENCY_SUM: number =\n  BUILD_TIER_LADDER.reduce((n, tier) => n + BUILD_TIER_CONCURRENCY[tier], 0);\n\n/**\n * This tier's default worker concurrency. Falls back to the `developer` row for\n * an unrecognised tier, matching `buildSlotsFor` — a bad tier string must not\n * hand out the most generous figure in the table.\n */\nexport function buildWorkerConcurrencyFor(tier: QuotaTier): number {\n  return BUILD_TIER_CONCURRENCY[tier] ?? BUILD_TIER_CONCURRENCY.developer;\n}\n\n/**\n * The env var that overrides {@link buildWorkerConcurrencyFor} for one tier.\n *\n * Derived rather than written out six times: the per-tier reads used to be six\n * near-identical `envInt` lines, where a wrong cross-reference\n * (`pro: envInt('…_PRO', tierDefault.team)`) silently takes another tier's\n * default and no type can catch it.\n */\nexport function buildConcurrencyEnvVar(tier: QuotaTier): string {\n  return `PLUGIN_BUILD_CONCURRENCY_${tier.toUpperCase()}`;\n}\n\n/** This size's credit/vCPU multiplier; `1` for anything unrecognised. */\nexport function buildSizeMultiplier(size: string): number {\n  return BUILD_SIZE_CATALOG[size as BuildSize]?.multiplier ?? 1;\n}\n\n/** `Small` … `X-Large`; the raw id for anything unrecognised. */\nexport function buildSizeLabel(size: string): string {\n  return BUILD_SIZE_CATALOG[size as BuildSize]?.label ?? size;\n}\n\n/** `Standard` / `Flexible`; the raw id for anything unrecognised. */\nexport function buildClassLabel(buildClass: string): string {\n  return BUILD_CLASS_CATALOG[buildClass as BuildClass]?.label ?? buildClass;\n}\n\n/**\n * Env-var suffix of this size's buildkitd pool override.\n *\n * Declared in the catalog rather than derived, because deriving it produces\n * ILLEGAL NAMES: `'0.5x'.toUpperCase()` is `0.5X`, and a dot cannot appear in an\n * environment variable name. (It is the same reason `x-large` was rejected as an\n * id — `..._X-LARGE` is not an identifier either.) Falls back to `1X`, the\n * shared daemon, for an unrecognised size.\n */\nexport function buildSizeEnvSuffix(size: string): string {\n  return BUILD_SIZE_CATALOG[size as BuildSize]?.envSuffix ?? '1X';\n}\n\n/** The class this size runs in unless the caller overrides it. */\nexport function defaultClassForSize(size: string): BuildClass {\n  return BUILD_SIZE_CATALOG[size as BuildSize]?.defaultClass ?? 'standard';\n}\n\n/**\n * How much longer a build at this size may run before the timeout kills it.\n *\n * Scales UP below `1x` and never down above it, and the asymmetry is the point:\n * the timeout is a SAFETY bound on a runaway build, not a budget. At half the\n * vCPU a ten-minute build becomes about twenty and would die on a 15-minute\n * bound — so Small would quietly fail long builds (as a `retryable` failure, so\n * the tenant is not charged, but it is retried twice and dead-lettered). Scaling\n * it DOWN at `4x` would instead break I/O-bound builds that gain nothing from\n * the extra CPU.\n */\nexport function buildTimeoutFactor(size: string): number {\n  return Math.max(1, 1 / buildSizeMultiplier(size));\n}\n\n/** In-flight builds one org on `tier` may hold in `buildClass` (the default). */\nexport function buildSlotsFor(tier: QuotaTier, buildClass: BuildClass): number {\n  const meta = BUILD_CLASS_CATALOG[buildClass] ?? BUILD_CLASS_CATALOG.standard;\n  return meta.slotsByTier[tier] ?? meta.slotsByTier.developer;\n}\n\n/** Both classes' slot counts for one tier — the per-tier reading the UI wants. */\nexport function buildSlotsByClass(tier: QuotaTier): Readonly<Record<BuildClass, number>> {\n  return {\n    standard: buildSlotsFor(tier, 'standard'),\n    flexible: buildSlotsFor(tier, 'flexible'),\n  };\n}\n\n/** Whether `tier` may request `size`. */\nexport function tierAllowsBuildSize(tier: QuotaTier, size: string): boolean {\n  const meta = BUILD_SIZE_CATALOG[size as BuildSize];\n  if (!meta) return false;\n  if (meta.minTier === null) return true;\n  const have = BUILD_TIER_LADDER.indexOf(tier);\n  // An unrecognised tier gets the FLOOR of the ladder — the smallest allowance,\n  // never everything. Same conservative call `tierForQueueName` makes.\n  if (have < 0) return false;\n  return have >= BUILD_TIER_LADDER.indexOf(meta.minTier);\n}\n\n/** Every size `tier` may request, ascending. */\nexport function buildSizesForTier(tier: QuotaTier): readonly BuildSize[] {\n  return BUILD_SIZES.filter((s) => tierAllowsBuildSize(tier, s));\n}\n"]}

package/lib/types/catalog-metadata.js

@@ -16,4 +16,4 @@ export const LIFECYCLE_STAGES = ['experimental', 'production', 'deprecated'];
 export const CRITICALITY_LEVELS = ['low', 'medium', 'high', 'critical'];
 /** Whether an owner reference points at an individual user or a team/org. */
 export const OWNER_TYPES = ['user', 'team'];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/common.js

@@ -67,4 +67,4 @@ export function isValidQuotaType(value) {
 export function effectiveRootOrgId(payload) {
     return payload.rootOrganizationId ?? payload.organizationId;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAGtC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAyBnD;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,kBAAkB,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;AAiDjG,kFAAkF;AAClF,MAAM,CAAC,MAAM,eAAe,GAA6B,CAAC,MAAM,EAAE,iBAAiB,EAAE,SAAS,CAAC,CAAC;AAChG,MAAM,CAAC,MAAM,UAAU,GAAwB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AACrE,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AAgDxG;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,iBAAiB,EAAE,SAAS,EAAE,cAAc;IAChF,YAAY;IACZ,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;IAC7D,UAAU;CACF,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAwC,MAAM,CAAC,WAAW,CACrF,MAAM,CAAC,OAAO,CAAC,aAAa,CAA2C,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5E,CAAC;AAEzC;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AA2PD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAkE;IAElE,OAAO,OAAO,CAAC,kBAAkB,IAAI,OAAO,CAAC,cAAc,CAAC;AAC9D,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Permission } from './permissions.js';\nimport { QUOTA_CATALOG } from './quota-catalog.js';\nimport type { QuotaTier } from './quota-tiers.js';\n\n/**\n * Capability scope catalog for machine/automation tokens. A scoped token carries\n * exactly one of these instead of role-based permissions; endpoints that accept a\n * scoped identity check it via `hasScope`. Kept a closed union (mirroring\n * {@link Permission}) so a typo on either the mint or the check side is a compile\n * error. Add a value here when introducing a new scoped-token surface.\n *\n * - `reporting:ingest` — the AWS event-ingestion Lambda's writes (`/reports/events`,\n *   `/reports/ingest-health`) and the incident webhook.\n * - `registry:push`    — `docker push` into the owning org's own namespace via\n *   image-registry's `/token` endpoint. Grants the raw-image write that\n *   `plugins:write` grants a person, and nothing else: a scoped token carries no\n *   permissions, so it can neither read the API nor push outside its org.\n * - `scim`             — an identity provider's SCIM 2.0 client (3b) driving\n *   `/scim/v2/Users` and `/scim/v2/Groups` for the key's OWN org. It provisions\n *   and deactivates memberships and moves people between directory groups; it\n *   can never read or write anything else, and — because a scoped token carries\n *   no permissions — it cannot author the group → Role rules its syncs resolve\n *   through. Only a service-account key may carry it; a person's token never does.\n */\nexport type TokenScope = 'reporting:ingest' | 'registry:push' | 'scim';\n\n/**\n * Runtime catalog of {@link TokenScope} (a union is erased at runtime). This is\n * the ONE allowlist every mint path validates against — platform's key/token\n * issue routes included — so a new scope is added in exactly one place.\n */\nexport const TOKEN_SCOPES: readonly TokenScope[] = ['reporting:ingest', 'registry:push', 'scim'];\n\n/**\n * What kind of principal a token speaks for. Auth decisions branch on this claim\n * — never on the shape of `sub` or on which optional claims happen to be present.\n *\n * - `user`            — a person (session, machine session, PAT or impersonation).\n * - `service_account` — a non-human account owned by ONE org, holding org Roles\n *                       and authenticating with a `pb_sa_…` key exchanged at\n *                       platform. Never satisfies an assurance/step-up gate.\n * - `service`         — an internal Pipeline Builder service ({@link signServiceToken}).\n */\nexport type PrincipalType = 'user' | 'service_account' | 'service';\n\n/**\n * How a token is used. `access` is a session-style access token (interactive,\n * machine-session or service); `api_key` is a standalone credential tracked by\n * its own record — a Personal Access Token or a service-account key, named by\n * `jti`.\n */\nexport type TokenUse = 'access' | 'api_key';\n\n/**\n * Authentication methods (`amr`, RFC 8176 style) that established a user's\n * session. `pwd` password sign-in; `oauth` social sign-in (Google, GitHub …);\n * `sso` per-org OIDC single sign-on; `webauthn` a passkey (WebAuthn assertion\n * with user verification); `stepup` a step-up re-verification token; `mfa` a\n * second factor was presented as well — today an authenticator-app code (TOTP)\n * or one of its recovery codes, so it appears ALONGSIDE the method that\n * identified the user (`['pwd', 'mfa']`), never on its own.\n */\nexport type AuthMethod = 'pwd' | 'oauth' | 'sso' | 'webauthn' | 'stepup' | 'mfa';\n\n/**\n * Authenticator assurance level of the session a token speaks for.\n *\n * - `1` — one factor: a password, a social sign-in, or SSO through an IdP the\n *   org has NOT marked as enforcing MFA.\n * - `2` — MFA-grade: a passkey asserted with user verification, a password plus\n *   an authenticator-app code, or SSO through an IdP the org HAS marked as\n *   enforcing MFA (providers don't send `amr` reliably, so the org's own\n *   statement about its IdP is the signal).\n *\n * Fixed when the session is opened and stored on its refresh-session slot, so\n * refresh / renewal / switch-org copy it verbatim and can never RAISE it —\n * earning aal 2 always means authenticating again with a second factor.\n */\nexport type AssuranceLevel = 1 | 2;\n\n/** Runtime catalogs for the claim unions above (a union is erased at runtime). */\nexport const PRINCIPAL_TYPES: readonly PrincipalType[] = ['user', 'service_account', 'service'];\nexport const TOKEN_USES: readonly TokenUse[] = ['access', 'api_key'];\nexport const AUTH_METHODS: readonly AuthMethod[] = ['pwd', 'oauth', 'sso', 'webauthn', 'stepup', 'mfa'];\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths) made by PEOPLE in\n *   INTERACTIVE SESSIONS. Personal access tokens are NOT here: this entry used\n *   to say they were, and {@link meteredQuotaTypeFor} says otherwise.\n * - `automationCalls` — the same metered API calls when the caller is not an\n *   interactive session: an ORG SERVICE ACCOUNT\n *   (`principalType: 'service_account'` — platform-automation,\n *   pipeline-register, reporting-ingest and registry-push keys), a PERSONAL\n *   ACCESS KEY (`token_use: 'api_key'`), or any token minted while holding one\n *   (`parentKeyId`). Counted INSTEAD of `apiCalls`, never as well, so a\n *   self-mutating pipeline doing one plugin lookup per step per run cannot lock\n *   its own humans out of the console (see {@link meteredQuotaTypeFor}, which is\n *   the authority for the split — `docs/quotas.md` agrees with it). Sized for\n *   that traffic per tier.\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n * - `listings` — active, non-suspended plugin-ecosystem listings a (root) org\n *   publishes (docs/plugin-publishing.md). A COUNT quota like\n *   `plugins`: checked at publish-request submit and re-checked at approval;\n *   installs never count.\n */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'automationCalls' | 'aiCalls' | 'storageBytes'\n  | 'cpuCredits'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs'\n  | 'listings';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'automationCalls', 'aiCalls', 'storageBytes',\n  'cpuCredits',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n  'listings',\n] as const;\n\n/**\n * Human label for each quota type, singular — the one spelling every 429 body,\n * notification and dashboard uses (\"API call quota reached …\").\n *\n * DERIVED from `types/quota-catalog.ts`, which is the one place a quota type's\n * display facts live and the one the browser imports directly. This stays here\n * as the server-side name because every service already reads it from the\n * barrel; it is a projection of the catalog, not a second copy of it.\n */\nexport const QUOTA_TYPE_LABELS: Readonly<Record<QuotaType, string>> = Object.fromEntries(\n  (Object.entries(QUOTA_CATALOG) as Array<[QuotaType, { label: string }]>).map(([type, meta]) => [type, meta.label]),\n) as Readonly<Record<QuotaType, string>>;\n\n/**\n * Where a person goes to raise a limit. Relative on purpose: the dashboard and\n * the API share an origin behind nginx, and a CLI / Lambda that renders a 429\n * prefixes it with the platform URL it already talks to.\n */\nexport const QUOTA_UPGRADE_PATH = '/dashboard/billing';\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n  /**\n   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\n/**\n * Coarse per-org membership label, DERIVED from the Roles a user is assigned\n * (the highest `grantsRole` among them; `owner` is set only by ownership\n * transfer). It is a display/authority label — driving `isAdmin`, ownership,\n * and seat accounting — NOT a permission source. Effective permissions come\n * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a\n * global role.\n */\nexport type OrgRole = 'owner' | 'admin' | 'member';\n\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Which kind of principal this token speaks for (see {@link PrincipalType}). */\n  principalType: PrincipalType;\n  /** How the token is used (see {@link TokenUse}); PATs are `api_key`. */\n  token_use: TokenUse;\n  /**\n   * Methods that authenticated the session (user principals). Kept on the\n   * refresh-session slot, so refresh / renew / switch-org carry it unchanged.\n   * Absent on service tokens.\n   */\n  amr?: AuthMethod[];\n  /** Assurance level (user principals). Never raised by refresh / renew / switch-org. */\n  aal?: AssuranceLevel;\n  /** Epoch seconds of the sign-in that established the session (user principals).\n   *  Never reset by refresh / renew / switch-org. */\n  auth_time?: number;\n  /**\n   * The active org REQUIRES MFA and its grace period has passed.\n   *\n   * Carried as a claim so no service has to look the policy up: the org policy\n   * is enforced where the token is ISSUED (a session scoped to such an org gets\n   * `aal: 2` or is refused), and this claim is the record of that decision, for\n   * UI copy and audit rather than for a second enforcement point.\n   */\n  mfaRequired?: boolean;\n  /**\n   * The active org's \"administrative actions require MFA\" policy\n   * (`adminActionsRequireMfa`, strictest across the org and its ancestors).\n   * Present — and always `2` — only when the policy is on. It is resolved when\n   * the token is ISSUED, so services that can't read the org document still know\n   * the policy: `requireOrgAdminAssurance` refuses an `aal: 1` session on an\n   * administrative route when this claim is present. Changing the policy bumps\n   * every affected member's `tokenVersion`, so the claim can't go stale.\n   */\n  org_admin_aal?: 2;\n  /**\n   * BOOTSTRAP-ADMIN EXCEPTION. Set only on a session opened by\n   * the install's bootstrap admin (`BOOTSTRAP_SUPERADMIN_EMAILS`, system org)\n   * while they still have no enrolled factor. Such a session is `aal: 1` and may\n   * reach ONLY enrolment, sign-out and the routes `init-platform.sh` calls;\n   * every other service refuses it outright (see `requireAuth`). The exception\n   * closes permanently at the first enrolment and never reopens.\n   */\n  mfaEnrollmentPending?: boolean;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: OrgRole;\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Resolved fine-grained permissions for the active org/team — the union of\n   * the permissions carried by every Role the user is assigned (see\n   * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are\n   * granted all permissions implicitly and may omit this. Endpoints enforce via\n   * `requirePermission(...)`.\n   */\n  permissions?: Permission[];\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the SOLE signal for sysadmin authority — membership in\n   * the well-known \"system\" org grants nothing, because that would conflate\n   * \"Pipeline Builder operator\" with \"customer tenant\" in the data model.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier. */\n  tier?: QuotaTier;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /**\n   * Narrow capability scope for machine/automation tokens (e.g.\n   * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints\n   * that accept a scoped identity check this (see `hasScope`) instead of role;\n   * a scoped token is minted with minimal role for least-privilege.\n   */\n  scope?: TokenScope;\n  /**\n   * The token's `permissions` were NARROWED to a catalog subset chosen when the\n   * credential was created (a permission-scoped personal access key or machine\n   * token). The claim is the record that `permissions` is the INTERSECTION of\n   * that subset with the holder's current Roles — not their full authority — so\n   * anything the token mints can only be narrower still, and it never carries\n   * `isSuperAdmin` or an admin `role` (both would bypass the subset). Only ever\n   * `true`; absent on unrestricted tokens.\n   */\n  permissionsRestricted?: boolean;\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`\n   * (use the shared {@link effectiveRootOrgId} accessor rather than coalescing inline).\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * Unique token id. On an impersonation token it identifies the SESSION, so it\n   * can be revoked on its own across every service (see\n   * `TokenRevocationStore.getSessionRevocation`). Personal Access Tokens\n   * (`token_use: 'api_key'`) carry one too, validated against their own record.\n   * A `jti` alone never classifies a token — `token_use` and `impersonatorId` do.\n   */\n  jti?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /**\n   * The refresh-session slot (interactive or machine) this access token was\n   * minted with. Revoking that ONE slot publishes `revoke:sid:<sid>` (see\n   * `credentialRevocationKey`), which every service checks in `requireAuth`, so\n   * a single signed-out device / machine credential stops working everywhere\n   * immediately instead of at natural expiry. Absent on PATs and impersonation.\n   */\n  sid?: string;\n  /**\n   * The access key (PAT / service-account key id) this token was DERIVED from,\n   * when it is not itself the exchanged key token (whose key id is its `jti`) —\n   * e.g. a switch-org or generate-token mint made while holding an exchanged\n   * key token. Revoking the key publishes `revoke:key:<keyId>`, which rejects\n   * every token that names it here or as its `jti`.\n   */\n  parentKeyId?: string;\n  /**\n   * SERVICE tokens only: this audit delivery may record an `affectedOrgId`\n   * outside the token's org (see `ServiceTokenOptions.auditCrossOrg`). Honoured\n   * by platform's `/audit/events` ingest alone.\n   */\n  auditCrossOrg?: true;\n  /**\n   * The user's ACCESS version at the moment this token was issued: the hard\n   * `tokenVersion` (deactivate / password change / logout-all — clears slots)\n   * plus `claimsVersion` (role, tier, membership or ownership changes — re-minted\n   * on refresh). Both only grow, so a token whose embedded version is behind the\n   * current one has been REVOKED. Platform validates this against Mongo; the\n   * stateless services validate it against a Redis-published current-version\n   * store (see `setTokenRevocationStore`). Absent on machine/service tokens.\n   */\n  tokenVersion?: number;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * The account boundary (root org) for a token's active org.\n *\n * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org\n * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries\n * the top of its ancestry chain. Every account-scoped read (quota/seat/billing\n * pooling) must resolve through this coalesce rather than reading\n * `organizationId` directly — the latter silently works today (all orgs flat)\n * but would bind to the team instead of the account once teams exist.\n *\n * @returns the effective root org id, or `undefined` when neither field is set.\n */\nexport function effectiveRootOrgId(\n  payload: Pick<JwtPayload, 'organizationId' | 'rootOrganizationId'>,\n): string | undefined {\n  return payload.rootOrganizationId ?? payload.organizationId;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAGtC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAyBnD;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,kBAAkB,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;AAiDjG,kFAAkF;AAClF,MAAM,CAAC,MAAM,eAAe,GAA6B,CAAC,MAAM,EAAE,iBAAiB,EAAE,SAAS,CAAC,CAAC;AAChG,MAAM,CAAC,MAAM,UAAU,GAAwB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AACrE,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AAgDxG;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,iBAAiB,EAAE,SAAS,EAAE,cAAc;IAChF,YAAY;IACZ,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;IAC7D,UAAU;CACF,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAwC,MAAM,CAAC,WAAW,CACrF,MAAM,CAAC,OAAO,CAAC,aAAa,CAA2C,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5E,CAAC;AAEzC;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AA2PD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAkE;IAElE,OAAO,OAAO,CAAC,kBAAkB,IAAI,OAAO,CAAC,cAAc,CAAC;AAC9D,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Permission } from './permissions.js';\nimport { QUOTA_CATALOG } from './quota-catalog.js';\nimport type { QuotaTier } from './quota-tiers.js';\n\n/**\n * Capability scope catalog for machine/automation tokens. A scoped token carries\n * exactly one of these instead of role-based permissions; endpoints that accept a\n * scoped identity check it via `hasScope`. Kept a closed union (mirroring\n * {@link Permission}) so a typo on either the mint or the check side is a compile\n * error. Add a value here when introducing a new scoped-token surface.\n *\n * - `reporting:ingest` — the AWS event-ingestion Lambda's writes (`/reports/events`,\n *   `/reports/ingest-health`) and the incident webhook.\n * - `registry:push`    — `docker push` into the owning org's own namespace via\n *   image-registry's `/token` endpoint. Grants the raw-image write that\n *   `plugins:write` grants a person, and nothing else: a scoped token carries no\n *   permissions, so it can neither read the API nor push outside its org.\n * - `scim`             — an identity provider's SCIM 2.0 client (3b) driving\n *   `/scim/v2/Users` and `/scim/v2/Groups` for the key's OWN org. It provisions\n *   and deactivates memberships and moves people between directory groups; it\n *   can never read or write anything else, and — because a scoped token carries\n *   no permissions — it cannot author the group → Role rules its syncs resolve\n *   through. Only a service-account key may carry it; a person's token never does.\n */\nexport type TokenScope = 'reporting:ingest' | 'registry:push' | 'scim';\n\n/**\n * Runtime catalog of {@link TokenScope} (a union is erased at runtime). This is\n * the ONE allowlist every mint path validates against — platform's key/token\n * issue routes included — so a new scope is added in exactly one place.\n */\nexport const TOKEN_SCOPES: readonly TokenScope[] = ['reporting:ingest', 'registry:push', 'scim'];\n\n/**\n * What kind of principal a token speaks for. Auth decisions branch on this claim\n * — never on the shape of `sub` or on which optional claims happen to be present.\n *\n * - `user`            — a person (session, machine session, PAT or impersonation).\n * - `service_account` — a non-human account owned by ONE org, holding org Roles\n *                       and authenticating with a `pb_sa_…` key exchanged at\n *                       platform. Never satisfies an assurance/step-up gate.\n * - `service`         — an internal Pipeline Builder service ({@link signServiceToken}).\n */\nexport type PrincipalType = 'user' | 'service_account' | 'service';\n\n/**\n * How a token is used. `access` is a session-style access token (interactive,\n * machine-session or service); `api_key` is a standalone credential tracked by\n * its own record — a Personal Access Token or a service-account key, named by\n * `jti`.\n */\nexport type TokenUse = 'access' | 'api_key';\n\n/**\n * Authentication methods (`amr`, RFC 8176 style) that established a user's\n * session. `pwd` password sign-in; `oauth` social sign-in (Google, GitHub …);\n * `sso` per-org OIDC single sign-on; `webauthn` a passkey (WebAuthn assertion\n * with user verification); `stepup` a step-up re-verification token; `mfa` a\n * second factor was presented as well — today an authenticator-app code (TOTP)\n * or one of its recovery codes, so it appears ALONGSIDE the method that\n * identified the user (`['pwd', 'mfa']`), never on its own.\n */\nexport type AuthMethod = 'pwd' | 'oauth' | 'sso' | 'webauthn' | 'stepup' | 'mfa';\n\n/**\n * Authenticator assurance level of the session a token speaks for.\n *\n * - `1` — one factor: a password, a social sign-in, or SSO through an IdP the\n *   org has NOT marked as enforcing MFA.\n * - `2` — MFA-grade: a passkey asserted with user verification, a password plus\n *   an authenticator-app code, or SSO through an IdP the org HAS marked as\n *   enforcing MFA (providers don't send `amr` reliably, so the org's own\n *   statement about its IdP is the signal).\n *\n * Fixed when the session is opened and stored on its refresh-session slot, so\n * refresh / renewal / switch-org copy it verbatim and can never RAISE it —\n * earning aal 2 always means authenticating again with a second factor.\n */\nexport type AssuranceLevel = 1 | 2;\n\n/** Runtime catalogs for the claim unions above (a union is erased at runtime). */\nexport const PRINCIPAL_TYPES: readonly PrincipalType[] = ['user', 'service_account', 'service'];\nexport const TOKEN_USES: readonly TokenUse[] = ['access', 'api_key'];\nexport const AUTH_METHODS: readonly AuthMethod[] = ['pwd', 'oauth', 'sso', 'webauthn', 'stepup', 'mfa'];\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths) made by PEOPLE in\n *   INTERACTIVE SESSIONS. Personal access tokens are NOT here: this entry used\n *   to say they were, and {@link meteredQuotaTypeFor} says otherwise.\n * - `automationCalls` — the same metered API calls when the caller is not an\n *   interactive session: an ORG SERVICE ACCOUNT\n *   (`principalType: 'service_account'` — platform-automation,\n *   pipeline-register, reporting-ingest and registry-push keys), a PERSONAL\n *   ACCESS KEY (`token_use: 'api_key'`), or any token minted while holding one\n *   (`parentKeyId`). Counted INSTEAD of `apiCalls`, never as well, so a\n *   self-mutating pipeline doing one plugin lookup per step per run cannot lock\n *   its own humans out of the console (see {@link meteredQuotaTypeFor}, which is\n *   the authority for the split — `docs/quotas.md` agrees with it). Sized for\n *   that traffic per tier.\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n * - `listings` — active, non-suspended plugin-ecosystem listings a (root) org\n *   publishes (docs/plugin-publishing.md). A COUNT quota like\n *   `plugins`: checked at publish-request submit and re-checked at approval;\n *   installs never count.\n */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'automationCalls' | 'aiCalls' | 'storageBytes'\n  | 'cpuCredits'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs'\n  | 'listings';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'automationCalls', 'aiCalls', 'storageBytes',\n  'cpuCredits',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n  'listings',\n] as const;\n\n/**\n * Human label for each quota type, singular — the one spelling every 429 body,\n * notification and dashboard uses (\"API call quota reached …\").\n *\n * DERIVED from `types/quota-catalog.ts`, which is the one place a quota type's\n * display facts live and the one the browser imports directly. This stays here\n * as the server-side name because every service already reads it from the\n * barrel; it is a projection of the catalog, not a second copy of it.\n */\nexport const QUOTA_TYPE_LABELS: Readonly<Record<QuotaType, string>> = Object.fromEntries(\n  (Object.entries(QUOTA_CATALOG) as Array<[QuotaType, { label: string }]>).map(([type, meta]) => [type, meta.label]),\n) as Readonly<Record<QuotaType, string>>;\n\n/**\n * Where a person goes to raise a limit. Relative on purpose: the dashboard and\n * the API share an origin behind nginx, and a CLI / Lambda that renders a 429\n * prefixes it with the platform URL it already talks to.\n */\nexport const QUOTA_UPGRADE_PATH = '/dashboard/billing';\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n  /**\n   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\n/**\n * Coarse per-org membership label, DERIVED from the Roles a user is assigned\n * (the highest `grantsRole` among them; `owner` is set only by ownership\n * transfer). It is a display/authority label — driving `isAdmin`, ownership,\n * and seat accounting — NOT a permission source. Effective permissions come\n * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a\n * global role.\n */\nexport type OrgRole = 'owner' | 'admin' | 'member';\n\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Which kind of principal this token speaks for (see {@link PrincipalType}). */\n  principalType: PrincipalType;\n  /** How the token is used (see {@link TokenUse}); PATs are `api_key`. */\n  token_use: TokenUse;\n  /**\n   * Methods that authenticated the session (user principals). Kept on the\n   * refresh-session slot, so refresh / renew / switch-org carry it unchanged.\n   * Absent on service tokens.\n   */\n  amr?: AuthMethod[];\n  /** Assurance level (user principals). Never raised by refresh / renew / switch-org. */\n  aal?: AssuranceLevel;\n  /** Epoch seconds of the sign-in that established the session (user principals).\n   *  Never reset by refresh / renew / switch-org. */\n  auth_time?: number;\n  /**\n   * The active org REQUIRES MFA and its grace period has passed.\n   *\n   * Carried as a claim so no service has to look the policy up: the org policy\n   * is enforced where the token is ISSUED (a session scoped to such an org gets\n   * `aal: 2` or is refused), and this claim is the record of that decision, for\n   * UI copy and audit rather than for a second enforcement point.\n   */\n  mfaRequired?: boolean;\n  /**\n   * The active org's \"administrative actions require MFA\" policy\n   * (`adminActionsRequireMfa`, strictest across the org and its ancestors).\n   * Present — and always `2` — only when the policy is on. It is resolved when\n   * the token is ISSUED, so services that can't read the org document still know\n   * the policy: `requireOrgAdminAssurance` refuses an `aal: 1` session on an\n   * administrative route when this claim is present. Changing the policy bumps\n   * every affected member's `tokenVersion`, so the claim can't go stale.\n   */\n  org_admin_aal?: 2;\n  /**\n   * BOOTSTRAP-ADMIN EXCEPTION. Set only on a session opened by\n   * the install's bootstrap admin (`BOOTSTRAP_SUPERADMIN_EMAILS`, system org)\n   * while they still have no enrolled factor. Such a session is `aal: 1` and may\n   * reach ONLY enrolment, sign-out and the routes `init-platform.sh` calls;\n   * every other service refuses it outright (see `requireAuth`). The exception\n   * closes permanently at the first enrolment and never reopens.\n   */\n  mfaEnrollmentPending?: boolean;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: OrgRole;\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Resolved fine-grained permissions for the active org/team — the union of\n   * the permissions carried by every Role the user is assigned (see\n   * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are\n   * granted all permissions implicitly and may omit this. Endpoints enforce via\n   * `requirePermission(...)`.\n   */\n  permissions?: Permission[];\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the SOLE signal for sysadmin authority — membership in\n   * the well-known \"system\" org grants nothing, because that would conflate\n   * \"Pipeline Builder operator\" with \"customer tenant\" in the data model.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier. */\n  tier?: QuotaTier;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /**\n   * Narrow capability scope for machine/automation tokens (e.g.\n   * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints\n   * that accept a scoped identity check this (see `hasScope`) instead of role;\n   * a scoped token is minted with minimal role for least-privilege.\n   */\n  scope?: TokenScope;\n  /**\n   * The token's `permissions` were NARROWED to a catalog subset chosen when the\n   * credential was created (a permission-scoped personal access key or machine\n   * token). The claim is the record that `permissions` is the INTERSECTION of\n   * that subset with the holder's current Roles — not their full authority — so\n   * anything the token mints can only be narrower still, and it never carries\n   * `isSuperAdmin` or an admin `role` (both would bypass the subset). Only ever\n   * `true`; absent on unrestricted tokens.\n   */\n  permissionsRestricted?: boolean;\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`\n   * (use the shared {@link effectiveRootOrgId} accessor rather than coalescing inline).\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * Unique token id. On an impersonation token it identifies the SESSION, so it\n   * can be revoked on its own across every service (see\n   * `TokenRevocationStore.getSessionRevocation`). Personal Access Tokens\n   * (`token_use: 'api_key'`) carry one too, validated against their own record.\n   * A `jti` alone never classifies a token — `token_use` and `impersonatorId` do.\n   */\n  jti?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /**\n   * The refresh-session slot (interactive or machine) this access token was\n   * minted with. Revoking that ONE slot publishes `revoke:sid:<sid>` (see\n   * `credentialRevocationKey`), which every service checks in `requireAuth`, so\n   * a single signed-out device / machine credential stops working everywhere\n   * immediately instead of at natural expiry. Absent on PATs and impersonation.\n   */\n  sid?: string;\n  /**\n   * The access key (PAT / service-account key id) this token was DERIVED from,\n   * when it is not itself the exchanged key token (whose key id is its `jti`) —\n   * e.g. a switch-org or generate-token mint made while holding an exchanged\n   * key token. Revoking the key publishes `revoke:key:<keyId>`, which rejects\n   * every token that names it here or as its `jti`.\n   */\n  parentKeyId?: string;\n  /**\n   * SERVICE tokens only: this audit delivery may record an `affectedOrgId`\n   * outside the token's org (see `ServiceTokenOptions.auditCrossOrg`). Honoured\n   * by platform's `/audit/events` ingest alone.\n   */\n  auditCrossOrg?: true;\n  /**\n   * The user's ACCESS version at the moment this token was issued: the hard\n   * `tokenVersion` (deactivate / password change / logout-all — clears slots)\n   * plus `claimsVersion` (role, tier, membership or ownership changes — re-minted\n   * on refresh). Both only grow, so a token whose embedded version is behind the\n   * current one has been REVOKED. Platform validates this against Mongo; the\n   * stateless services validate it against a Redis-published current-version\n   * store (see `setTokenRevocationStore`). Absent on machine/service tokens.\n   */\n  tokenVersion?: number;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * The account boundary (root org) for a token's active org.\n *\n * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org\n * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries\n * the top of its ancestry chain. Every account-scoped read (quota/seat/billing\n * pooling) must resolve through this coalesce rather than reading\n * `organizationId` directly — the latter silently works today (all orgs flat)\n * but would bind to the team instead of the account once teams exist.\n *\n * @returns the effective root org id, or `undefined` when neither field is set.\n */\nexport function effectiveRootOrgId(\n  payload: Pick<JwtPayload, 'organizationId' | 'rootOrganizationId'>,\n): string | undefined {\n  return payload.rootOrganizationId ?? payload.organizationId;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}

package/lib/types/compliance-exemption.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGxpYW5jZS1leGVtcHRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvY29tcGxpYW5jZS1leGVtcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFRoZSBgUE9TVCAvY29tcGxpYW5jZS9leGVtcHRpb25zYCByZXF1ZXN0IGJvZHkuXG4gKlxuICogSXQgbGl2ZXMgaGVyZSBiZWNhdXNlIGl0IGNyb3NzZXMgYSBTRVJWSUNFIGJvdW5kYXJ5OiB0aGUgQXNrIGFnZW50IGRyYWZ0cyBvbmVcbiAqIChgYXBpL2Fza2Ag4oCUIGEgcHJvcG9zYWwgdGhlIHVzZXIgcmV2aWV3cyBhbmQgY29tbWl0cyB0aHJvdWdoIHRoZWlyIG93blxuICogc2Vzc2lvbikgYW5kIHRoZSBjb21wbGlhbmNlIHNlcnZpY2UgaW5zZXJ0cyBpdCAoYGFwaS9jb21wbGlhbmNlYCkuIEVhY2ggc2lkZVxuICogaGFkIGl0cyBvd24gc2l4LWZpZWxkIGRlY2xhcmF0aW9uLCBzbyBhIGZpZWxkIGFkZGVkIG9uIG9uZSBzaWRlIHdhcyBpbnZpc2libGVcbiAqIHRvIHRoZSBvdGhlciB1bnRpbCBhIHJlcXVlc3QgZmFpbGVkIHZhbGlkYXRpb24gYXQgcnVudGltZS5cbiAqL1xuXG4vKiogQSByZXF1ZXN0IHRvIHdhaXZlIG9uZSBjb21wbGlhbmNlIHJ1bGUgZm9yIG9uZSBlbnRpdHkuICovXG5leHBvcnQgaW50ZXJmYWNlIENvbXBsaWFuY2VFeGVtcHRpb25SZXF1ZXN0IHtcbiAgLyoqIFRoZSBydWxlIGJlaW5nIHdhaXZlZC4gKi9cbiAgcnVsZUlkOiBzdHJpbmc7XG4gIC8qKiBXaGljaCBraW5kIG9mIGVudGl0eSB0aGUgd2FpdmVyIGNvdmVycy4gKi9cbiAgZW50aXR5VHlwZTogJ3BsdWdpbicgfCAncGlwZWxpbmUnO1xuICAvKiogVGhlIGVudGl0eSB0aGUgd2FpdmVyIGFwcGxpZXMgdG8uICovXG4gIGVudGl0eUlkOiBzdHJpbmc7XG4gIC8qKiBEaXNwbGF5IGxhYmVsIGZvciB0aGUgZW50aXR5LCBmb3IgdGhlIHJldmlldyBxdWV1ZSBhbmQgdGhlIGF1ZGl0IHRyYWlsLiAqL1xuICBlbnRpdHlOYW1lPzogc3RyaW5nO1xuICAvKiogV2h5IHRoZSB3YWl2ZXIgaXMgYmVpbmcgYXNrZWQgZm9yOyBzaG93biB0byB0aGUgYXBwcm92ZXIuICovXG4gIHJlYXNvbjogc3RyaW5nO1xuICAvKiogSVNPLTg2MDEgZXhwaXJ5LiBPbWl0dGVkIG1lYW5zIHRoZSB3YWl2ZXIgZG9lcyBub3Qgc2VsZi1leHBpcmUuICovXG4gIGV4cGlyZXNBdD86IHN0cmluZztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGxpYW5jZS1leGVtcHRpb24uanMiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9jb21wbGlhbmNlLWV4ZW1wdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbi8qKlxuICogVGhlIGBQT1NUIC9jb21wbGlhbmNlL2V4ZW1wdGlvbnNgIHJlcXVlc3QgYm9keS5cbiAqXG4gKiBJdCBsaXZlcyBoZXJlIGJlY2F1c2UgaXQgY3Jvc3NlcyBhIFNFUlZJQ0UgYm91bmRhcnk6IHRoZSBBc2sgYWdlbnQgZHJhZnRzIG9uZVxuICogKGBhcGkvYXNrYCDigJQgYSBwcm9wb3NhbCB0aGUgdXNlciByZXZpZXdzIGFuZCBjb21taXRzIHRocm91Z2ggdGhlaXIgb3duXG4gKiBzZXNzaW9uKSBhbmQgdGhlIGNvbXBsaWFuY2Ugc2VydmljZSBpbnNlcnRzIGl0IChgYXBpL2NvbXBsaWFuY2VgKS4gRWFjaCBzaWRlXG4gKiBoYWQgaXRzIG93biBzaXgtZmllbGQgZGVjbGFyYXRpb24sIHNvIGEgZmllbGQgYWRkZWQgb24gb25lIHNpZGUgd2FzIGludmlzaWJsZVxuICogdG8gdGhlIG90aGVyIHVudGlsIGEgcmVxdWVzdCBmYWlsZWQgdmFsaWRhdGlvbiBhdCBydW50aW1lLlxuICovXG5cbi8qKiBBIHJlcXVlc3QgdG8gd2FpdmUgb25lIGNvbXBsaWFuY2UgcnVsZSBmb3Igb25lIGVudGl0eS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29tcGxpYW5jZUV4ZW1wdGlvblJlcXVlc3Qge1xuICAvKiogVGhlIHJ1bGUgYmVpbmcgd2FpdmVkLiAqL1xuICBydWxlSWQ6IHN0cmluZztcbiAgLyoqIFdoaWNoIGtpbmQgb2YgZW50aXR5IHRoZSB3YWl2ZXIgY292ZXJzLiAqL1xuICBlbnRpdHlUeXBlOiAncGx1Z2luJyB8ICdwaXBlbGluZSc7XG4gIC8qKiBUaGUgZW50aXR5IHRoZSB3YWl2ZXIgYXBwbGllcyB0by4gKi9cbiAgZW50aXR5SWQ6IHN0cmluZztcbiAgLyoqIERpc3BsYXkgbGFiZWwgZm9yIHRoZSBlbnRpdHksIGZvciB0aGUgcmV2aWV3IHF1ZXVlIGFuZCB0aGUgYXVkaXQgdHJhaWwuICovXG4gIGVudGl0eU5hbWU/OiBzdHJpbmc7XG4gIC8qKiBXaHkgdGhlIHdhaXZlciBpcyBiZWluZyBhc2tlZCBmb3I7IHNob3duIHRvIHRoZSBhcHByb3Zlci4gKi9cbiAgcmVhc29uOiBzdHJpbmc7XG4gIC8qKiBJU08tODYwMSBleHBpcnkuIE9taXR0ZWQgbWVhbnMgdGhlIHdhaXZlciBkb2VzIG5vdCBzZWxmLWV4cGlyZS4gKi9cbiAgZXhwaXJlc0F0Pzogc3RyaW5nO1xufVxuIl19

package/lib/types/ecosystem-notifications.d.ts

@@ -146,6 +146,15 @@ export declare function renderEcosystemManagerChange(input: {
     added: boolean;
     /** Who made the change (superadmins only can), when known. */
     actor?: string;
+    /**
+     * The Role actually granted. This notice fires for ANY Role carrying a
+     * system-org-only permission — `ecosystemRoleName` returns whichever one it
+     * is — so hard-coding "Ecosystem Manager" announced staffing **Console
+     * Administrator** (a read/write shell over every tenant's rows) or **Support
+     * Lead** (`impersonation:open`) as a plugin-moderation grant. The audit row
+     * had the name all along; the message operators actually read did not.
+     */
+    role?: string;
 }): EcosystemNotificationContent;
 /**
  * Coalesce several queued notices into one digest email: a count-bearing