@pipeline-builder/api-core 4.1.7 → 4.1.9

package/lib/types/quota-tiers.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { envInt, envStr } from '../utils/env.js';
 /**
  * Preset limits for each tier. -1 means unlimited.
  *
@@ -111,25 +112,14 @@ const DEFAULT_TIER_LIMITS = {
     },
 };
 /**
- * Read an integer env var, falling back to the code default. `-1` = unlimited.
- * Rejects (→ fallback) anything that isn't a clean integer string and any value
- * `< -1`: a decimal (`50.5`) or a nonsense negative (`-5`) would otherwise ship a
- * broken finite limit (parity with `envCents`'s rigor for prices).
+ * Read a tier LIMIT env var. `-1` = unlimited; anything below that is nonsense
+ * (a `-5` limit would ship a broken finite cap), so it falls back to the code
+ * default rather than clamping up to `-1`. The parsing itself is api-core's
+ * shared `envInt` — strict about decimals/garbage — not a local re-derivation.
  */
-function envInt(name, fallback) {
-    const raw = process.env[name];
-    if (raw === undefined || raw === '')
-        return fallback;
-    const trimmed = raw.trim();
-    if (!/^-?\d+$/.test(trimmed))
-        return fallback; // no decimals / non-numeric
-    const n = parseInt(trimmed, 10);
-    return Number.isNaN(n) || n < -1 ? fallback : n;
-}
-/** Read a string env var, falling back to the code default. */
-function envStr(name, fallback) {
-    const raw = process.env[name];
-    return raw === undefined || raw === '' ? fallback : raw;
+function tierLimitEnv(name, fallback) {
+    const n = envInt(name, fallback);
+    return n < -1 ? fallback : n;
 }
 /**
  * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars
@@ -152,18 +142,18 @@ function tierLimits(tier) {
     const d = DEFAULT_TIER_LIMITS[tier];
     const T = tier.toUpperCase();
     return {
-        plugins: envInt(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),
-        pipelines: envInt(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),
-        apiCalls: envInt(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),
-        aiCalls: envInt(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),
-        storageBytes: envInt(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),
-        dashboards: envInt(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),
-        alertRules: envInt(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),
-        alertDestinations: envInt(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),
-        idpConfigs: envInt(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),
-        seats: envInt(`QUOTA_TIER_${T}_SEATS`, d.seats),
-        eventRetentionDays: envInt(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),
-        doraRetentionDays: envInt(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),
+        plugins: tierLimitEnv(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),
+        pipelines: tierLimitEnv(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),
+        apiCalls: tierLimitEnv(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),
+        aiCalls: tierLimitEnv(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),
+        storageBytes: tierLimitEnv(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),
+        dashboards: tierLimitEnv(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),
+        alertRules: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),
+        alertDestinations: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),
+        idpConfigs: tierLimitEnv(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),
+        seats: tierLimitEnv(`QUOTA_TIER_${T}_SEATS`, d.seats),
+        eventRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),
+        doraRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),
     };
 }
 // Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).
@@ -218,4 +208,4 @@ export function isValidTier(value) {
 export function getTierLimits(tier) {
     return isValidTier(tier) ? QUOTA_TIERS[tier].limits : QUOTA_TIERS.developer.limits;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-tiers.js","sourceRoot":"","sources":["../../src/types/quota-tiers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/** Available quota tier identifiers.\n *\n * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes\n * every feature/add-on bundle. It is the DEFAULT when billing is disabled (no\n * metering/enforcement surface exists, so nothing is capped), and it is NEVER\n * shown or selectable when billing is enabled — see `STANDARD_TIERS`. */\nexport type QuotaTier = 'developer' | 'pro' | 'team' | 'enterprise' | 'unlimited';\n\n/** Limit values for each quota type within a tier. */\nexport interface QuotaTierLimits {\n  plugins: number;\n  pipelines: number;\n  apiCalls: number;\n  aiCalls: number;\n  /**\n   * Aggregate registry storage cap in BYTES. Counted across every repo\n   * under the org's `org-{orgId}/` namespace. -1 means unlimited.\n   * push-gate reads this; the image-registry rejects token issuance for\n   * `push` scope when the org's measured usage exceeds the limit.\n   */\n  storageBytes: number;\n  /** Count-quotas on the user-editable feature tables added to close per-org\n   *  DoS via spam. -1 means unlimited. */\n  dashboards: number;\n  alertRules: number;\n  alertDestinations: number;\n  idpConfigs: number;\n  /**\n   * Max org members (active users / seats). -1 = unlimited. This is the \"Team\"\n   * tier differentiator — enforced at member-invite time (an invite is blocked\n   * when active members + pending invites would exceed this).\n   */\n  seats: number;\n  /**\n   * Reporting retention in DAYS — NOT a flow quota (never decremented, absent\n   * from `VALID_QUOTA_TYPES`): these ride the tier-baseline + bundle-grant math\n   * purely as an entitlement the billing service syncs to reporting's\n   * `dora_settings`. -1 = unlimited (the sweep skips the org entirely).\n   *   `eventRetentionDays` — non-deploy `pipeline_events` (STAGE/ACTION/build).\n   *   `doraRetentionDays`  — deploy events + `deployment_outcomes` + `incidents`,\n   *                          and the per-org report-query window for DORA routes.\n   * Extendable via the `retention_pack` / `dora_history_pack` add-on bundles.\n   */\n  eventRetentionDays: number;\n  doraRetentionDays: number;\n}\n\n/** Full preset for a single tier (label + limits). */\nexport interface QuotaTierPreset {\n  label: string;\n  limits: QuotaTierLimits;\n}\n\n/**\n * Preset limits for each tier. -1 means unlimited.\n *\n * AI calls are sized much smaller than `apiCalls` because each call has\n * external provider cost (~$0.01$0.10/call). Developer tier allows light\n * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high\n * (25,000) — fair-use, not literally unlimited.\n *\n * `storageBytes` is the aggregate registry cap per org. Sized\n * around plugin-image realities: a typical plugin image is 200500 MB;\n * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 50 GB covers a\n * mature catalog. Operators can override per-org via the quota CRUD API.\n */\nconst GB = 1024 * 1024 * 1024;\n\n/**\n * Code-default limits per tier — the fallback when no env override is set.\n * -1 means unlimited. (Counts sized to \"comfortably enough for one team, not\n * script spam\": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config\n * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas\n * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)\n */\nconst DEFAULT_TIER_LIMITS: Record<QuotaTier, QuotaTierLimits> = {\n  // Free tier: single seat, 2 pipelines, apiCalls CAPPED (was unlimited — a\n  // DoS/abuse hole on a shared resource); aiCalls small (each has ~$0.01-0.10\n  // external cost). Lean base — growth happens by upgrading, not stacking here.\n  developer: {\n    plugins: 25,\n    pipelines: 2,\n    apiCalls: 25_000,\n    aiCalls: 25,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\n    seats: 1,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Pro = individual power user, single seat, individual pricing. A 2nd seat (or\n  // team collaboration) requires the Team tier — the `seat` add-on is Team+ only,\n  // keeping Team the collaboration tier. Pro's value over Developer is its richer\n  // call/storage/plugin ceilings + feature add-ons (SSO/audit/DORA), not seats.\n  pro: {\n    plugins: 50,\n    pipelines: 5,\n    apiCalls: 250_000,\n    aiCalls: 1_000,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\n    seats: 1,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Team = collaboration tier; the seat limit (3) is the real differentiator over\n  // Pro (single-seat) — it's the multi-seat collaboration floor. Lean base ($79):\n  // growth rides the seat/pipeline/etc add-ons (land-and-expand). Limits sit\n  // between Pro and Enterprise.\n  team: {\n    plugins: 75,\n    pipelines: 6,\n    apiCalls: 500_000,\n    aiCalls: 2_500,\n    storageBytes: 60 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    seats: 3,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Enterprise ($599, held): the all-inclusive tier — 15 seats, 30 pipelines, ALL\n  // premium features included (see TIER_FEATURES). FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped so one account can't run up unbounded\n  // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.\n  enterprise: {\n    plugins: 150,\n    pipelines: 30,\n    apiCalls: 900_000,\n    aiCalls: 9_000,\n    storageBytes: 250 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: 15,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled\n  // (no enforcement surface) — never shown/selectable when billing is enabled.\n  unlimited: {\n    plugins: -1,\n    pipelines: -1,\n    apiCalls: -1,\n    aiCalls: -1,\n    storageBytes: -1,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: -1,\n    eventRetentionDays: -1,\n    doraRetentionDays: -1,\n  },\n};\n\n/**\n * Read an integer env var, falling back to the code default. `-1` = unlimited.\n * Rejects (→ fallback) anything that isn't a clean integer string and any value\n * `< -1`: a decimal (`50.5`) or a nonsense negative (`-5`) would otherwise ship a\n * broken finite limit (parity with `envCents`'s rigor for prices).\n */\nfunction envInt(name: string, fallback: number): number {\n  const raw = process.env[name];\n  if (raw === undefined || raw === '') return fallback;\n  const trimmed = raw.trim();\n  if (!/^-?\\d+$/.test(trimmed)) return fallback; // no decimals / non-numeric\n  const n = parseInt(trimmed, 10);\n  return Number.isNaN(n) || n < -1 ? fallback : n;\n}\n\n/** Read a string env var, falling back to the code default. */\nfunction envStr(name: string, fallback: string): string {\n  const raw = process.env[name];\n  return raw === undefined || raw === '' ? fallback : raw;\n}\n\n/**\n * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars\n * (e.g. `QUOTA_TIER_PRO_PIPELINES=250`, `QUOTA_TIER_DEVELOPER_STORAGE_BYTES=...`).\n * Unset/empty → the code default. `-1` = unlimited. Read once at module load —\n * on k8s these flow in via the `app-env` ConfigMap (built from `.env`).\n */\nfunction tierLimits(tier: QuotaTier): QuotaTierLimits {\n  // `unlimited` is uncapped BY DEFINITION: EVERY quota is -1 and it is NOT\n  // env-overridable. Reading QUOTA_TIER_UNLIMITED_* here would let a stray env\n  // var silently cap the billing-DISABLED default tier — surfacing as a spurious\n  // \"quota exceeded\" on a deploy that meters nothing. Derive -1 for every field\n  // from the limits shape so a newly-added quota is uncapped here automatically.\n  if (tier === 'unlimited') {\n    const uncapped = { ...DEFAULT_TIER_LIMITS.unlimited };\n    for (const k of Object.keys(uncapped) as (keyof QuotaTierLimits)[]) uncapped[k] = -1;\n    return uncapped;\n  }\n  const d = DEFAULT_TIER_LIMITS[tier];\n  const T = tier.toUpperCase();\n  return {\n    plugins: envInt(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),\n    pipelines: envInt(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),\n    apiCalls: envInt(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),\n    aiCalls: envInt(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),\n    storageBytes: envInt(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),\n    dashboards: envInt(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),\n    alertRules: envInt(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),\n    alertDestinations: envInt(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),\n    idpConfigs: envInt(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),\n    seats: envInt(`QUOTA_TIER_${T}_SEATS`, d.seats),\n    eventRetentionDays: envInt(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),\n    doraRetentionDays: envInt(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),\n  };\n}\n\n// Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).\nexport const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset> = {\n  developer: { label: envStr('QUOTA_TIER_DEVELOPER_LABEL', 'Developer'), limits: tierLimits('developer') },\n  pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },\n  team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },\n  enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },\n  unlimited: { label: envStr('QUOTA_TIER_UNLIMITED_LABEL', 'Unlimited'), limits: tierLimits('unlimited') },\n};\n\n/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*\n *  tier — `unlimited` is a valid value even though it's never offered for sale. */\nexport const VALID_TIERS: readonly QuotaTier[] = Object.keys(QUOTA_TIERS) as QuotaTier[];\n\n/** The standard, billing-selectable tiers — the ones offered as purchasable plans\n *  and shown in tier pickers. Derived as \"every valid tier except `unlimited`\",\n *  which is the billing-DISABLED default and is never displayed/selectable when\n *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */\nexport const STANDARD_TIERS: readonly QuotaTier[] = VALID_TIERS.filter((t) => t !== 'unlimited');\n\n/** Tiers that permit the org → team hierarchy (nesting teams under a root). The\n *  billing-off `unlimited` tier is team-capable (it's the most permissive); the\n *  entry-level `developer`/`pro` tiers are not. Single source for the parent-\n *  eligibility + downgrade-overcap checks so they can't drift. */\nexport const TEAM_CAPABLE_TIERS: readonly QuotaTier[] = ['team', 'enterprise', 'unlimited'];\nexport function tierAllowsTeams(tier: string | undefined | null): boolean {\n  return !!tier && (TEAM_CAPABLE_TIERS as readonly string[]).includes(tier);\n}\n\n/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,\n *  opt-out default-on — mirrors the billing/platform configs). With billing OFF\n *  there's no metering/enforcement surface, so the default tier is `unlimited`. */\nexport function isBillingEnabled(): boolean {\n  return (process.env.BILLING_ENABLED || 'true').toLowerCase() !== 'false';\n}\n\n/**\n * Default tier assigned to new organizations.\n * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).\n * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.\n */\nexport const DEFAULT_TIER: QuotaTier = !isBillingEnabled()\n  ? 'unlimited'\n  : (isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '') && process.env.DEFAULT_QUOTA_TIER !== 'unlimited'\n    ? (process.env.DEFAULT_QUOTA_TIER as QuotaTier)\n    : 'developer');\n\n/** Check whether a string is a valid QuotaTier. */\nexport function isValidTier(value: string): value is QuotaTier {\n  // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype\n  // chain, so inherited Object keys ('toString', 'constructor', …) would return\n  // true and then `getTierLimits` would read `.limits` off a function → crash.\n  // `tier` is attacker-influenceable (JWT / request body / DEFAULT_QUOTA_TIER env).\n  return (VALID_TIERS as readonly string[]).includes(value);\n}\n\n/** Get the default limits for a given tier (falls back to developer). */\nexport function getTierLimits(tier: string): QuotaTierLimits {\n  return isValidTier(tier) ? QUOTA_TIERS[tier].limits: QUOTA_TIERS.developer.limits;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-tiers.js","sourceRoot":"","sources":["../../src/types/quota-tiers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { envInt, envStr } from '../utils/env.js';\n\n/** Available quota tier identifiers.\n *\n * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes\n * every feature/add-on bundle. It is the DEFAULT when billing is disabled (no\n * metering/enforcement surface exists, so nothing is capped), and it is NEVER\n * shown or selectable when billing is enabled — see `STANDARD_TIERS`. */\nexport type QuotaTier = 'developer' | 'pro' | 'team' | 'enterprise' | 'unlimited';\n\n/** Limit values for each quota type within a tier. */\nexport interface QuotaTierLimits {\n  plugins: number;\n  pipelines: number;\n  apiCalls: number;\n  aiCalls: number;\n  /**\n   * Aggregate registry storage cap in BYTES. Counted across every repo\n   * under the org's `org-{orgId}/` namespace. -1 means unlimited.\n   * push-gate reads this; the image-registry rejects token issuance for\n   * `push` scope when the org's measured usage exceeds the limit.\n   */\n  storageBytes: number;\n  /** Count-quotas on the user-editable feature tables added to close per-org\n   *  DoS via spam. -1 means unlimited. */\n  dashboards: number;\n  alertRules: number;\n  alertDestinations: number;\n  idpConfigs: number;\n  /**\n   * Max org members (active users / seats). -1 = unlimited. This is the \"Team\"\n   * tier differentiator — enforced at member-invite time (an invite is blocked\n   * when active members + pending invites would exceed this).\n   */\n  seats: number;\n  /**\n   * Reporting retention in DAYS — NOT a flow quota (never decremented, absent\n   * from `VALID_QUOTA_TYPES`): these ride the tier-baseline + bundle-grant math\n   * purely as an entitlement the billing service syncs to reporting's\n   * `dora_settings`. -1 = unlimited (the sweep skips the org entirely).\n   *   `eventRetentionDays` — non-deploy `pipeline_events` (STAGE/ACTION/build).\n   *   `doraRetentionDays`  — deploy events + `deployment_outcomes` + `incidents`,\n   *                          and the per-org report-query window for DORA routes.\n   * Extendable via the `retention_pack` / `dora_history_pack` add-on bundles.\n   */\n  eventRetentionDays: number;\n  doraRetentionDays: number;\n}\n\n/** Full preset for a single tier (label + limits). */\nexport interface QuotaTierPreset {\n  label: string;\n  limits: QuotaTierLimits;\n}\n\n/**\n * Preset limits for each tier. -1 means unlimited.\n *\n * AI calls are sized much smaller than `apiCalls` because each call has\n * external provider cost (~$0.01$0.10/call). Developer tier allows light\n * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high\n * (25,000) — fair-use, not literally unlimited.\n *\n * `storageBytes` is the aggregate registry cap per org. Sized\n * around plugin-image realities: a typical plugin image is 200500 MB;\n * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 50 GB covers a\n * mature catalog. Operators can override per-org via the quota CRUD API.\n */\nconst GB = 1024 * 1024 * 1024;\n\n/**\n * Code-default limits per tier — the fallback when no env override is set.\n * -1 means unlimited. (Counts sized to \"comfortably enough for one team, not\n * script spam\": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config\n * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas\n * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)\n */\nconst DEFAULT_TIER_LIMITS: Record<QuotaTier, QuotaTierLimits> = {\n  // Free tier: single seat, 2 pipelines, apiCalls CAPPED (was unlimited — a\n  // DoS/abuse hole on a shared resource); aiCalls small (each has ~$0.01-0.10\n  // external cost). Lean base — growth happens by upgrading, not stacking here.\n  developer: {\n    plugins: 25,\n    pipelines: 2,\n    apiCalls: 25_000,\n    aiCalls: 25,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\n    seats: 1,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Pro = individual power user, single seat, individual pricing. A 2nd seat (or\n  // team collaboration) requires the Team tier — the `seat` add-on is Team+ only,\n  // keeping Team the collaboration tier. Pro's value over Developer is its richer\n  // call/storage/plugin ceilings + feature add-ons (SSO/audit/DORA), not seats.\n  pro: {\n    plugins: 50,\n    pipelines: 5,\n    apiCalls: 250_000,\n    aiCalls: 1_000,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\n    seats: 1,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Team = collaboration tier; the seat limit (3) is the real differentiator over\n  // Pro (single-seat) — it's the multi-seat collaboration floor. Lean base ($79):\n  // growth rides the seat/pipeline/etc add-ons (land-and-expand). Limits sit\n  // between Pro and Enterprise.\n  team: {\n    plugins: 75,\n    pipelines: 6,\n    apiCalls: 500_000,\n    aiCalls: 2_500,\n    storageBytes: 60 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    seats: 3,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Enterprise ($599, held): the all-inclusive tier — 15 seats, 30 pipelines, ALL\n  // premium features included (see TIER_FEATURES). FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped so one account can't run up unbounded\n  // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.\n  enterprise: {\n    plugins: 150,\n    pipelines: 30,\n    apiCalls: 900_000,\n    aiCalls: 9_000,\n    storageBytes: 250 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: 15,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled\n  // (no enforcement surface) — never shown/selectable when billing is enabled.\n  unlimited: {\n    plugins: -1,\n    pipelines: -1,\n    apiCalls: -1,\n    aiCalls: -1,\n    storageBytes: -1,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: -1,\n    eventRetentionDays: -1,\n    doraRetentionDays: -1,\n  },\n};\n\n/**\n * Read a tier LIMIT env var. `-1` = unlimited; anything below that is nonsense\n * (a `-5` limit would ship a broken finite cap), so it falls back to the code\n * default rather than clamping up to `-1`. The parsing itself is api-core's\n * shared `envInt` — strict about decimals/garbage — not a local re-derivation.\n */\nfunction tierLimitEnv(name: string, fallback: number): number {\n  const n = envInt(name, fallback);\n  return n < -1 ? fallback : n;\n}\n\n/**\n * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars\n * (e.g. `QUOTA_TIER_PRO_PIPELINES=250`, `QUOTA_TIER_DEVELOPER_STORAGE_BYTES=...`).\n * Unset/empty → the code default. `-1` = unlimited. Read once at module load —\n * on k8s these flow in via the `app-env` ConfigMap (built from `.env`).\n */\nfunction tierLimits(tier: QuotaTier): QuotaTierLimits {\n  // `unlimited` is uncapped BY DEFINITION: EVERY quota is -1 and it is NOT\n  // env-overridable. Reading QUOTA_TIER_UNLIMITED_* here would let a stray env\n  // var silently cap the billing-DISABLED default tier — surfacing as a spurious\n  // \"quota exceeded\" on a deploy that meters nothing. Derive -1 for every field\n  // from the limits shape so a newly-added quota is uncapped here automatically.\n  if (tier === 'unlimited') {\n    const uncapped = { ...DEFAULT_TIER_LIMITS.unlimited };\n    for (const k of Object.keys(uncapped) as (keyof QuotaTierLimits)[]) uncapped[k] = -1;\n    return uncapped;\n  }\n  const d = DEFAULT_TIER_LIMITS[tier];\n  const T = tier.toUpperCase();\n  return {\n    plugins: tierLimitEnv(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),\n    pipelines: tierLimitEnv(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),\n    apiCalls: tierLimitEnv(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),\n    aiCalls: tierLimitEnv(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),\n    storageBytes: tierLimitEnv(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),\n    dashboards: tierLimitEnv(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),\n    alertRules: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),\n    alertDestinations: tierLimitEnv(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),\n    idpConfigs: tierLimitEnv(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),\n    seats: tierLimitEnv(`QUOTA_TIER_${T}_SEATS`, d.seats),\n    eventRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),\n    doraRetentionDays: tierLimitEnv(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),\n  };\n}\n\n// Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).\nexport const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset> = {\n  developer: { label: envStr('QUOTA_TIER_DEVELOPER_LABEL', 'Developer'), limits: tierLimits('developer') },\n  pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },\n  team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },\n  enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },\n  unlimited: { label: envStr('QUOTA_TIER_UNLIMITED_LABEL', 'Unlimited'), limits: tierLimits('unlimited') },\n};\n\n/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*\n *  tier — `unlimited` is a valid value even though it's never offered for sale. */\nexport const VALID_TIERS: readonly QuotaTier[] = Object.keys(QUOTA_TIERS) as QuotaTier[];\n\n/** The standard, billing-selectable tiers — the ones offered as purchasable plans\n *  and shown in tier pickers. Derived as \"every valid tier except `unlimited`\",\n *  which is the billing-DISABLED default and is never displayed/selectable when\n *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */\nexport const STANDARD_TIERS: readonly QuotaTier[] = VALID_TIERS.filter((t) => t !== 'unlimited');\n\n/** Tiers that permit the org → team hierarchy (nesting teams under a root). The\n *  billing-off `unlimited` tier is team-capable (it's the most permissive); the\n *  entry-level `developer`/`pro` tiers are not. Single source for the parent-\n *  eligibility + downgrade-overcap checks so they can't drift. */\nexport const TEAM_CAPABLE_TIERS: readonly QuotaTier[] = ['team', 'enterprise', 'unlimited'];\nexport function tierAllowsTeams(tier: string | undefined | null): boolean {\n  return !!tier && (TEAM_CAPABLE_TIERS as readonly string[]).includes(tier);\n}\n\n/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,\n *  opt-out default-on — mirrors the billing/platform configs). With billing OFF\n *  there's no metering/enforcement surface, so the default tier is `unlimited`. */\nexport function isBillingEnabled(): boolean {\n  return (process.env.BILLING_ENABLED || 'true').toLowerCase() !== 'false';\n}\n\n/**\n * Default tier assigned to new organizations.\n * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).\n * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.\n */\nexport const DEFAULT_TIER: QuotaTier = !isBillingEnabled()\n  ? 'unlimited'\n  : (isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '') && process.env.DEFAULT_QUOTA_TIER !== 'unlimited'\n    ? (process.env.DEFAULT_QUOTA_TIER as QuotaTier)\n    : 'developer');\n\n/** Check whether a string is a valid QuotaTier. */\nexport function isValidTier(value: string): value is QuotaTier {\n  // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype\n  // chain, so inherited Object keys ('toString', 'constructor', …) would return\n  // true and then `getTierLimits` would read `.limits` off a function → crash.\n  // `tier` is attacker-influenceable (JWT / request body / DEFAULT_QUOTA_TIER env).\n  return (VALID_TIERS as readonly string[]).includes(value);\n}\n\n/** Get the default limits for a given tier (falls back to developer). */\nexport function getTierLimits(tier: string): QuotaTierLimits {\n  return isValidTier(tier) ? QUOTA_TIERS[tier].limits: QUOTA_TIERS.developer.limits;\n}\n"]}

package/lib/utils/api-key.d.ts

@@ -2,8 +2,6 @@
 export declare const API_KEY_PREFIXES: readonly ['pb_pat', 'pb_sa'];
 /** One of {@link API_KEY_PREFIXES}. `pb_sa` is reserved for service accounts. */
 export type ApiKeyPrefix = (typeof API_KEY_PREFIXES)[number];
-/** Random bytes behind each key — 256 bits, base64url-encoded to 43 chars. */
-export declare const API_KEY_SECRET_BYTES = 32;
 /**
  * Lifetime of the JWT an exchange returns. Short by design: it is the window in
  * which a revoked key still works, and the reason services never need to read a
@@ -25,10 +23,3 @@ export declare function apiKeyPrefixOf(credential: string | undefined): ApiKeyPr
 export declare function hashApiKey(key: string): string;
 /** Mint a new key. The caller stores only {@link hashApiKey} of the result. */
 export declare function generateApiKey(prefix: ApiKeyPrefix): string;
-/** The last four characters of a key — displayed with the prefix to name it. */
-export declare function apiKeyLast4(key: string): string;
-/**
- * How a key is shown once it can no longer be read: `pb_pat_…a1b2`. Built from
- * the stored prefix + last4, never from the secret.
- */
-export declare function formatApiKeyDisplay(prefix: string, last4: string): string;

package/lib/utils/api-key.js

@@ -23,7 +23,7 @@ import { createHash, randomBytes } from 'crypto';
 /** Prefixes that name what kind of principal a key speaks for. */
 export const API_KEY_PREFIXES = ['pb_pat', 'pb_sa'];
 /** Random bytes behind each key — 256 bits, base64url-encoded to 43 chars. */
-export const API_KEY_SECRET_BYTES = 32;
+const API_KEY_SECRET_BYTES = 32;
 /**
  * Lifetime of the JWT an exchange returns. Short by design: it is the window in
  * which a revoked key still works, and the reason services never need to read a
@@ -61,15 +61,4 @@ export function hashApiKey(key) {
 export function generateApiKey(prefix) {
     return `${prefix}_${randomBytes(API_KEY_SECRET_BYTES).toString('base64url')}`;
 }
-/** The last four characters of a key — displayed with the prefix to name it. */
-export function apiKeyLast4(key) {
-    return key.slice(-4);
-}
-/**
- * How a key is shown once it can no longer be read: `pb_pat_…a1b2`. Built from
- * the stored prefix + last4, never from the secret.
- */
-export function formatApiKeyDisplay(prefix, last4) {
-    return `${prefix}_…${last4}`;
-}
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/audit.js

@@ -1,6 +1,7 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { scrubAwsIdentifiers } from './aws-scrub.js';
+import { errorMessage } from './response.js';
 /**
  * Emit a cross-service audit event as a structured log line.
  *
@@ -28,7 +29,7 @@ export function emitAudit(logger, audit) {
         try {
             logger.warn('Failed to emit audit event', {
                 event: audit.event,
-                error: err instanceof Error ? err.message : String(err),
+                error: errorMessage(err),
             });
         }
         catch {
@@ -36,4 +37,4 @@ export function emitAudit(logger, audit) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/env.d.ts

@@ -10,8 +10,12 @@
  * `validation/common-schemas.ts`).
  */
 /**
- * Parse an integer env var. Unset / blank / non-numeric → `def`. Optional
- * `min`/`max` clamp the result (applied after the default).
+ * Parse an integer env var. Unset / blank / not a clean integer string → `def`.
+ * Optional `min`/`max` clamp the result (applied after the default).
+ *
+ * STRICT on purpose: `parseInt` accepts `50.5` (→ 50) and `12abc` (→ 12), which
+ * is how a typo'd quota limit or timeout silently ships a value nobody wrote.
+ * Anything that isn't `-?\d+` falls back to the code default instead.
  */
 export declare function envInt(name: string, def: number, opts?: {
     min?: number;

package/lib/utils/env.js

@@ -12,12 +12,17 @@
  * `validation/common-schemas.ts`).
  */
 /**
- * Parse an integer env var. Unset / blank / non-numeric → `def`. Optional
- * `min`/`max` clamp the result (applied after the default).
+ * Parse an integer env var. Unset / blank / not a clean integer string → `def`.
+ * Optional `min`/`max` clamp the result (applied after the default).
+ *
+ * STRICT on purpose: `parseInt` accepts `50.5` (→ 50) and `12abc` (→ 12), which
+ * is how a typo'd quota limit or timeout silently ships a value nobody wrote.
+ * Anything that isn't `-?\d+` falls back to the code default instead.
  */
 export function envInt(name, def, opts) {
     const raw = process.env[name];
-    let n = raw === undefined || raw.trim() === '' ? def : Number.parseInt(raw, 10);
+    const trimmed = raw?.trim() ?? '';
+    let n = trimmed !== '' && /^[+-]?\d+$/.test(trimmed) ? Number.parseInt(trimmed, 10) : def;
     if (!Number.isFinite(n))
         n = def;
     if (opts?.min !== undefined)
@@ -46,4 +51,4 @@ export function envStr(name, def) {
     const raw = process.env[name];
     return raw === undefined || raw.trim() === '' ? def : raw;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/identity.d.ts

@@ -12,11 +12,47 @@ export interface RequestIdentity {
     /** User role from x-user-role header (decoded from JWT) */
     readonly role?: string;
 }
+/**
+ * Canonical org-id normalization: trim + lowercase, empty ⇒ undefined.
+ *
+ * The SINGLE spelling rule for a tenant id across the fleet. Org ids are
+ * 24-hex ObjectId strings (plus the `'system'` sentinel), and hex is
+ * case-insensitive — so `Acme`-style casing differences resolve to the SAME
+ * Mongo document while string comparisons (`activeOrgId === targetOrgId`, an
+ * RLS GUC vs a WHERE clause, a cache key) silently disagree. Everything that
+ * compares or keys on an org id normalizes through here so the comparison and
+ * the lookup can never drift apart.
+ */
+export declare function normalizeOrgId(orgId: string | undefined | null): string | undefined;
+/**
+ * The actor id written when nothing in the request attributes the action to a
+ * person — an internal service hop, a scheduler tick, a token whose subject
+ * never resolved. One spelling, because the audit trail is queried by it.
+ */
+export declare const SYSTEM_ACTOR_ID = "system";
+/**
+ * The actor id to stamp on an audit event, from a route context.
+ *
+ * Route handlers used to reach back into `req.user.sub` themselves, with
+ * fallbacks that disagreed across services (`?? ''`, `?? userId ?? 'system'`,
+ * `?? 'system'`) — so the same unattributable write landed in the trail under
+ * three different actors depending on which route wrote it.
+ *
+ * `rc.userId` is already the normalized identity `withRoute` resolved (JWT
+ * `sub`, else the `x-user-id` hop header — see {@link getIdentity}), so this is
+ * the same value the rest of the request is scoped by, and the ONE place the
+ * "unattributable" sentinel is chosen. Accepts anything carrying a `userId`,
+ * which the route context does — pass `rc`, or `{ userId }` when the handler
+ * destructures.
+ */
+export declare function actorId(rc: {
+    userId?: string | null;
+}): string;
 /**
  * Extract identity information from request headers.
  *
  * Extracts common identity headers used for multi-tenant authentication:
- * - x-org-id: Organization identifier
+ * - x-org-id: Organization identifier (INTERNAL SERVICE hops only, see below)
  * - x-user-id: User identifier
  * - x-request-id: Request trace identifier
  * - x-user-role: User role

package/lib/utils/identity.js

@@ -1,11 +1,49 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { getHeaderString } from './headers.js';
+/**
+ * Canonical org-id normalization: trim + lowercase, empty ⇒ undefined.
+ *
+ * The SINGLE spelling rule for a tenant id across the fleet. Org ids are
+ * 24-hex ObjectId strings (plus the `'system'` sentinel), and hex is
+ * case-insensitive — so `Acme`-style casing differences resolve to the SAME
+ * Mongo document while string comparisons (`activeOrgId === targetOrgId`, an
+ * RLS GUC vs a WHERE clause, a cache key) silently disagree. Everything that
+ * compares or keys on an org id normalizes through here so the comparison and
+ * the lookup can never drift apart.
+ */
+export function normalizeOrgId(orgId) {
+    return orgId?.trim().toLowerCase() || undefined;
+}
+/**
+ * The actor id written when nothing in the request attributes the action to a
+ * person — an internal service hop, a scheduler tick, a token whose subject
+ * never resolved. One spelling, because the audit trail is queried by it.
+ */
+export const SYSTEM_ACTOR_ID = 'system';
+/**
+ * The actor id to stamp on an audit event, from a route context.
+ *
+ * Route handlers used to reach back into `req.user.sub` themselves, with
+ * fallbacks that disagreed across services (`?? ''`, `?? userId ?? 'system'`,
+ * `?? 'system'`) — so the same unattributable write landed in the trail under
+ * three different actors depending on which route wrote it.
+ *
+ * `rc.userId` is already the normalized identity `withRoute` resolved (JWT
+ * `sub`, else the `x-user-id` hop header — see {@link getIdentity}), so this is
+ * the same value the rest of the request is scoped by, and the ONE place the
+ * "unattributable" sentinel is chosen. Accepts anything carrying a `userId`,
+ * which the route context does — pass `rc`, or `{ userId }` when the handler
+ * destructures.
+ */
+export function actorId(rc) {
+    return rc.userId || SYSTEM_ACTOR_ID;
+}
 /**
  * Extract identity information from request headers.
  *
  * Extracts common identity headers used for multi-tenant authentication:
- * - x-org-id: Organization identifier
+ * - x-org-id: Organization identifier (INTERNAL SERVICE hops only, see below)
  * - x-user-id: User identifier
  * - x-request-id: Request trace identifier
  * - x-user-role: User role
@@ -32,15 +70,29 @@ export function getIdentity(req) {
     // JWT (e.g. requestId). The JWT payload uses `sub` for the user id per
     // OIDC convention; that's our authoritative source.
     const user = req.user;
-    // Canonical orgId normalization — the SINGLE source of truth. Lowercasing
-    // (and trimming) ONCE here guarantees the RLS GUC (`identityScope` reads this
-    // raw `identity.orgId`) and the app-layer WHERE clauses (route-wrapper /
-    // app-factory, which historically re-lowercased) always agree on tenant. A
+    // The `x-org-id` header is CLIENT-SETTABLE, so it is only ever honored for a
+    // principal that has no tenant of its own to speak for:
+    //   - an INTERNAL SERVICE principal (`principalType: 'service'`), whose token
+    //     names the signing service rather than the tenant it is acting for —
+    //     that is the S2S hop convention (the cascade, the quota client, …); and
+    //   - a request with no verified principal at all (`attachRequestContext`
+    //     runs before `requireAuth`, which recomputes this from the JWT).
+    // For a USER or SERVICE-ACCOUNT principal the JWT is the ONLY authority.
+    // Platform can mint a user token with no `organizationId` (a person between
+    // orgs, mid-invite, mid-onboarding), and the old `user?.organizationId ||
+    // header` fallback let such a token name any tenant it liked — a value that
+    // flows straight into the RLS tenant GUC. Absent ⇒ undefined ⇒ the route's
+    // `requireOrgId` refuses the call, which is the correct answer.
+    const principalType = user?.principalType;
+    const headerOrgId = getHeaderString(req.headers['x-org-id']);
+    const mayUseHeaderOrg = !user || principalType === 'service';
+    const rawOrgId = user?.organizationId || (mayUseHeaderOrg ? headerOrgId : undefined);
+    // Normalized ONCE here (see normalizeOrgId) so the RLS GUC (`identityScope`
+    // reads this `identity.orgId`) and the app-layer WHERE clauses (route-wrapper
+    // / app-factory, which historically re-lowercased) always agree on tenant. A
     // mismatch — GUC set to `Acme` while WHERE queries `acme` — would, under
-    // owner-bypass RLS, silently scope reads to the wrong (or no) tenant. Empty /
-    // whitespace-only collapses to undefined so "missing org" stays falsy.
-    const rawOrgId = user?.organizationId || getHeaderString(req.headers['x-org-id']);
-    const orgId = rawOrgId?.trim().toLowerCase() || undefined;
+    // owner-bypass RLS, silently scope reads to the wrong (or no) tenant.
+    const orgId = normalizeOrgId(rawOrgId);
     return {
         orgId,
         userId: user?.sub || getHeaderString(req.headers['x-user-id']),
@@ -48,4 +100,4 @@ export function getIdentity(req) {
         role: user?.role || getHeaderString(req.headers['x-user-role']),
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/utils/identity.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAiB/C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,KAAgC;IAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,SAAS,CAAC;AAClD,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,OAAO,CAAC,EAA8B;IACpD,OAAO,EAAE,CAAC,MAAM,IAAI,eAAe,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,WAAW,CAAC,GAAgB;IAC1C,oEAAoE;IACpE,uEAAuE;IACvE,uEAAuE;IACvE,oDAAoD;IACpD,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;IACtB,6EAA6E;IAC7E,wDAAwD;IACxD,8EAA8E;IAC9E,0EAA0E;IAC1E,6EAA6E;IAC7E,0EAA0E;IAC1E,sEAAsE;IACtE,yEAAyE;IACzE,4EAA4E;IAC5E,0EAA0E;IAC1E,4EAA4E;IAC5E,2EAA2E;IAC3E,gEAAgE;IAChE,MAAM,aAAa,GAAG,IAAI,EAAE,aAAa,CAAC;IAC1C,MAAM,WAAW,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7D,MAAM,eAAe,GAAG,CAAC,IAAI,IAAI,aAAa,KAAK,SAAS,CAAC;IAC7D,MAAM,QAAQ,GAAG,IAAI,EAAE,cAAc,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACrF,4EAA4E;IAC5E,8EAA8E;IAC9E,6EAA6E;IAC7E,yEAAyE;IACzE,sEAAsE;IACtE,MAAM,KAAK,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IACvC,OAAO;QACL,KAAK;QACL,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAC9D,SAAS,EAAE,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACvD,IAAI,EAAE,IAAI,EAAE,IAAI,IAAI,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;KAChE,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { getHeaderString } from './headers.js';\nimport type { HttpRequest } from '../types/http.js';\n\n/**\n * Identity information extracted from request headers.\n */\nexport interface RequestIdentity {\n  /** Organization ID from x-org-id header */\n  readonly orgId?: string;\n  /** User ID from x-user-id header */\n  readonly userId?: string;\n  /** Request ID from x-request-id header */\n  readonly requestId?: string;\n  /** User role from x-user-role header (decoded from JWT) */\n  readonly role?: string;\n}\n\n/**\n * Canonical org-id normalization: trim + lowercase, empty ⇒ undefined.\n *\n * The SINGLE spelling rule for a tenant id across the fleet. Org ids are\n * 24-hex ObjectId strings (plus the `'system'` sentinel), and hex is\n * case-insensitive — so `Acme`-style casing differences resolve to the SAME\n * Mongo document while string comparisons (`activeOrgId === targetOrgId`, an\n * RLS GUC vs a WHERE clause, a cache key) silently disagree. Everything that\n * compares or keys on an org id normalizes through here so the comparison and\n * the lookup can never drift apart.\n */\nexport function normalizeOrgId(orgId: string | undefined | null): string | undefined {\n  return orgId?.trim().toLowerCase() || undefined;\n}\n\n/**\n * The actor id written when nothing in the request attributes the action to a\n * person — an internal service hop, a scheduler tick, a token whose subject\n * never resolved. One spelling, because the audit trail is queried by it.\n */\nexport const SYSTEM_ACTOR_ID = 'system';\n\n/**\n * The actor id to stamp on an audit event, from a route context.\n *\n * Route handlers used to reach back into `req.user.sub` themselves, with\n * fallbacks that disagreed across services (`?? ''`, `?? userId ?? 'system'`,\n * `?? 'system'`) — so the same unattributable write landed in the trail under\n * three different actors depending on which route wrote it.\n *\n * `rc.userId` is already the normalized identity `withRoute` resolved (JWT\n * `sub`, else the `x-user-id` hop header — see {@link getIdentity}), so this is\n * the same value the rest of the request is scoped by, and the ONE place the\n * \"unattributable\" sentinel is chosen. Accepts anything carrying a `userId`,\n * which the route context does — pass `rc`, or `{ userId }` when the handler\n * destructures.\n */\nexport function actorId(rc: { userId?: string | null }): string {\n  return rc.userId || SYSTEM_ACTOR_ID;\n}\n\n/**\n * Extract identity information from request headers.\n *\n * Extracts common identity headers used for multi-tenant authentication:\n * - x-org-id: Organization identifier (INTERNAL SERVICE hops only, see below)\n * - x-user-id: User identifier\n * - x-request-id: Request trace identifier\n * - x-user-role: User role\n *\n * @param req - HTTP request object\n * @returns Identity object with orgId, userId, requestId, and role\n *\n * @example\n * ```typescript\n * app.post('/api/resource', requireAuth, async (req, res) => {\n *   const identity = getIdentity(req);\n *\n *   if (!identity.orgId) {\n *     return sendError(res, 400, 'x-org-id header required');\n *   }\n *\n *   // Use identity.orgId, identity.userId, etc.\n * });\n * ```\n */\nexport function getIdentity(req: HttpRequest): RequestIdentity {\n  // Prefer JWT-verified claims (req.user) over raw headers to prevent\n  // spoofing. Headers are only used as fallback or for fields not in the\n  // JWT (e.g. requestId). The JWT payload uses `sub` for the user id per\n  // OIDC convention; that's our authoritative source.\n  const user = req.user;\n  // The `x-org-id` header is CLIENT-SETTABLE, so it is only ever honored for a\n  // principal that has no tenant of its own to speak for:\n  //   - an INTERNAL SERVICE principal (`principalType: 'service'`), whose token\n  //     names the signing service rather than the tenant it is acting for —\n  //     that is the S2S hop convention (the cascade, the quota client, …); and\n  //   - a request with no verified principal at all (`attachRequestContext`\n  //     runs before `requireAuth`, which recomputes this from the JWT).\n  // For a USER or SERVICE-ACCOUNT principal the JWT is the ONLY authority.\n  // Platform can mint a user token with no `organizationId` (a person between\n  // orgs, mid-invite, mid-onboarding), and the old `user?.organizationId ||\n  // header` fallback let such a token name any tenant it liked — a value that\n  // flows straight into the RLS tenant GUC. Absent ⇒ undefined ⇒ the route's\n  // `requireOrgId` refuses the call, which is the correct answer.\n  const principalType = user?.principalType;\n  const headerOrgId = getHeaderString(req.headers['x-org-id']);\n  const mayUseHeaderOrg = !user || principalType === 'service';\n  const rawOrgId = user?.organizationId || (mayUseHeaderOrg ? headerOrgId : undefined);\n  // Normalized ONCE here (see normalizeOrgId) so the RLS GUC (`identityScope`\n  // reads this `identity.orgId`) and the app-layer WHERE clauses (route-wrapper\n  // / app-factory, which historically re-lowercased) always agree on tenant. A\n  // mismatch — GUC set to `Acme` while WHERE queries `acme` — would, under\n  // owner-bypass RLS, silently scope reads to the wrong (or no) tenant.\n  const orgId = normalizeOrgId(rawOrgId);\n  return {\n    orgId,\n    userId: user?.sub || getHeaderString(req.headers['x-user-id']),\n    requestId: getHeaderString(req.headers['x-request-id']),\n    role: user?.role || getHeaderString(req.headers['x-user-role']),\n  };\n}\n"]}

package/lib/utils/index.d.ts

@@ -7,7 +7,8 @@ export * from './response.js';
 export * from './params.js';
 export * from './headers.js';
 export * from './identity.js';
-export * from './jwk.js';
+export { USER_TOKEN_ALGORITHM, USER_TOKEN_CURVE, JWKS_PATH, decodeJwtHeader, isJwksDocument, publicJwkFrom, derToJoseSignature, } from './jwk.js';
+export type { PublicJwk, JwksDocument, JwtHeader } from './jwk.js';
 export * from './object.js';
 export * from './alias-resolver.js';
 export * from './concurrency.js';

package/lib/utils/index.js

@@ -9,7 +9,12 @@ export * from './response.js';
 export * from './params.js';
 export * from './headers.js';
 export * from './identity.js';
-export * from './jwk.js';
+// JWK primitives. Platform IS the token signer, so it legitimately needs
+// `publicJwkFrom` + `derToJoseSignature` from the package surface.
+// `jwkThumbprint` and `publicKeyFromJwk` are kid-derivation/verification
+// plumbing used only inside api-core — deep-import them from there instead of
+// leaking them to every service.
+export { USER_TOKEN_ALGORITHM, USER_TOKEN_CURVE, JWKS_PATH, decodeJwtHeader, isJwksDocument, publicJwkFrom, derToJoseSignature, } from './jwk.js';
 export * from './object.js';
 export * from './alias-resolver.js';
 export * from './concurrency.js';
@@ -22,4 +27,4 @@ export * from './sensitive-patterns.js';
 export * from './ssrf.js';
 export * from './env.js';
 export * from './compliance-attributes.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9sb2dnZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9hcGkta2V5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc2FmZS1yZXF1aXJlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc2VjdXJlLWNvbXBhcmUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jcmFzaC1oYW5kbGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc3BvbnNlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcGFyYW1zLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vaGVhZGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2lkZW50aXR5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vandrLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vb2JqZWN0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vYWxpYXMtcmVzb2x2ZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb25jdXJyZW5jeS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F1ZGl0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc2VjcmV0LWVuY3J5cHRpb24uanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWNyZXQtcm90YXRpb24uanMnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXRyaWMtZW1pdHRlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F3cy1zY3J1Yi5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NlbnNpdGl2ZS1wYXR0ZXJucy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NzcmYuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnYuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wbGlhbmNlLWF0dHJpYnV0ZXMuanMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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