@pipeline-builder/api-core 4.1.3 → 4.1.4

package/lib/testing/user-tokens.js

@@ -0,0 +1,115 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Test helpers for the ES256 user-token chain.
+ *
+ * Before #5 every suite that needed an authenticated request just signed a JWT
+ * with a literal `JWT_SECRET` — one line, and seventeen independent copies of
+ * it. User tokens are asymmetric now, which needs a keypair, a `kid` and a JWKS
+ * the verifier can fetch, so that per-suite copy-paste would be ~15 lines each.
+ * Hence one shared seam, in api-core next to the route-coverage helper, imported
+ * by the suites of every package:
+ *
+ * ```ts
+ * import { installTestJwks, signTestUserToken } from '@pipeline-builder/api-core/lib/testing/user-tokens.js';
+ *
+ * const jwks = installTestJwks();
+ * const token = signTestUserToken({ sub: 'u1', role: 'member', ... });
+ * ```
+ *
+ * `installTestJwks` replaces the process-wide JWKS cache with one backed by the
+ * generated keys — no HTTP, and it counts fetches so a test can assert the
+ * refresh / unknown-`kid` / negative-cache behaviour.
+ */
+import crypto, {} from 'crypto';
+import { JwksCache, setPlatformJwksCache } from '../services/jwks-cache.js';
+import { USER_TOKEN_ALGORITHM, publicJwkFrom } from '../utils/jwk.js';
+/** Generate one EC P-256 signing key, `kid` = its RFC 7638 thumbprint. */
+export function generateTestSigningKey() {
+    const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'prime256v1' });
+    const jwk = publicJwkFrom(publicKey);
+    return { kid: jwk.kid, privateKey, publicKey, jwk };
+}
+/**
+ * Sign `payload` as an ES256 JWT with `key`. `expiresIn` seconds (default 300).
+ * Synchronous — `crypto.sign` is, and platform's async signer only exists
+ * because KMS is a network call — so a suite can mint a token inline wherever it
+ * used to call `jwt.sign`.
+ */
+export function signTestUserToken(payload, options = {
+    key: defaultKey(),
+}) {
+    const key = options.key ?? defaultKey();
+    const now = Math.floor(Date.now() / 1000);
+    const body = {
+        ...payload,
+        iat: payload.iat ?? now,
+        exp: payload.exp ?? now + (options.expiresIn ?? 300),
+        ...(options.notBefore !== undefined ? { nbf: now + options.notBefore } : {}),
+        ...(options.issuer ? { iss: options.issuer } : {}),
+        ...(options.audience ? { aud: options.audience } : {}),
+    };
+    const b64 = (value) => Buffer.from(JSON.stringify(value), 'utf-8').toString('base64url');
+    const signingInput = `${b64({ alg: USER_TOKEN_ALGORITHM, typ: 'JWT', kid: options.kid ?? key.kid })}.${b64(body)}`;
+    const signature = crypto.sign('sha256', Buffer.from(signingInput, 'utf-8'), {
+        key: key.privateKey,
+        dsaEncoding: 'ieee-p1363',
+    });
+    return `${signingInput}.${signature.toString('base64url')}`;
+}
+/** The claim block a USER principal must carry to satisfy `hasValidIdentityClaims`. */
+export function testUserIdentityClaims() {
+    return {
+        type: 'access',
+        principalType: 'user',
+        token_use: 'access',
+        amr: ['pwd'],
+        aal: 1,
+        auth_time: Math.floor(Date.now() / 1000),
+    };
+}
+let installed;
+function defaultKey() {
+    if (!installed)
+        throw new Error('installTestJwks() must be called before signing a test user token');
+    return installed.primary;
+}
+/**
+ * Install a JWKS cache backed by freshly generated keys (or `keys` when given)
+ * as the process-wide one, and return a handle over it. Call in `beforeEach`;
+ * `uninstallTestJwks()` restores the real HTTP-backed cache.
+ */
+export function installTestJwks(keys = [generateTestSigningKey()], cacheOptions = {}) {
+    let published = keys;
+    let fetches = 0;
+    let failures = 0;
+    const handle = {
+        get keys() { return published; },
+        get primary() { return published[0]; },
+        fetchCount: () => fetches,
+        failNextFetches: (count) => { failures = count; },
+        publish: (next) => { published = next; },
+        document: () => ({ keys: published.map((k) => k.jwk) }),
+    };
+    const cache = new JwksCache({
+        source: 'test',
+        fetch: async () => {
+            fetches += 1;
+            if (failures > 0) {
+                failures -= 1;
+                throw new Error('test JWKS fetch failure');
+            }
+            return handle.document();
+        },
+        ...cacheOptions,
+    });
+    setPlatformJwksCache(cache);
+    installed = handle;
+    return handle;
+}
+/** Restore the real (HTTP-backed) JWKS cache. */
+export function uninstallTestJwks() {
+    setPlatformJwksCache(undefined);
+    installed = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-tokens.js","sourceRoot":"","sources":["../../src/testing/user-tokens.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Test helpers for the ES256 user-token chain.\n *\n * Before #5 every suite that needed an authenticated request just signed a JWT\n * with a literal `JWT_SECRET` — one line, and seventeen independent copies of\n * it. User tokens are asymmetric now, which needs a keypair, a `kid` and a JWKS\n * the verifier can fetch, so that per-suite copy-paste would be ~15 lines each.\n * Hence one shared seam, in api-core next to the route-coverage helper, imported\n * by the suites of every package:\n *\n * ```ts\n * import { installTestJwks, signTestUserToken } from '@pipeline-builder/api-core/lib/testing/user-tokens.js';\n *\n * const jwks = installTestJwks();\n * const token = signTestUserToken({ sub: 'u1', role: 'member', ... });\n * ```\n *\n * `installTestJwks` replaces the process-wide JWKS cache with one backed by the\n * generated keys — no HTTP, and it counts fetches so a test can assert the\n * refresh / unknown-`kid` / negative-cache behaviour.\n */\n\nimport crypto, { type KeyObject } from 'crypto';\nimport { JwksCache, setPlatformJwksCache } from '../services/jwks-cache.js';\nimport { USER_TOKEN_ALGORITHM, publicJwkFrom, type JwksDocument, type PublicJwk } from '../utils/jwk.js';\n\n/** A generated signing key, in every form the tests need. */\nexport interface TestSigningKey {\n  kid: string;\n  privateKey: KeyObject;\n  publicKey: KeyObject;\n  jwk: PublicJwk;\n}\n\n/** Generate one EC P-256 signing key, `kid` = its RFC 7638 thumbprint. */\nexport function generateTestSigningKey(): TestSigningKey {\n  const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'prime256v1' });\n  const jwk = publicJwkFrom(publicKey);\n  return { kid: jwk.kid, privateKey, publicKey, jwk };\n}\n\n/**\n * Sign `payload` as an ES256 JWT with `key`. `expiresIn` seconds (default 300).\n * Synchronous — `crypto.sign` is, and platform's async signer only exists\n * because KMS is a network call — so a suite can mint a token inline wherever it\n * used to call `jwt.sign`.\n */\nexport function signTestUserToken(\n  payload: Record<string, unknown>,\n  options: { key: TestSigningKey; expiresIn?: number; issuer?: string; audience?: string; kid?: string; notBefore?: number } = {\n    key: defaultKey(),\n  },\n): string {\n  const key = options.key ?? defaultKey();\n  const now = Math.floor(Date.now() / 1000);\n  const body: Record<string, unknown> = {\n    ...payload,\n    iat: payload.iat ?? now,\n    exp: payload.exp ?? now + (options.expiresIn ?? 300),\n    ...(options.notBefore !== undefined ? { nbf: now + options.notBefore } : {}),\n    ...(options.issuer ? { iss: options.issuer } : {}),\n    ...(options.audience ? { aud: options.audience } : {}),\n  };\n  const b64 = (value: unknown) => Buffer.from(JSON.stringify(value), 'utf-8').toString('base64url');\n  const signingInput = `${b64({ alg: USER_TOKEN_ALGORITHM, typ: 'JWT', kid: options.kid ?? key.kid })}.${b64(body)}`;\n  const signature = crypto.sign('sha256', Buffer.from(signingInput, 'utf-8'), {\n    key: key.privateKey,\n    dsaEncoding: 'ieee-p1363',\n  });\n  return `${signingInput}.${signature.toString('base64url')}`;\n}\n\n/** The claim block a USER principal must carry to satisfy `hasValidIdentityClaims`. */\nexport function testUserIdentityClaims(): Record<string, unknown> {\n  return {\n    type: 'access',\n    principalType: 'user',\n    token_use: 'access',\n    amr: ['pwd'],\n    aal: 1,\n    auth_time: Math.floor(Date.now() / 1000),\n  };\n}\n\n/** Handle over the installed test JWKS — lets a test rotate keys and count fetches. */\nexport interface TestJwksHandle {\n  /** Keys currently published. */\n  keys: TestSigningKey[];\n  /** The first published key — what `signTestUserToken` uses by default. */\n  primary: TestSigningKey;\n  /** How many times the verifier has fetched the document. */\n  fetchCount(): number;\n  /** Make the next fetch(es) fail, to exercise the negative cache / fail-closed paths. */\n  failNextFetches(count: number): void;\n  /** Replace the published set (a rotation), leaving the cache to notice. */\n  publish(keys: TestSigningKey[]): void;\n  /** The document as the verifier sees it. */\n  document(): JwksDocument;\n}\n\nlet installed: TestJwksHandle | undefined;\n\nfunction defaultKey(): TestSigningKey {\n  if (!installed) throw new Error('installTestJwks() must be called before signing a test user token');\n  return installed.primary;\n}\n\n/**\n * Install a JWKS cache backed by freshly generated keys (or `keys` when given)\n * as the process-wide one, and return a handle over it. Call in `beforeEach`;\n * `uninstallTestJwks()` restores the real HTTP-backed cache.\n */\nexport function installTestJwks(\n  keys: TestSigningKey[] = [generateTestSigningKey()],\n  cacheOptions: { refreshIntervalMs?: number; negativeTtlMs?: number; unknownKidCooldownMs?: number } = {},\n): TestJwksHandle {\n  let published = keys;\n  let fetches = 0;\n  let failures = 0;\n\n  const handle: TestJwksHandle = {\n    get keys() { return published; },\n    get primary() { return published[0]; },\n    fetchCount: () => fetches,\n    failNextFetches: (count: number) => { failures = count; },\n    publish: (next: TestSigningKey[]) => { published = next; },\n    document: () => ({ keys: published.map((k) => k.jwk) }),\n  };\n\n  const cache = new JwksCache({\n    source: 'test',\n    fetch: async () => {\n      fetches += 1;\n      if (failures > 0) {\n        failures -= 1;\n        throw new Error('test JWKS fetch failure');\n      }\n      return handle.document();\n    },\n    ...cacheOptions,\n  });\n  setPlatformJwksCache(cache);\n  installed = handle;\n  return handle;\n}\n\n/** Restore the real (HTTP-backed) JWKS cache. */\nexport function uninstallTestJwks(): void {\n  setPlatformJwksCache(undefined);\n  installed = undefined;\n}\n"]}

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

@@ -11,8 +11,6 @@
 /** Lifecycle stage of a catalog entity. */
 export declare const LIFECYCLE_STAGES: readonly ['experimental', 'production', 'deprecated'];
 export type Lifecycle = (typeof LIFECYCLE_STAGES)[number];
-/** Default lifecycle applied when none is supplied (matches the DB column default). */
-export declare const DEFAULT_LIFECYCLE: Lifecycle;
 /** Operational criticality of a catalog entity (optional/unset by default). */
 export declare const CRITICALITY_LEVELS: readonly ['low', 'medium', 'high', 'critical'];
 export type Criticality = (typeof CRITICALITY_LEVELS)[number];

package/lib/types/catalog-metadata.js

@@ -12,10 +12,8 @@
  */
 /** Lifecycle stage of a catalog entity. */
 export const LIFECYCLE_STAGES = ['experimental', 'production', 'deprecated'];
-/** Default lifecycle applied when none is supplied (matches the DB column default). */
-export const DEFAULT_LIFECYCLE = 'production';
 /** Operational criticality of a catalog entity (optional/unset by default). */
 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.d.ts

@@ -6,8 +6,74 @@ import type { QuotaTier } from './quota-tiers.js';
  * scoped identity check it via `hasScope`. Kept a closed union (mirroring
  * {@link Permission}) so a typo on either the mint or the check side is a compile
  * error. Add a value here when introducing a new scoped-token surface.
+ *
+ * - `reporting:ingest` — the AWS event-ingestion Lambda's writes (`/reports/events`,
+ *   `/reports/ingest-health`) and the incident webhook.
+ * - `registry:push`    — `docker push` into the owning org's own namespace via
+ *   image-registry's `/token` endpoint. Grants the raw-image write that
+ *   `plugins:write` grants a person, and nothing else: a scoped token carries no
+ *   permissions, so it can neither read the API nor push outside its org.
+ * - `scim`             — an identity provider's SCIM 2.0 client (3b) driving
+ *   `/scim/v2/Users` and `/scim/v2/Groups` for the key's OWN org. It provisions
+ *   and deactivates memberships and moves people between directory groups; it
+ *   can never read or write anything else, and — because a scoped token carries
+ *   no permissions — it cannot author the group → Role rules its syncs resolve
+ *   through. Only a service-account key may carry it; a person's token never does.
+ */
+export type TokenScope = 'reporting:ingest' | 'registry:push' | 'scim';
+/**
+ * Runtime catalog of {@link TokenScope} (a union is erased at runtime). This is
+ * the ONE allowlist every mint path validates against — platform's key/token
+ * issue routes included — so a new scope is added in exactly one place.
+ */
+export declare const TOKEN_SCOPES: readonly TokenScope[];
+/**
+ * What kind of principal a token speaks for. Auth decisions branch on this claim
+ * — never on the shape of `sub` or on which optional claims happen to be present.
+ *
+ * - `user`            — a person (session, machine session, PAT or impersonation).
+ * - `service_account` — a non-human account owned by ONE org, holding org Roles
+ *                       and authenticating with a `pb_sa_…` key exchanged at
+ *                       platform. Never satisfies an assurance/step-up gate.
+ * - `service`         — an internal Pipeline Builder service ({@link signServiceToken}).
+ */
+export type PrincipalType = 'user' | 'service_account' | 'service';
+/**
+ * How a token is used. `access` is a session-style access token (interactive,
+ * machine-session or service); `api_key` is a standalone credential tracked by
+ * its own record — a Personal Access Token or a service-account key, named by
+ * `jti`.
+ */
+export type TokenUse = 'access' | 'api_key';
+/**
+ * Authentication methods (`amr`, RFC 8176 style) that established a user's
+ * session. `pwd` password sign-in; `oauth` social sign-in (Google, GitHub …);
+ * `sso` per-org OIDC single sign-on; `webauthn` a passkey (WebAuthn assertion
+ * with user verification); `stepup` a step-up re-verification token; `mfa` a
+ * second factor was presented as well — today an authenticator-app code (TOTP)
+ * or one of its recovery codes, so it appears ALONGSIDE the method that
+ * identified the user (`['pwd', 'mfa']`), never on its own.
  */
-export type TokenScope = 'reporting:ingest';
+export type AuthMethod = 'pwd' | 'oauth' | 'sso' | 'webauthn' | 'stepup' | 'mfa';
+/**
+ * Authenticator assurance level of the session a token speaks for (#8).
+ *
+ * - `1` — one factor: a password, a social sign-in, or SSO through an IdP the
+ *   org has NOT marked as enforcing MFA.
+ * - `2` — MFA-grade: a passkey asserted with user verification, a password plus
+ *   an authenticator-app code, or SSO through an IdP the org HAS marked as
+ *   enforcing MFA (providers don't send `amr` reliably, so the org's own
+ *   statement about its IdP is the signal).
+ *
+ * Fixed when the session is opened and stored on its refresh-session slot, so
+ * refresh / renewal / switch-org copy it verbatim and can never RAISE it —
+ * earning aal 2 always means authenticating again with a second factor.
+ */
+export type AssuranceLevel = 1 | 2;
+/** Runtime catalogs for the claim unions above (a union is erased at runtime). */
+export declare const PRINCIPAL_TYPES: readonly PrincipalType[];
+export declare const TOKEN_USES: readonly TokenUse[];
+export declare const AUTH_METHODS: readonly AuthMethod[];
 /**
  * Quota type identifiers.
  *
@@ -132,6 +198,39 @@ export interface JwtPayload {
     username: string;
     /** User email */
     email: string;
+    /** Which kind of principal this token speaks for (see {@link PrincipalType}). */
+    principalType: PrincipalType;
+    /** How the token is used (see {@link TokenUse}); PATs are `api_key`. */
+    token_use: TokenUse;
+    /**
+     * Methods that authenticated the session (user principals). Kept on the
+     * refresh-session slot, so refresh / renew / switch-org carry it unchanged.
+     * Absent on service tokens.
+     */
+    amr?: AuthMethod[];
+    /** Assurance level (user principals). Never raised by refresh / renew / switch-org. */
+    aal?: AssuranceLevel;
+    /** Epoch seconds of the sign-in that established the session (user principals).
+     *  Never reset by refresh / renew / switch-org. */
+    auth_time?: number;
+    /**
+     * The active org REQUIRES MFA and its grace period has passed (#8).
+     *
+     * Carried as a claim so no service has to look the policy up: the org policy
+     * is enforced where the token is ISSUED (a session scoped to such an org gets
+     * `aal: 2` or is refused), and this claim is the record of that decision, for
+     * UI copy and audit rather than for a second enforcement point.
+     */
+    mfaRequired?: boolean;
+    /**
+     * BOOTSTRAP-ADMIN EXCEPTION (#8, revision 4). Set only on a session opened by
+     * the install's bootstrap admin (`BOOTSTRAP_SUPERADMIN_EMAILS`, system org)
+     * while they still have no enrolled factor. Such a session is `aal: 1` and may
+     * reach ONLY enrolment, sign-out and the routes `init-platform.sh` calls;
+     * every other service refuses it outright (see `requireAuth`). The exception
+     * closes permanently at the first enrolment and never reopens.
+     */
+    mfaEnrollmentPending?: boolean;
     /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */
     role: OrgRole;
     /** Derived: true when role is 'admin' or 'owner' in the active organization */
@@ -188,9 +287,9 @@ export interface JwtPayload {
     /**
      * Unique token id. On an impersonation token it identifies the SESSION, so it
      * can be revoked on its own across every service (see
-     * `TokenRevocationStore.getSessionRevocation`). Personal Access Tokens carry
-     * one too, validated against a different record — which is why a `jti` alone
-     * never marks a token as impersonation; `impersonatorId` does.
+     * `TokenRevocationStore.getSessionRevocation`). Personal Access Tokens
+     * (`token_use: 'api_key'`) carry one too, validated against their own record.
+     * A `jti` alone never classifies a token — `token_use` and `impersonatorId` do.
      */
     jti?: string;
     /**

package/lib/types/common.js

@@ -1,5 +1,15 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+/**
+ * Runtime catalog of {@link TokenScope} (a union is erased at runtime). This is
+ * the ONE allowlist every mint path validates against — platform's key/token
+ * issue routes included — so a new scope is added in exactly one place.
+ */
+export const TOKEN_SCOPES = ['reporting:ingest', 'registry:push', 'scim'];
+/** Runtime catalogs for the claim unions above (a union is erased at runtime). */
+export const PRINCIPAL_TYPES = ['user', 'service_account', 'service'];
+export const TOKEN_USES = ['access', 'api_key'];
+export const AUTH_METHODS = ['pwd', 'oauth', 'sso', 'webauthn', 'stepup', 'mfa'];
 /**
  * Valid quota type values.
  */
@@ -38,4 +48,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;AA0CtC;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAiLD;;;;;;;;;;;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 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 */\nexport type TokenScope = 'reporting:ingest';\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\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 */\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' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\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  /** 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 — the old path\n   * (membership in the well-known \"system\" org with role admin/owner) has been\n   * removed because it conflated \"Pipeline Builder operator\" with \"real customer\n   * tenant\" in the data model. Grant sysadmin only via `isSuperAdmin`.\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  /** 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 carry\n   * one too, validated against a different record — which is why a `jti` alone\n   * never marks a token as impersonation; `impersonatorId` does.\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 user's `tokenVersion` at the moment this token was issued. Every\n   * privilege change (deactivate / role or tier downgrade / membership or\n   * ownership change / password change / logout-all) increments the user's\n   * server-side `tokenVersion`, 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","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA2BtC;;;;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;AA8BxG;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAkND;;;;;;;;;;;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 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 (#8).\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)\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 */\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' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\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 (#8).\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   * BOOTSTRAP-ADMIN EXCEPTION (#8, revision 4). 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 — the old path\n   * (membership in the well-known \"system\" org with role admin/owner) has been\n   * removed because it conflated \"Pipeline Builder operator\" with \"real customer\n   * tenant\" in the data model. Grant sysadmin only via `isSuperAdmin`.\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  /** 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 user's `tokenVersion` at the moment this token was issued. Every\n   * privilege change (deactivate / role or tier downgrade / membership or\n   * ownership change / password change / logout-all) increments the user's\n   * server-side `tokenVersion`, 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/error-codes.d.ts

@@ -12,7 +12,21 @@ export declare enum ErrorCode {
     TOKEN_INVALID = "TOKEN_INVALID",
     TOKEN_MISSING = "TOKEN_MISSING",
     TOKEN_REVOKED = "TOKEN_REVOKED",
+    /** The session is not MFA-grade (`aal` below the route's `minAssurance`).
+     *  The client sends the person to enrol / sign in again with a second
+     *  factor — it must NOT sign them out or retry a token refresh, since a
+     *  refresh can never raise the assurance level. */
+    MFA_REQUIRED = "MFA_REQUIRED",
+    /** The session is MFA-grade but its `auth_time` is older than the route's
+     *  `maxAge` — the person must authenticate again (not merely refresh). */
+    REAUTH_REQUIRED = "REAUTH_REQUIRED",
     INSUFFICIENT_PERMISSIONS = "INSUFFICIENT_PERMISSIONS",
+    /** A machine credential (service principal, org service account, or an
+     *  exchanged access key) reached a route that requires a person. */
+    HUMAN_SESSION_REQUIRED = "HUMAN_SESSION_REQUIRED",
+    /** A bootstrap-admin enrolment session (`mfaEnrollmentPending`) reached a
+     *  route outside the enrolment / sign-out / setup allowlist. */
+    MFA_ENROLLMENT_REQUIRED = "MFA_ENROLLMENT_REQUIRED",
     ORG_MISMATCH = "ORG_MISMATCH",
     COMPLIANCE_VIOLATION = "COMPLIANCE_VIOLATION",
     NOT_FOUND = "NOT_FOUND",
@@ -41,6 +55,7 @@ export declare enum ErrorCode {
     ADDON_OVER_CAP = "ADDON_OVER_CAP",// 409
     INTERNAL_ERROR = "INTERNAL_ERROR",
     DATABASE_ERROR = "DATABASE_ERROR",
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED",
     SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
     COMPLIANCE_SERVICE_UNAVAILABLE = "COMPLIANCE_SERVICE_UNAVAILABLE"
 }

package/lib/types/error-codes.js

@@ -16,8 +16,22 @@ export var ErrorCode;
     ErrorCode["TOKEN_INVALID"] = "TOKEN_INVALID";
     ErrorCode["TOKEN_MISSING"] = "TOKEN_MISSING";
     ErrorCode["TOKEN_REVOKED"] = "TOKEN_REVOKED";
+    /** The session is not MFA-grade (`aal` below the route's `minAssurance`).
+     *  The client sends the person to enrol / sign in again with a second
+     *  factor — it must NOT sign them out or retry a token refresh, since a
+     *  refresh can never raise the assurance level. */
+    ErrorCode["MFA_REQUIRED"] = "MFA_REQUIRED";
+    /** The session is MFA-grade but its `auth_time` is older than the route's
+     *  `maxAge` — the person must authenticate again (not merely refresh). */
+    ErrorCode["REAUTH_REQUIRED"] = "REAUTH_REQUIRED";
     // Authorization errors (403)
     ErrorCode["INSUFFICIENT_PERMISSIONS"] = "INSUFFICIENT_PERMISSIONS";
+    /** A machine credential (service principal, org service account, or an
+     *  exchanged access key) reached a route that requires a person. */
+    ErrorCode["HUMAN_SESSION_REQUIRED"] = "HUMAN_SESSION_REQUIRED";
+    /** A bootstrap-admin enrolment session (`mfaEnrollmentPending`) reached a
+     *  route outside the enrolment / sign-out / setup allowlist. */
+    ErrorCode["MFA_ENROLLMENT_REQUIRED"] = "MFA_ENROLLMENT_REQUIRED";
     ErrorCode["ORG_MISMATCH"] = "ORG_MISMATCH";
     ErrorCode["COMPLIANCE_VIOLATION"] = "COMPLIANCE_VIOLATION";
     // Not found errors (404)
@@ -53,6 +67,8 @@ export var ErrorCode;
     // Server errors (500)
     ErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
     ErrorCode["DATABASE_ERROR"] = "DATABASE_ERROR";
+    // Not implemented (501) — the configured provider has no such capability
+    ErrorCode["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
     // Service unavailable (503)
     ErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
     ErrorCode["COMPLIANCE_SERVICE_UNAVAILABLE"] = "COMPLIANCE_SERVICE_UNAVAILABLE";
@@ -66,7 +82,11 @@ export const ErrorCodeStatus = {
     [ErrorCode.TOKEN_INVALID]: 401,
     [ErrorCode.TOKEN_MISSING]: 401,
     [ErrorCode.TOKEN_REVOKED]: 401,
+    [ErrorCode.MFA_REQUIRED]: 401,
+    [ErrorCode.REAUTH_REQUIRED]: 401,
     [ErrorCode.INSUFFICIENT_PERMISSIONS]: 403,
+    [ErrorCode.HUMAN_SESSION_REQUIRED]: 403,
+    [ErrorCode.MFA_ENROLLMENT_REQUIRED]: 403,
     [ErrorCode.ORG_MISMATCH]: 403,
     [ErrorCode.COMPLIANCE_VIOLATION]: 403,
     [ErrorCode.NOT_FOUND]: 404,
@@ -95,6 +115,7 @@ export const ErrorCodeStatus = {
     [ErrorCode.ADDON_OVER_CAP]: 409,
     [ErrorCode.INTERNAL_ERROR]: 500,
     [ErrorCode.DATABASE_ERROR]: 500,
+    [ErrorCode.NOT_IMPLEMENTED]: 501,
     [ErrorCode.SERVICE_UNAVAILABLE]: 503,
     [ErrorCode.COMPLIANCE_SERVICE_UNAVAILABLE]: 503,
 };
@@ -104,4 +125,4 @@ export const ErrorCodeStatus = {
 export function getStatusForErrorCode(code) {
     return ErrorCodeStatus[code] ?? 500;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-codes.js","sourceRoot":"","sources":["../../src/types/error-codes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Standardized error codes used across all API microservices.\n * Use these codes in error responses for consistent client handling.\n *\n * Each HTTP status category has one primary code. Use the `details`\n * field in error responses for sub-type information (e.g. which quota\n * was exceeded, which field failed validation).\n */\nexport enum ErrorCode {\n  // Authentication errors (401)\n  UNAUTHORIZED = 'UNAUTHORIZED',\n  TOKEN_EXPIRED = 'TOKEN_EXPIRED',\n  TOKEN_INVALID = 'TOKEN_INVALID',\n  TOKEN_MISSING = 'TOKEN_MISSING',\n  TOKEN_REVOKED = 'TOKEN_REVOKED',\n\n  // Authorization errors (403)\n  INSUFFICIENT_PERMISSIONS = 'INSUFFICIENT_PERMISSIONS',\n  ORG_MISMATCH = 'ORG_MISMATCH',\n  COMPLIANCE_VIOLATION = 'COMPLIANCE_VIOLATION',\n\n  // Not found errors (404)\n  NOT_FOUND = 'NOT_FOUND',\n  ORG_NOT_FOUND = 'ORG_NOT_FOUND',\n\n  // Validation errors (400)\n  VALIDATION_ERROR = 'VALIDATION_ERROR',\n  MISSING_REQUIRED_FIELD = 'MISSING_REQUIRED_FIELD',\n  TEMPLATE_UNKNOWN_PATH = 'TEMPLATE_UNKNOWN_PATH',\n  TEMPLATE_CYCLE = 'TEMPLATE_CYCLE',\n  TEMPLATE_PARSE_ERROR = 'TEMPLATE_PARSE_ERROR',\n  TEMPLATE_TYPE_MISMATCH = 'TEMPLATE_TYPE_MISMATCH',\n  TEMPLATE_SECRETS_RESERVED = 'TEMPLATE_SECRETS_RESERVED',\n  TEMPLATE_CONTRACT_VIOLATION = 'TEMPLATE_CONTRACT_VIOLATION',\n  TEMPLATE_SIZE_EXCEEDED = 'TEMPLATE_SIZE_EXCEEDED',\n  TEMPLATE_VALIDATION_FAILED = 'TEMPLATE_VALIDATION_FAILED',\n\n  // Quota/Rate limit errors (429)\n  QUOTA_EXCEEDED = 'QUOTA_EXCEEDED',\n  RATE_LIMIT_EXCEEDED = 'RATE_LIMIT_EXCEEDED',\n\n  // Payload errors (413)\n  PAYLOAD_TOO_LARGE = 'PAYLOAD_TOO_LARGE',\n\n  // Conflict errors (409)\n  CONFLICT = 'CONFLICT',\n  DUPLICATE_ENTRY = 'DUPLICATE_ENTRY',\n  SCAN_CONFLICT = 'SCAN_CONFLICT',\n\n  // Billing errors\n  PAYMENT_METHOD_REQUIRED = 'PAYMENT_METHOD_REQUIRED', // 402\n  DISCOUNT_CEILING_EXCEEDED = 'DISCOUNT_CEILING_EXCEEDED', // 400\n  DISCOUNT_NOT_FOUND = 'DISCOUNT_NOT_FOUND', // 404\n  DISCOUNT_INACTIVE = 'DISCOUNT_INACTIVE', // 409\n  PLAN_OVER_CAP = 'PLAN_OVER_CAP', // 409\n  ADDON_OVER_CAP = 'ADDON_OVER_CAP', // 409\n\n  // Server errors (500)\n  INTERNAL_ERROR = 'INTERNAL_ERROR',\n  DATABASE_ERROR = 'DATABASE_ERROR',\n\n  // Service unavailable (503)\n  SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE',\n  COMPLIANCE_SERVICE_UNAVAILABLE = 'COMPLIANCE_SERVICE_UNAVAILABLE',\n}\n\n/**\n * Maps error codes to their default HTTP status codes.\n */\nexport const ErrorCodeStatus: Record<ErrorCode, number> = {\n  [ErrorCode.UNAUTHORIZED]: 401,\n  [ErrorCode.TOKEN_EXPIRED]: 401,\n  [ErrorCode.TOKEN_INVALID]: 401,\n  [ErrorCode.TOKEN_MISSING]: 401,\n  [ErrorCode.TOKEN_REVOKED]: 401,\n  [ErrorCode.INSUFFICIENT_PERMISSIONS]: 403,\n  [ErrorCode.ORG_MISMATCH]: 403,\n  [ErrorCode.COMPLIANCE_VIOLATION]: 403,\n  [ErrorCode.NOT_FOUND]: 404,\n  [ErrorCode.ORG_NOT_FOUND]: 404,\n  [ErrorCode.VALIDATION_ERROR]: 400,\n  [ErrorCode.MISSING_REQUIRED_FIELD]: 400,\n  [ErrorCode.TEMPLATE_UNKNOWN_PATH]: 400,\n  [ErrorCode.TEMPLATE_CYCLE]: 400,\n  [ErrorCode.TEMPLATE_PARSE_ERROR]: 400,\n  [ErrorCode.TEMPLATE_TYPE_MISMATCH]: 400,\n  [ErrorCode.TEMPLATE_SECRETS_RESERVED]: 400,\n  [ErrorCode.TEMPLATE_CONTRACT_VIOLATION]: 400,\n  [ErrorCode.TEMPLATE_SIZE_EXCEEDED]: 400,\n  [ErrorCode.TEMPLATE_VALIDATION_FAILED]: 400,\n  [ErrorCode.QUOTA_EXCEEDED]: 429,\n  [ErrorCode.RATE_LIMIT_EXCEEDED]: 429,\n  [ErrorCode.PAYLOAD_TOO_LARGE]: 413,\n  [ErrorCode.CONFLICT]: 409,\n  [ErrorCode.DUPLICATE_ENTRY]: 409,\n  [ErrorCode.SCAN_CONFLICT]: 409,\n  [ErrorCode.PAYMENT_METHOD_REQUIRED]: 402,\n  [ErrorCode.DISCOUNT_CEILING_EXCEEDED]: 400,\n  [ErrorCode.DISCOUNT_NOT_FOUND]: 404,\n  [ErrorCode.DISCOUNT_INACTIVE]: 409,\n  [ErrorCode.PLAN_OVER_CAP]: 409,\n  [ErrorCode.ADDON_OVER_CAP]: 409,\n  [ErrorCode.INTERNAL_ERROR]: 500,\n  [ErrorCode.DATABASE_ERROR]: 500,\n  [ErrorCode.SERVICE_UNAVAILABLE]: 503,\n  [ErrorCode.COMPLIANCE_SERVICE_UNAVAILABLE]: 503,\n};\n\n/**\n * Get the HTTP status code for an error code.\n */\nexport function getStatusForErrorCode(code: ErrorCode): number {\n  return ErrorCodeStatus[code] ?? 500;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-codes.js","sourceRoot":"","sources":["../../src/types/error-codes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Standardized error codes used across all API microservices.\n * Use these codes in error responses for consistent client handling.\n *\n * Each HTTP status category has one primary code. Use the `details`\n * field in error responses for sub-type information (e.g. which quota\n * was exceeded, which field failed validation).\n */\nexport enum ErrorCode {\n  // Authentication errors (401)\n  UNAUTHORIZED = 'UNAUTHORIZED',\n  TOKEN_EXPIRED = 'TOKEN_EXPIRED',\n  TOKEN_INVALID = 'TOKEN_INVALID',\n  TOKEN_MISSING = 'TOKEN_MISSING',\n  TOKEN_REVOKED = 'TOKEN_REVOKED',\n  /** The session is not MFA-grade (`aal` below the route's `minAssurance`).\n   *  The client sends the person to enrol / sign in again with a second\n   *  factor — it must NOT sign them out or retry a token refresh, since a\n   *  refresh can never raise the assurance level. */\n  MFA_REQUIRED = 'MFA_REQUIRED',\n  /** The session is MFA-grade but its `auth_time` is older than the route's\n   *  `maxAge` — the person must authenticate again (not merely refresh). */\n  REAUTH_REQUIRED = 'REAUTH_REQUIRED',\n\n  // Authorization errors (403)\n  INSUFFICIENT_PERMISSIONS = 'INSUFFICIENT_PERMISSIONS',\n  /** A machine credential (service principal, org service account, or an\n   *  exchanged access key) reached a route that requires a person. */\n  HUMAN_SESSION_REQUIRED = 'HUMAN_SESSION_REQUIRED',\n  /** A bootstrap-admin enrolment session (`mfaEnrollmentPending`) reached a\n   *  route outside the enrolment / sign-out / setup allowlist. */\n  MFA_ENROLLMENT_REQUIRED = 'MFA_ENROLLMENT_REQUIRED',\n  ORG_MISMATCH = 'ORG_MISMATCH',\n  COMPLIANCE_VIOLATION = 'COMPLIANCE_VIOLATION',\n\n  // Not found errors (404)\n  NOT_FOUND = 'NOT_FOUND',\n  ORG_NOT_FOUND = 'ORG_NOT_FOUND',\n\n  // Validation errors (400)\n  VALIDATION_ERROR = 'VALIDATION_ERROR',\n  MISSING_REQUIRED_FIELD = 'MISSING_REQUIRED_FIELD',\n  TEMPLATE_UNKNOWN_PATH = 'TEMPLATE_UNKNOWN_PATH',\n  TEMPLATE_CYCLE = 'TEMPLATE_CYCLE',\n  TEMPLATE_PARSE_ERROR = 'TEMPLATE_PARSE_ERROR',\n  TEMPLATE_TYPE_MISMATCH = 'TEMPLATE_TYPE_MISMATCH',\n  TEMPLATE_SECRETS_RESERVED = 'TEMPLATE_SECRETS_RESERVED',\n  TEMPLATE_CONTRACT_VIOLATION = 'TEMPLATE_CONTRACT_VIOLATION',\n  TEMPLATE_SIZE_EXCEEDED = 'TEMPLATE_SIZE_EXCEEDED',\n  TEMPLATE_VALIDATION_FAILED = 'TEMPLATE_VALIDATION_FAILED',\n\n  // Quota/Rate limit errors (429)\n  QUOTA_EXCEEDED = 'QUOTA_EXCEEDED',\n  RATE_LIMIT_EXCEEDED = 'RATE_LIMIT_EXCEEDED',\n\n  // Payload errors (413)\n  PAYLOAD_TOO_LARGE = 'PAYLOAD_TOO_LARGE',\n\n  // Conflict errors (409)\n  CONFLICT = 'CONFLICT',\n  DUPLICATE_ENTRY = 'DUPLICATE_ENTRY',\n  SCAN_CONFLICT = 'SCAN_CONFLICT',\n\n  // Billing errors\n  PAYMENT_METHOD_REQUIRED = 'PAYMENT_METHOD_REQUIRED', // 402\n  DISCOUNT_CEILING_EXCEEDED = 'DISCOUNT_CEILING_EXCEEDED', // 400\n  DISCOUNT_NOT_FOUND = 'DISCOUNT_NOT_FOUND', // 404\n  DISCOUNT_INACTIVE = 'DISCOUNT_INACTIVE', // 409\n  PLAN_OVER_CAP = 'PLAN_OVER_CAP', // 409\n  ADDON_OVER_CAP = 'ADDON_OVER_CAP', // 409\n\n  // Server errors (500)\n  INTERNAL_ERROR = 'INTERNAL_ERROR',\n  DATABASE_ERROR = 'DATABASE_ERROR',\n\n  // Not implemented (501) — the configured provider has no such capability\n  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',\n\n  // Service unavailable (503)\n  SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE',\n  COMPLIANCE_SERVICE_UNAVAILABLE = 'COMPLIANCE_SERVICE_UNAVAILABLE',\n}\n\n/**\n * Maps error codes to their default HTTP status codes.\n */\nexport const ErrorCodeStatus: Record<ErrorCode, number> = {\n  [ErrorCode.UNAUTHORIZED]: 401,\n  [ErrorCode.TOKEN_EXPIRED]: 401,\n  [ErrorCode.TOKEN_INVALID]: 401,\n  [ErrorCode.TOKEN_MISSING]: 401,\n  [ErrorCode.TOKEN_REVOKED]: 401,\n  [ErrorCode.MFA_REQUIRED]: 401,\n  [ErrorCode.REAUTH_REQUIRED]: 401,\n  [ErrorCode.INSUFFICIENT_PERMISSIONS]: 403,\n  [ErrorCode.HUMAN_SESSION_REQUIRED]: 403,\n  [ErrorCode.MFA_ENROLLMENT_REQUIRED]: 403,\n  [ErrorCode.ORG_MISMATCH]: 403,\n  [ErrorCode.COMPLIANCE_VIOLATION]: 403,\n  [ErrorCode.NOT_FOUND]: 404,\n  [ErrorCode.ORG_NOT_FOUND]: 404,\n  [ErrorCode.VALIDATION_ERROR]: 400,\n  [ErrorCode.MISSING_REQUIRED_FIELD]: 400,\n  [ErrorCode.TEMPLATE_UNKNOWN_PATH]: 400,\n  [ErrorCode.TEMPLATE_CYCLE]: 400,\n  [ErrorCode.TEMPLATE_PARSE_ERROR]: 400,\n  [ErrorCode.TEMPLATE_TYPE_MISMATCH]: 400,\n  [ErrorCode.TEMPLATE_SECRETS_RESERVED]: 400,\n  [ErrorCode.TEMPLATE_CONTRACT_VIOLATION]: 400,\n  [ErrorCode.TEMPLATE_SIZE_EXCEEDED]: 400,\n  [ErrorCode.TEMPLATE_VALIDATION_FAILED]: 400,\n  [ErrorCode.QUOTA_EXCEEDED]: 429,\n  [ErrorCode.RATE_LIMIT_EXCEEDED]: 429,\n  [ErrorCode.PAYLOAD_TOO_LARGE]: 413,\n  [ErrorCode.CONFLICT]: 409,\n  [ErrorCode.DUPLICATE_ENTRY]: 409,\n  [ErrorCode.SCAN_CONFLICT]: 409,\n  [ErrorCode.PAYMENT_METHOD_REQUIRED]: 402,\n  [ErrorCode.DISCOUNT_CEILING_EXCEEDED]: 400,\n  [ErrorCode.DISCOUNT_NOT_FOUND]: 404,\n  [ErrorCode.DISCOUNT_INACTIVE]: 409,\n  [ErrorCode.PLAN_OVER_CAP]: 409,\n  [ErrorCode.ADDON_OVER_CAP]: 409,\n  [ErrorCode.INTERNAL_ERROR]: 500,\n  [ErrorCode.DATABASE_ERROR]: 500,\n  [ErrorCode.NOT_IMPLEMENTED]: 501,\n  [ErrorCode.SERVICE_UNAVAILABLE]: 503,\n  [ErrorCode.COMPLIANCE_SERVICE_UNAVAILABLE]: 503,\n};\n\n/**\n * Get the HTTP status code for an error code.\n */\nexport function getStatusForErrorCode(code: ErrorCode): number {\n  return ErrorCodeStatus[code] ?? 500;\n}\n"]}

package/lib/types/permissions.d.ts

@@ -12,9 +12,36 @@ import type { OrgRole } from './common.js';
  * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`
  * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.
  */
-export type Permission = 'pipelines:read' | 'pipelines:write' | 'pipelines:publish' | 'templates:read' | 'templates:write' | 'templates:publish' | 'plugins:read' | 'plugins:write' | 'plugins:publish' | 'compliance:read' | 'compliance:write' | 'members:manage' | 'roles:manage' | 'invitations:manage' | 'dashboards:read' | 'dashboards:write' | 'observability:read' | 'observability:write' | 'reports:read' | 'reports:rollup' | 'messages:read' | 'messages:write' | 'billing:read' | 'billing:manage' | 'quotas:read' | 'registry:read' | 'registry:write' | 'org:settings' | 'org:idp' | 'org:kms' | 'org:impersonation';
+export type Permission = 'pipelines:read' | 'pipelines:write' | 'pipelines:publish' | 'templates:read' | 'templates:write' | 'templates:publish' | 'plugins:read' | 'plugins:write' | 'plugins:publish' | 'compliance:read' | 'compliance:write' | 'members:manage' | 'roles:manage' | 'invitations:manage' | 'service_accounts:manage' | 'dashboards:read' | 'dashboards:write' | 'observability:read' | 'observability:write' | 'reports:read' | 'reports:rollup' | 'messages:read' | 'messages:write' | 'billing:read' | 'billing:manage' | 'quotas:read' | 'registry:read' | 'registry:write' | 'org:settings' | 'org:idp' | 'org:kms' | 'org:impersonation';
 /** All valid permissions (order determines display order in the picker). */
 export declare const ALL_PERMISSIONS: readonly Permission[];
+/**
+ * Display metadata for one permission: the label + description the
+ * permission-picker UI shows, and the category it groups under.
+ */
+export interface PermissionMeta {
+    id: Permission;
+    label: string;
+    description: string;
+    category: string;
+}
+/**
+ * The permission catalog with display metadata, in picker order.
+ *
+ * This module is the SINGLE catalog for backend and browser alike: it has no
+ * runtime dependencies (the only import is a type), so the frontend imports it
+ * through the `@pipeline-builder/api-core/permissions` subpath instead of keeping
+ * a hand-maintained mirror. Every id in {@link ALL_PERMISSIONS} must appear here
+ * exactly once (asserted by `permissions.test.ts`).
+ */
+export declare const PERMISSION_CATALOG: readonly PermissionMeta[];
+/** Human label for a permission id (falls back to the raw id for an unknown one). */
+export declare function permissionLabel(id: string): string;
+/** One picker section: a category and the permissions it contains, in catalog order. */
+export interface PermissionCategory {
+    category: string;
+    permissions: PermissionMeta[];
+}
 /** Check whether a string is a valid Permission. */
 export declare function isValidPermission(value: string): value is Permission;
 /**
@@ -36,6 +63,13 @@ export declare const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[];
 export declare const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[];
 /** Whether `permission` may be granted through a user-authored custom Role. */
 export declare function isOrgAssignablePermission(permission: Permission): boolean;
+/**
+ * Category → permissions for the custom-Role AUTHORING picker: the catalog minus
+ * the {@link SUPERADMIN_ONLY_PERMISSIONS}, with any now-empty category dropped
+ * (so "Registry" disappears). The grouped view of
+ * {@link ORG_ASSIGNABLE_PERMISSIONS}.
+ */
+export declare const ORG_ASSIGNABLE_CATEGORIES: readonly PermissionCategory[];
 /**
  * Seed bundle for each built-in Role, keyed by the coarse role it grants.
  * Consumed by the Role seeder + the startup backfill to populate a built-in