@pipeline-builder/api-core 5.2.11 → 5.2.12

package/lib/types/common.d.ts

@@ -1,5 +1,6 @@
 import type { Permission } from './permissions.js';
 import type { QuotaTier } from './quota-tiers.js';
+import type { OrgRole } from './wire-vocabulary.js';
 /**
  * Capability scope catalog for machine/automation tokens. A scoped token carries
  * exactly one of these instead of role-based permissions; endpoints that accept a
@@ -20,13 +21,13 @@ import type { QuotaTier } from './quota-tiers.js';
  *   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';
+export declare const TOKEN_SCOPES: readonly ['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.
+ * A token scope. {@link TOKEN_SCOPES} 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[];
+export type TokenScope = (typeof TOKEN_SCOPES)[number];
 /**
  * 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.
@@ -37,14 +38,16 @@ export declare const TOKEN_SCOPES: readonly TokenScope[];
  *                       platform. Never satisfies an assurance/step-up gate.
  * - `service`         — an internal Pipeline Builder service ({@link signServiceToken}).
  */
-export type PrincipalType = 'user' | 'service_account' | 'service';
+export declare const PRINCIPAL_TYPES: readonly ['user', 'service_account', 'service'];
+export type PrincipalType = (typeof PRINCIPAL_TYPES)[number];
 /**
  * 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';
+export declare const TOKEN_USES: readonly ['access', 'api_key'];
+export type TokenUse = (typeof TOKEN_USES)[number];
 /**
  * Authentication methods (`amr`, RFC 8176 style) that established a user's
  * session. `pwd` password sign-in; `oauth` social sign-in (Google, GitHub …);
@@ -54,7 +57,8 @@ export type TokenUse = 'access' | 'api_key';
  * or one of its recovery codes, so it appears ALONGSIDE the method that
  * identified the user (`['pwd', 'mfa']`), never on its own.
  */
-export type AuthMethod = 'pwd' | 'oauth' | 'sso' | 'webauthn' | 'stepup' | 'mfa';
+export declare const AUTH_METHODS: readonly ['pwd', 'oauth', 'sso', 'webauthn', 'stepup', 'mfa'];
+export type AuthMethod = (typeof AUTH_METHODS)[number];
 /**
  * Authenticator assurance level of the session a token speaks for.
  *
@@ -70,10 +74,6 @@ export type AuthMethod = 'pwd' | 'oauth' | 'sso' | 'webauthn' | 'stepup' | 'mfa'
  * 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.
  *
@@ -209,20 +209,11 @@ export type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;
  * Users can belong to multiple organizations. The token is scoped to one
  * active organization at a time. The `role` field is the user's per-org
  * role in that organization (from the UserOrganization junction collection),
- * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.
+ * and `isAdmin` is derived from it (`isAdminOrgRole`, wire-vocabulary.ts).
  *
  * Use `POST /auth/switch-org` to change the active organization, which
  * re-issues tokens with the new org's role and context.
  */
-/**
- * Coarse per-org membership label, DERIVED from the Roles a user is assigned
- * (the highest `grantsRole` among them; `owner` is set only by ownership
- * transfer). It is a display/authority label — driving `isAdmin`, ownership,
- * and seat accounting — NOT a permission source. Effective permissions come
- * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a
- * global role.
- */
-export type OrgRole = 'owner' | 'admin' | 'member';
 export interface JwtPayload {
     /** User ID (subject) */
     sub: string;

package/lib/types/common.js

@@ -2,14 +2,53 @@
 // SPDX-License-Identifier: Apache-2.0
 import { QUOTA_CATALOG } from './quota-catalog.js';
 /**
- * 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.
+ * Capability scope catalog for machine/automation tokens. A scoped token carries
+ * exactly one of these instead of role-based permissions; endpoints that accept a
+ * 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 const TOKEN_SCOPES = ['reporting:ingest', 'registry:push', 'scim'];
-/** Runtime catalogs for the claim unions above (a union is erased at runtime). */
+/**
+ * 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 const PRINCIPAL_TYPES = ['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 const TOKEN_USES = ['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 const AUTH_METHODS = ['pwd', 'oauth', 'sso', 'webauthn', 'stepup', 'mfa'];
 /**
  * Valid quota type values.
@@ -67,4 +106,4 @@ export function isValidQuotaType(value) {
 export function effectiveRootOrgId(payload) {
     return payload.rootOrganizationId ?? payload.organizationId;
 }
-//# 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"]}
+//# 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;AAInD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,kBAAkB,EAAE,eAAe,EAAE,MAAM,CAAU,CAAC;AAQnF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,SAAS,CAAU,CAAC;AAG/E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAU,CAAC;AAGzD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAU,CAAC;AAiE1F;;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;AAkPD;;;;;;;;;;;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';\nimport type { OrgRole } from './wire-vocabulary.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 const TOKEN_SCOPES = ['reporting:ingest', 'registry:push', 'scim'] as const;\n/**\n * A token scope. {@link TOKEN_SCOPES} is the ONE allowlist every mint path\n * validates against — platform's key/token issue routes included — so a new\n * scope is added in exactly one place.\n */\nexport type TokenScope = (typeof TOKEN_SCOPES)[number];\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 const PRINCIPAL_TYPES = ['user', 'service_account', 'service'] as const;\nexport type PrincipalType = (typeof PRINCIPAL_TYPES)[number];\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 const TOKEN_USES = ['access', 'api_key'] as const;\nexport type TokenUse = (typeof TOKEN_USES)[number];\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 const AUTH_METHODS = ['pwd', 'oauth', 'sso', 'webauthn', 'stepup', 'mfa'] as const;\nexport type AuthMethod = (typeof AUTH_METHODS)[number];\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/**\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 from it (`isAdminOrgRole`, wire-vocabulary.ts).\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\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/ecosystem-notifications.d.ts

@@ -1,30 +1,29 @@
-/**
- * The plugin-ecosystem notification contract (docs/plugin-publishing.md),
- * shared by the sender (the plugin service's enqueue API and digest
- * dispatcher) and the relay (platform `POST /internal/notify-email`).
- *
- * Recipients travel as RULES, never as lists: platform resolves each
- * {@link EcosystemRecipientSpec} against its user/Role directory AT SEND TIME,
- * so a digest that flushes tomorrow reaches tomorrow's moderators, the plugin
- * service never handles an email address or a membership list, and a publisher
- * can never learn who installed their plugin (the relay mails each recipient
- * individually — no shared To: line).
- */
-/** A notification event number. */
-export type EcosystemNotificationEventId = 'N1' | 'N2' | 'N3' | 'N4' | 'N5' | 'N6' | 'N7' | 'N8' | 'N9' | 'N10' | 'N11' | 'N12' | 'N13' | 'N14' | 'N15' | 'N16' | 'N17' | 'N18' | 'N19' | 'N20' | 'N21' | 'N22' | 'N23' | 'N24' | 'N25' | 'N26' | 'N27' | 'N28' | 'N29' | 'N30' | 'N31' | 'N32' | 'N33' | 'N34';
 /** A delivery channel. In-app is the source of truth; email is the courtesy copy. */
 export type EcosystemNotificationChannel = 'in_app' | 'email';
-/** A per-user EMAIL opt-out key. In-app is never optional. */
-export type EcosystemEmailPreference = 'ecosystem.reviews.email' | 'ecosystem.upgrades.email' | 'ecosystem.installs.email' | 'ecosystem.moderationDigest.email';
-/** The field each preference key is stored under in the user's per-org
- *  `notifications.ecosystem` preferences (platform `UserPreferences`). */
-export declare const ECOSYSTEM_EMAIL_PREFERENCE_FIELDS: Readonly<Record<EcosystemEmailPreference, EcosystemEmailPreferenceField>>;
+/**
+ * Per-user EMAIL opt-out keys (in-app is never optional), each mapped to the
+ * field it is stored under in the user's per-org `notifications.ecosystem`
+ * preferences (platform `UserPreferences`).
+ */
+export declare const ECOSYSTEM_EMAIL_PREFERENCE_FIELDS: {
+    readonly 'ecosystem.reviews.email': 'reviewsEmail';
+    readonly 'ecosystem.upgrades.email': 'upgradesEmail';
+    readonly 'ecosystem.installs.email': 'installsEmail';
+    readonly 'ecosystem.moderationDigest.email': 'moderationDigestEmail';
+};
+/** A per-user EMAIL opt-out key. */
+export type EcosystemEmailPreference = keyof typeof ECOSYSTEM_EMAIL_PREFERENCE_FIELDS;
 /** Stored field names of the ecosystem email preferences (all default `true`). */
-export type EcosystemEmailPreferenceField = 'reviewsEmail' | 'upgradesEmail' | 'installsEmail' | 'moderationDigestEmail';
+export type EcosystemEmailPreferenceField = (typeof ECOSYSTEM_EMAIL_PREFERENCE_FIELDS)[EcosystemEmailPreference];
 /** Every stored ecosystem email-preference field. */
 export declare const ECOSYSTEM_EMAIL_PREFERENCE_FIELD_NAMES: readonly EcosystemEmailPreferenceField[];
-/** How often a batched email is flushed. */
-export type EcosystemDigestCadence = 'hourly' | 'daily' | 'weekly';
+/** How often a batched email is flushed, with the digest subject's label. */
+declare const DIGEST_CADENCE_LABEL: {
+    readonly hourly: 'Hourly';
+    readonly daily: 'Daily';
+    readonly weekly: 'Weekly';
+};
+export type EcosystemDigestCadence = keyof typeof DIGEST_CADENCE_LABEL;
 /** One event's delivery rules. */
 export interface EcosystemEventSpec {
     /** One-line description (docs, logs). */
@@ -43,14 +42,205 @@ export interface EcosystemEventSpec {
      *  security address (the plugin security notices N30–N33). */
     allowsAddress?: boolean;
 }
+/** The notification event table, as data (keyed by event number). */
+declare const EVENTS: {
+    N1: {
+        description: string;
+        channels: "email"[];
+        preference: null;
+        allowsAddress: true;
+    };
+    N2: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.moderationDigest.email";
+        digest: "daily";
+    };
+    N3: {
+        description: string;
+        channels: "email"[];
+        preference: null;
+        allowsAddress: true;
+    };
+    N4: {
+        description: string;
+        channels: "email"[];
+        preference: null;
+        allowsAddress: true;
+    };
+    N5: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N6: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.moderationDigest.email";
+        digest: "daily";
+    };
+    N7: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N8: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N9: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N10: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N11: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.installs.email";
+    };
+    N12: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.installs.email";
+    };
+    N13: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.upgrades.email";
+        digest: "weekly";
+    };
+    N14: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.upgrades.email";
+    };
+    N15: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.reviews.email";
+        digest: "hourly";
+    };
+    N16: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.reviews.email";
+    };
+    N17: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.moderationDigest.email";
+        digest: "daily";
+    };
+    N18: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N19: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N20: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N21: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N22: {
+        description: string;
+        channels: "email"[];
+        preference: null;
+    };
+    N23: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N24: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.moderationDigest.email";
+        digest: "daily";
+    };
+    N25: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N26: {
+        description: string;
+        channels: "in_app"[];
+        preference: "ecosystem.upgrades.email";
+    };
+    N27: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: "ecosystem.upgrades.email";
+        digest: "weekly";
+    };
+    N28: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N29: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+    N30: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+        allowsAddress: true;
+    };
+    N31: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+        allowsAddress: true;
+    };
+    N32: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+        allowsAddress: true;
+    };
+    N33: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+        allowsAddress: true;
+    };
+    N34: {
+        description: string;
+        channels: ("email" | "in_app")[];
+        preference: null;
+    };
+};
+/** A notification event number. */
+export type EcosystemNotificationEventId = keyof typeof EVENTS;
 /** The notification event table, as data. */
 export declare const ECOSYSTEM_NOTIFICATION_EVENTS: Readonly<Record<EcosystemNotificationEventId, EcosystemEventSpec>>;
 /** Whether `value` is a notification event number. */
 export declare function isEcosystemNotificationEvent(value: unknown): value is EcosystemNotificationEventId;
 /** Org-local permissions an {@link EcosystemRecipientSpec} `org_permission` rule may name. */
-export type EcosystemOrgRecipientPermission = 'publishers:manage' | 'plugin_installs:manage' | 'plugins:write' | 'pipelines:write' | 'toolchain:manage';
+declare const ORG_RECIPIENT_PERMISSIONS: readonly ["publishers:manage", "plugin_installs:manage", "plugins:write", "pipelines:write", "toolchain:manage"];
+export type EcosystemOrgRecipientPermission = (typeof ORG_RECIPIENT_PERMISSIONS)[number];
 /** System-org permissions a `moderators` rule may name. */
-export type EcosystemModeratorPermission = 'plugins:moderate' | 'publishers:verify';
+declare const MODERATOR_PERMISSIONS: readonly ["plugins:moderate", "publishers:verify"];
+export type EcosystemModeratorPermission = (typeof MODERATOR_PERMISSIONS)[number];
 /**
  * A recipient RULE, resolved by platform at send time:
  *
@@ -162,3 +352,4 @@ export declare function renderEcosystemManagerChange(input: {
  * subject and one line per item (each item's subject), oldest first.
  */
 export declare function renderEcosystemDigest(event: EcosystemNotificationEventId, items: readonly EcosystemNotificationContent[]): EcosystemNotificationContent;
+export {};