@pipeline-builder/api-core 5.2.6 → 5.2.8

package/lib/types/tier-limits.js

@@ -0,0 +1,254 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * A tier key as product copy: `developer` → "Developer", `pro_plus` → "Pro Plus".
+ *
+ * Lives here, with the other tier facts, because three callers want it: the
+ * default `QUOTA_TIERS` label, the shared test fixture's labels (which kept a
+ * second `titleCase` of its own), and the browser.
+ *
+ * It will NOT guess at an acronym (`sso` → "Sso") or a stylized name ("Pro+"),
+ * and deliberately takes no formatting options: the cases it cannot derive need
+ * a human writing copy, which is what `QUOTA_TIER_<TIER>_LABEL` is for. A mode
+ * flag would add surface without reaching any of them, and a mid-sentence phrase
+ * ("… — new version") is a different FACT from a standalone label rather than
+ * another style of one — `quota-catalog.ts` carries `label` and `labelPlural` as
+ * separate named fields for exactly that reason.
+ */
+export function tierLabel(tier) {
+    return tier
+        .split(/[_-]/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Preset limits for each tier. -1 means unlimited.
+ *
+ * AI calls are sized much smaller than `apiCalls` because each call has
+ * external provider cost (~$0.01$0.10/call). Developer tier allows light
+ * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high
+ * (25,000) — fair-use, not literally unlimited.
+ *
+ * `storageBytes` is the aggregate registry cap per org. Sized
+ * around plugin-image realities: a typical plugin image is 200500 MB;
+ * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 25 GB covers a
+ * mature catalog. Operators can override per-org via the quota CRUD API.
+ */
+const GB = 1024 * 1024 * 1024;
+/**
+ * How the `automationCalls` defaults are sized — written down so the next
+ * person to touch them argues with the arithmetic, not with the numbers.
+ *
+ * Every call an org's automation keys make in one pipeline RUN, itemized (the
+ * earlier sizing counted only the plugin lookups and hand-waved the rest as
+ * "×2"):
+ *
+ *   plugin lookups            12   one per plugin step (self-mutating pipeline)
+ *   synth                      1   the synth step fetching the pipeline config
+ *   runtime check              1   the pre-deploy runtime-check call
+ *   security-report upload     1   the scan step posting its report
+ *   registry register          1   pipeline-register stamping the deployed version
+ *   reporting ingest batches  12   the event forwarder posts ~one batch per action
+ *                             --
+ *                             28   calls per run
+ *
+ * Per default period (`QUOTA_RESET_DAYS`, 3 days) one active pipeline running
+ * hourly makes 28 × 24 × 3 = 2,016 calls. An org keeps far more pipelines alive
+ * than it CREATES in a period (`pipelines` is a creation rate), so active
+ * pipelines are taken as 4× the tier's `pipelines`. On top sits a per-ORG
+ * constant that does not scale with pipelines: the ingest-health heartbeat
+ * (≤ 1/minute → 1,440/day → 4,320/period). The sum gets 25% headroom (retries,
+ * registry pushes, ad-hoc CI scripts on keys) and rounds UP to the next 10,000:
+ *
+ *   developer   2×4×2016 + 4320 =  20,448 × 1.25 =  25,560 →  30,000
+ *   pro         5×4×2016 + 4320 =  44,640 × 1.25 =  55,800 →  60,000
+ *   team       10×4×2016 + 4320 =  84,960 × 1.25 = 106,200 → 110,000
+ *   business   20×4×2016 + 4320 = 165,600 × 1.25 = 207,000 → 210,000
+ *   enterprise 30×4×2016 + 4320 = 246,240 × 1.25 = 307,800 → 310,000
+ *
+ * {@link automationCallsFor} computes exactly this, and the tier tests hold the
+ * table to it. Over the cap the 429 is SOFT for a band ({@link quotaGracePct}):
+ * a self-mutating pipeline that hard-stopped at 100% stayed stopped until the
+ * period reset, up to 3 days. The limits are PER PERIOD: an operator who
+ * lengthens `QUOTA_RESET_DAYS` should scale `QUOTA_TIER_<TIER>_AUTOMATION_CALLS`
+ * by the same factor.
+ */
+export const AUTOMATION_CALLS_SIZING = {
+    callsPerRun: {
+        pluginLookups: 12,
+        synth: 1,
+        runtimeCheck: 1,
+        securityReportUpload: 1,
+        registryRegister: 1,
+        ingestBatches: 12,
+    },
+    runsPerDay: 24,
+    activePipelinesPerCreation: 4,
+    /** Ingest-health heartbeats per org per day (≤ one a minute). */
+    heartbeatsPerDay: 1440,
+    /** Multiplier on the itemized total. */
+    headroom: 1.25,
+    /** Defaults round UP to a multiple of this. */
+    roundTo: 10_000,
+};
+/** The {@link AUTOMATION_CALLS_SIZING} formula for a tier creating `pipelines` per period. */
+export function automationCallsFor(pipelines, periodDays = 3) {
+    const s = AUTOMATION_CALLS_SIZING;
+    const perRun = Object.values(s.callsPerRun).reduce((a, b) => a + b, 0);
+    const perPipeline = perRun * s.runsPerDay * periodDays;
+    const total = (pipelines * s.activePipelinesPerCreation * perPipeline + s.heartbeatsPerDay * periodDays) * s.headroom;
+    return Math.ceil(total / s.roundTo) * s.roundTo;
+}
+/**
+ * Code-default limits per tier — the fallback when no env override is set.
+ *
+ * SERVER CODE WANTS `getTierLimits(tier)` / `QUOTA_TIERS[tier].limits`, not this
+ * table: those carry the deployment's `QUOTA_TIER_*` overrides, and this is what
+ * they fall back to. It is exported for the BROWSER, which has no env to overlay
+ * and gets the deployment's effective figures from `/config` instead.
+ * -1 means unlimited. (Counts sized to "comfortably enough for one team, not
+ * script spam": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config
+ * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas
+ * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)
+ */
+export const DEFAULT_TIER_LIMITS = {
+    // Free tier: single seat, 2 pipelines, apiCalls CAPPED (was unlimited — a
+    // DoS/abuse hole on a shared resource); aiCalls small (each has ~$0.01-0.10
+    // external cost). Lean base — growth happens by upgrading, not stacking here.
+    developer: {
+        plugins: 10,
+        pipelines: 2,
+        apiCalls: 25_000,
+        automationCalls: 30_000,
+        aiCalls: 20,
+        cpuCredits: 4_500,
+        storageBytes: 2 * GB,
+        dashboards: 20,
+        alertRules: 50,
+        alertDestinations: 10,
+        idpConfigs: 1,
+        listings: 3,
+        seats: 1,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Pro = individual power user, single seat, individual pricing. A 2nd seat (or
+    // team collaboration) requires the Team tier — the `seat` add-on is Team+ only,
+    // keeping Team the collaboration tier. Pro's value over Developer is its richer
+    // call/storage/plugin ceilings + feature add-ons (SSO/audit/DORA), not seats.
+    pro: {
+        plugins: 25,
+        pipelines: 5,
+        apiCalls: 100_000,
+        automationCalls: 60_000,
+        aiCalls: 200,
+        cpuCredits: 11_250,
+        storageBytes: 25 * GB,
+        dashboards: 200,
+        alertRules: 500,
+        alertDestinations: 50,
+        idpConfigs: 5,
+        listings: 10,
+        seats: 1,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Team = collaboration tier; the seat limit (3) is the real differentiator over
+    // Pro (single-seat) — it's the multi-seat collaboration floor. Lean base ($79):
+    // growth rides the seat/pipeline/etc add-ons (land-and-expand). Limits sit
+    // between Pro and Enterprise.
+    team: {
+        plugins: 50,
+        pipelines: 10,
+        apiCalls: 300_000,
+        automationCalls: 110_000,
+        aiCalls: 600,
+        cpuCredits: 22_500,
+        storageBytes: 60 * GB,
+        dashboards: -1,
+        alertRules: -1,
+        alertDestinations: -1,
+        idpConfigs: 5,
+        listings: 25,
+        seats: 3,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Business ($249): the step the $79 -> $599 cliff was missing. 8 seats, 20
+    // pipelines, and DORA (advanced_reporting) included rather than an add-on.
+    // Every cost driver is 100,000 apiCalls and 200 aiCalls PER SEAT, the same
+    // per-seat rate as Pro/Team/Enterprise, so the ladder reads consistently to a
+    // buyer who divides by headcount. Count-quotas that Team already uncaps stay
+    // -1; `idpConfigs` sits between Team's 5 and Enterprise's unlimited.
+    business: {
+        plugins: 100,
+        pipelines: 20,
+        apiCalls: 800_000,
+        automationCalls: 210_000,
+        aiCalls: 1_600,
+        cpuCredits: 45_000,
+        storageBytes: 120 * GB,
+        dashboards: -1,
+        alertRules: -1,
+        alertDestinations: -1,
+        idpConfigs: 10,
+        listings: 50,
+        seats: 8,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Enterprise ($599, held): the all-inclusive tier — 15 seats, 30 pipelines, ALL
+    // premium features included (see TIER_FEATURES). FAIR-USE — cost drivers (apiCalls,
+    // aiCalls, storageBytes) capped so one account can't run up unbounded
+    // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.
+    enterprise: {
+        plugins: 150,
+        pipelines: 30,
+        apiCalls: 1_500_000,
+        automationCalls: 310_000,
+        aiCalls: 3_000,
+        cpuCredits: 67_500,
+        storageBytes: 250 * GB,
+        dashboards: -1,
+        alertRules: -1,
+        alertDestinations: -1,
+        idpConfigs: -1,
+        listings: 100,
+        seats: 15,
+        supportContacts: 0,
+        supportPremiumContacts: 0,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled
+    // (no enforcement surface) — never shown/selectable when billing is enabled.
+    unlimited: {
+        plugins: -1,
+        pipelines: -1,
+        apiCalls: -1,
+        automationCalls: -1,
+        aiCalls: -1,
+        cpuCredits: -1,
+        storageBytes: -1,
+        dashboards: -1,
+        alertRules: -1,
+        alertDestinations: -1,
+        idpConfigs: -1,
+        listings: -1,
+        seats: -1,
+        supportContacts: -1,
+        supportPremiumContacts: -1,
+        eventRetentionDays: -1,
+        doraRetentionDays: -1,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tier-limits.js","sources":["../../src/types/tier-limits.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What a tier GIVES you, as DATA ONLY — the limits shape, the code-default\n * number for every tier x quota type, and the arithmetic those numbers were\n * derived from.\n *\n * Dependency-free and env-free so the browser imports it directly\n * (`@pipeline-builder/api-core/tier-limits`). Its only import is a type, which\n * is erased at compile time, so nothing of the server graph reaches the bundle.\n * The env OVERLAY (`QUOTA_TIER_<TIER>_<LIMIT>`) deliberately stays in\n * `quota-tiers.ts`: it reads `process.env`, which is what kept this table out of\n * the browser's reach in the first place.\n *\n * WHY IT EXISTS. The frontend kept a hand-written copy of this table\n * (`frontend/src/components/quotas/constants.ts`, under a \"keep in sync\"\n * comment) because importing the real one meant importing a module with sixteen\n * env reads. The copy prefills the quota-admin editor's per-tier presets, so a\n * drifted copy did not break the page — an admin clicked a preset and SAVED\n * numbers that were no longer the product's, with nothing anywhere reporting it.\n * A test parsed BOTH files' source text to hold them equal, which is the shape\n * you reach for when the values cannot be shared. Now they can be: the frontend\n * imports this table, the copy is gone, and the drift it guarded is not\n * expressible.\n */\n\nimport type { QuotaTier } from './quota-tiers.js';\n\n/**\n * A tier key as product copy: `developer` → \"Developer\", `pro_plus` → \"Pro Plus\".\n *\n * Lives here, with the other tier facts, because three callers want it: the\n * default `QUOTA_TIERS` label, the shared test fixture's labels (which kept a\n * second `titleCase` of its own), and the browser.\n *\n * It will NOT guess at an acronym (`sso` → \"Sso\") or a stylized name (\"Pro+\"),\n * and deliberately takes no formatting options: the cases it cannot derive need\n * a human writing copy, which is what `QUOTA_TIER_<TIER>_LABEL` is for. A mode\n * flag would add surface without reaching any of them, and a mid-sentence phrase\n * (\"… — new version\") is a different FACT from a standalone label rather than\n * another style of one — `quota-catalog.ts` carries `label` and `labelPlural` as\n * separate named fields for exactly that reason.\n */\nexport function tierLabel(tier: string): string {\n  return tier\n    .split(/[_-]/)\n    .filter(Boolean)\n    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))\n    .join(' ');\n}\n\n/** Limit values for each quota type within a tier. */\nexport interface QuotaTierLimits {\n  plugins: number;\n  pipelines: number;\n  apiCalls: number;\n  /**\n   * Metered API calls made by ORG SERVICE ACCOUNTS (automation), counted\n   * instead of `apiCalls` so pipelines can't starve the org's people. See\n   * {@link AUTOMATION_CALLS_SIZING} for how the defaults are derived.\n   */\n  automationCalls: 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  /**\n   * vCPU-MINUTES of plugin-build compute per MONTH — the one quota on a period\n   * of its own (every other flow quota rolls on `QUOTA_RESET_DAYS`, 3 days).\n   *\n   * Derived from the `plugins` cap rather than guessed: `plugins x 10` builds a\n   * month, at a flat 30 wall-minutes a build and 1.5 vCPU of buildkitd, so\n   * `credits = builds x 45`. The flat per-build figure is deliberate — scaling\n   * BOTH the build count and the per-build cost by tier made credits\n   * superlinear in tier on the strength of an unmeasured claim, and it made a\n   * pack's credit grant tier-dependent, which the catalogue's grant shape cannot\n   * express.\n   *\n   * This is the first dimension with genuine per-unit marginal cost: every other\n   * quota is a rate limit protecting shared infrastructure, this one is compute\n   * the platform pays for. See `docs/plans/cpu-credits.md`.\n   */\n  cpuCredits: 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   * Active, non-suspended plugin-ecosystem listings the org publishes\n   * (docs/plugin-installing.md). A COUNT quota — installs never\n   * count. -1 = unlimited. Extendable via the `listing_pack` add-on bundle.\n   */\n  listings: 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   * Max designated SUPPORT CONTACTS — the members authorised to open support\n   * cases. -1 = unlimited. Base is **0 on every tier**: support is an add-on at\n   * every tier and included in none, so an org with no support bundle has no\n   * contacts and cannot open a case. That makes the support paywall a quota\n   * check rather than a feature flag.\n   *\n   * Like `seats` this is a tier LIMIT, not a tracked counter — enforced live at\n   * designation time against current designations across the org subtree.\n   * Extended per unit by the `support_standard` / `support_priority` BASELINE\n   * bundles, which are priced per contact.\n   */\n  supportContacts: number;\n  /**\n   * How many of those contacts may be UPGRADED to premium (24×7, 8-hour\n   * response, and the only ones who may declare `urgent`).\n   *\n   * A second dimension rather than a third baseline level, because premium is an\n   * UPGRADE and not an alternative. The shape it encodes: an org buys N baseline\n   * contacts and upgrades M of them, M ≤ N. That is what lets a 100-seat\n   * customer give business-hours support to its three named contacts and 24×7\n   * to the one who carries the pager — the case the mutually-exclusive ladder\n   * could not express at all, where buying \"99 standard + 1 premium\" charged for\n   * 100 units and granted one contact.\n   *\n   * ADDITIVE, deliberately. A premium contact costs the baseline unit PLUS the\n   * upgrade ($19.99 + $99.99), because it is served during business hours\n   * through the baseline and overnight through the upgrade; pricing the upgrade\n   * as a delta would pretend the baseline were free. Base 0 on every tier, like\n   * `supportContacts`, so the paywall stays a quota check.\n   */\n  supportPremiumContacts: 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/**\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 25 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 * How the `automationCalls` defaults are sized — written down so the next\n * person to touch them argues with the arithmetic, not with the numbers.\n *\n * Every call an org's automation keys make in one pipeline RUN, itemized (the\n * earlier sizing counted only the plugin lookups and hand-waved the rest as\n * \"×2\"):\n *\n *   plugin lookups            12   one per plugin step (self-mutating pipeline)\n *   synth                      1   the synth step fetching the pipeline config\n *   runtime check              1   the pre-deploy runtime-check call\n *   security-report upload     1   the scan step posting its report\n *   registry register          1   pipeline-register stamping the deployed version\n *   reporting ingest batches  12   the event forwarder posts ~one batch per action\n *                             --\n *                             28   calls per run\n *\n * Per default period (`QUOTA_RESET_DAYS`, 3 days) one active pipeline running\n * hourly makes 28 × 24 × 3 = 2,016 calls. An org keeps far more pipelines alive\n * than it CREATES in a period (`pipelines` is a creation rate), so active\n * pipelines are taken as 4× the tier's `pipelines`. On top sits a per-ORG\n * constant that does not scale with pipelines: the ingest-health heartbeat\n * (≤ 1/minute → 1,440/day → 4,320/period). The sum gets 25% headroom (retries,\n * registry pushes, ad-hoc CI scripts on keys) and rounds UP to the next 10,000:\n *\n *   developer   2×4×2016 + 4320 =  20,448 × 1.25 =  25,560 →  30,000\n *   pro         5×4×2016 + 4320 =  44,640 × 1.25 =  55,800 →  60,000\n *   team       10×4×2016 + 4320 =  84,960 × 1.25 = 106,200 → 110,000\n *   business   20×4×2016 + 4320 = 165,600 × 1.25 = 207,000 → 210,000\n *   enterprise 30×4×2016 + 4320 = 246,240 × 1.25 = 307,800 → 310,000\n *\n * {@link automationCallsFor} computes exactly this, and the tier tests hold the\n * table to it. Over the cap the 429 is SOFT for a band ({@link quotaGracePct}):\n * a self-mutating pipeline that hard-stopped at 100% stayed stopped until the\n * period reset, up to 3 days. The limits are PER PERIOD: an operator who\n * lengthens `QUOTA_RESET_DAYS` should scale `QUOTA_TIER_<TIER>_AUTOMATION_CALLS`\n * by the same factor.\n */\nexport const AUTOMATION_CALLS_SIZING = {\n  callsPerRun: {\n    pluginLookups: 12,\n    synth: 1,\n    runtimeCheck: 1,\n    securityReportUpload: 1,\n    registryRegister: 1,\n    ingestBatches: 12,\n  },\n  runsPerDay: 24,\n  activePipelinesPerCreation: 4,\n  /** Ingest-health heartbeats per org per day (≤ one a minute). */\n  heartbeatsPerDay: 1440,\n  /** Multiplier on the itemized total. */\n  headroom: 1.25,\n  /** Defaults round UP to a multiple of this. */\n  roundTo: 10_000,\n} as const;\n\n/** The {@link AUTOMATION_CALLS_SIZING} formula for a tier creating `pipelines` per period. */\nexport function automationCallsFor(pipelines: number, periodDays: number = 3): number {\n  const s = AUTOMATION_CALLS_SIZING;\n  const perRun = Object.values(s.callsPerRun).reduce((a, b) => a + b, 0);\n  const perPipeline = perRun * s.runsPerDay * periodDays;\n  const total = (pipelines * s.activePipelinesPerCreation * perPipeline + s.heartbeatsPerDay * periodDays) * s.headroom;\n  return Math.ceil(total / s.roundTo) * s.roundTo;\n}\n\n/**\n * Code-default limits per tier — the fallback when no env override is set.\n *\n * SERVER CODE WANTS `getTierLimits(tier)` / `QUOTA_TIERS[tier].limits`, not this\n * table: those carry the deployment's `QUOTA_TIER_*` overrides, and this is what\n * they fall back to. It is exported for the BROWSER, which has no env to overlay\n * and gets the deployment's effective figures from `/config` instead.\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 */\nexport const 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: 10,\n    pipelines: 2,\n    apiCalls: 25_000,\n    automationCalls: 30_000,\n    aiCalls: 20,\n    cpuCredits: 4_500,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\n    listings: 3,\n    seats: 1,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\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: 25,\n    pipelines: 5,\n    apiCalls: 100_000,\n    automationCalls: 60_000,\n    aiCalls: 200,\n    cpuCredits: 11_250,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\n    listings: 10,\n    seats: 1,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\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: 50,\n    pipelines: 10,\n    apiCalls: 300_000,\n    automationCalls: 110_000,\n    aiCalls: 600,\n    cpuCredits: 22_500,\n    storageBytes: 60 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    listings: 25,\n    seats: 3,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Business ($249): the step the $79 -> $599 cliff was missing. 8 seats, 20\n  // pipelines, and DORA (advanced_reporting) included rather than an add-on.\n  // Every cost driver is 100,000 apiCalls and 200 aiCalls PER SEAT, the same\n  // per-seat rate as Pro/Team/Enterprise, so the ladder reads consistently to a\n  // buyer who divides by headcount. Count-quotas that Team already uncaps stay\n  // -1; `idpConfigs` sits between Team's 5 and Enterprise's unlimited.\n  business: {\n    plugins: 100,\n    pipelines: 20,\n    apiCalls: 800_000,\n    automationCalls: 210_000,\n    aiCalls: 1_600,\n    cpuCredits: 45_000,\n    storageBytes: 120 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 10,\n    listings: 50,\n    seats: 8,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\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: 1_500_000,\n    automationCalls: 310_000,\n    aiCalls: 3_000,\n    cpuCredits: 67_500,\n    storageBytes: 250 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    listings: 100,\n    seats: 15,\n    supportContacts: 0,\n    supportPremiumContacts: 0,\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    automationCalls: -1,\n    aiCalls: -1,\n    cpuCredits: -1,\n    storageBytes: -1,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    listings: -1,\n    seats: -1,\n    supportContacts: -1,\n    supportPremiumContacts: -1,\n    eventRetentionDays: -1,\n    doraRetentionDays: -1,\n  },\n};\n"]}

package/lib/types/usage-projection.js

@@ -95,4 +95,4 @@ export function daysToExhaustion(input) {
         return null;
     return Math.max(0, (limit - used) / perDay);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"usage-projection.js","sourceRoot":"","sources":["../../src/types/usage-projection.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;GAkBG;AAEH,qFAAqF;AACrF,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAanC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,YAAY,CAAC,KAO5B;IACC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAC1C,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,YAAY,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACtF,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/C,2EAA2E;IAC3E,uDAAuD;IACvD,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAElE,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;IACpC,MAAM,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC;IAClC,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC;IAC5C,MAAM,OAAO,GAAG,GAAG,GAAG,WAAW,CAAC;IAClC,2EAA2E;IAC3E,iEAAiE;IACjE,IAAI,OAAO,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAE9B,oEAAoE;IACpE,sEAAsE;IACtE,MAAM,KAAK,GAAG,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC;IACrD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC;IAC3C,OAAO;QACL,SAAS;QACT,KAAK,EAAE,SAAS,GAAG,KAAK;QACxB,UAAU,EAAE,SAAS,GAAG,KAAK;QAC7B,eAAe,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;KAC9C,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C,sEAAsE;AACtE,MAAM,UAAU,sBAAsB,CAAC,CAAyB;IAC9D,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,KAAK,IAAI,uBAAuB,CAAC;AAC1D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAMhC;IACC,MAAM,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IAC9B,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAC1C,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,eAAe,GAAG,UAAU,CAAC,CAAC;IACvD,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;AAC9C,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Where a quota counter is HEADED, from where it is now.\n *\n * Extracted out of `frontend/src/components/quotas/QuotaCard.tsx`, which owned\n * this privately (docs/plans/sales-agent.md, Phase 0 groundwork). Three callers\n * need the same answer and were going to compute it three ways:\n *\n *  - the quota card's forecast row, which is where it started;\n *  - the threshold notice, which decides whether to warn;\n *  - the usage profile's TRAJECTORY signal (D4 Class 2), which is the whole\n *    basis for \"when will they run out\" rather than \"are they out\".\n *\n * A projection that disagreed between the page and the offer would be the worst\n * possible split: the account reads one number on the card and gets an offer\n * argued from another.\n *\n * DEPENDENCY-FREE, so the browser imports it through the `./usage-projection`\n * subpath rather than keeping the copy it has now.\n */\n\n/** Milliseconds in a day, named because the arithmetic below reads better for it. */\nconst DAY_MS = 24 * 60 * 60 * 1000;\n\nexport interface UsageProjection {\n  /** Units the counter is pacing to reach by `resetAt`. */\n  projected: number;\n  /** `projected / limit`. Above 1 means the cap is reached before the reset. */\n  ratio: number;\n  /** Whether the pace exhausts the limit before the period ends. */\n  willBreach: boolean;\n  /** Fraction of the period already elapsed, 0–1. */\n  elapsedFraction: number;\n}\n\n/**\n * Project a flow counter to its period end, or `null` when there is nothing to\n * project from.\n *\n * Returns null rather than zero for every unprojectable case — no usage yet, an\n * unlimited or absent limit, a period that has not started, an unparseable\n * reset — because zero is a FORECAST and \"cannot say\" is not one. A caller that\n * treated the two alike would warn an account at 0% and offer against a\n * trajectory nobody measured.\n *\n * The burn rate is LINEAR, and that is a deliberate floor rather than a model:\n * real workloads spike, but a straight line still catches \"pacing three times\n * ahead of plan\", which is the case worth acting on. Anything cleverer wants the\n * history the profile store keeps (D16), not a better formula here.\n */\nexport function projectUsage(input: {\n  used: number;\n  limit: number;\n  resetAt: string | Date;\n  periodDays: number;\n  /** Defaults to now; injectable so a caller can project as of a period's end. */\n  now?: number;\n}): UsageProjection | null {\n  const { used, limit, periodDays } = input;\n  const reset = input.resetAt instanceof Date ? input.resetAt : new Date(input.resetAt);\n  if (Number.isNaN(reset.getTime())) return null;\n  // `limit <= 0` covers both an unset cap and the `-1` that means unlimited:\n  // neither has a ratio, and there is nothing to breach.\n  if (!(limit > 0) || !(used > 0) || !(periodDays > 0)) return null;\n\n  const now = input.now ?? Date.now();\n  const total = periodDays * DAY_MS;\n  const periodStart = reset.getTime() - total;\n  const elapsed = now - periodStart;\n  // Before the period opened, or exactly at its boundary: no elapsed time to\n  // divide by, and extrapolating from zero elapsed gives infinity.\n  if (elapsed <= 0) return null;\n\n  // Past the reset the period is over; the pace IS the usage, with no\n  // extrapolation, rather than a figure scaled by a fraction above one.\n  const scale = elapsed >= total ? 1 : total / elapsed;\n  const projected = Math.round(used * scale);\n  return {\n    projected,\n    ratio: projected / limit,\n    willBreach: projected > limit,\n    elapsedFraction: Math.min(1, elapsed / total),\n  };\n}\n\n/**\n * The band at which a projection is worth showing a person.\n *\n * Shared so the card's forecast row and the profile's pressure signal agree on\n * what \"approaching\" means. Below it there is a projection but no reason to say\n * anything, which is a different state from having no projection at all.\n */\nexport const PROJECTION_NOTICE_RATIO = 0.7;\n\n/** Whether a projection has crossed into the band worth surfacing. */\nexport function projectionWorthShowing(p: UsageProjection | null): boolean {\n  return p !== null && p.ratio >= PROJECTION_NOTICE_RATIO;\n}\n\n/**\n * Days until the counter reaches its limit at the current pace, or `null` when\n * it does not reach it inside the period.\n *\n * The TRAJECTORY signal's actual question (D4 Class 2) — \"how long have they\n * got\" is what decides whether an offer is timely, where the projected total\n * only says whether it is warranted. Fractional days are kept: rounding up to a\n * whole day loses exactly the urgency the signal is for.\n */\nexport function daysToExhaustion(input: {\n  used: number;\n  limit: number;\n  resetAt: string | Date;\n  periodDays: number;\n  now?: number;\n}): number | null {\n  const p = projectUsage(input);\n  if (!p || !p.willBreach) return null;\n  const { used, limit, periodDays } = input;\n  const perDay = used / (p.elapsedFraction * periodDays);\n  if (!(perDay > 0)) return null;\n  return Math.max(0, (limit - used) / perDay);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"usage-projection.js","sources":["../../src/types/usage-projection.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;GAkBG;AAEH,qFAAqF;AACrF,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAanC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,YAAY,CAAC,KAO5B;IACC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAC1C,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,YAAY,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACtF,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/C,2EAA2E;IAC3E,uDAAuD;IACvD,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAElE,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;IACpC,MAAM,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC;IAClC,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC;IAC5C,MAAM,OAAO,GAAG,GAAG,GAAG,WAAW,CAAC;IAClC,2EAA2E;IAC3E,iEAAiE;IACjE,IAAI,OAAO,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAE9B,oEAAoE;IACpE,sEAAsE;IACtE,MAAM,KAAK,GAAG,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC;IACrD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC;IAC3C,OAAO;QACL,SAAS;QACT,KAAK,EAAE,SAAS,GAAG,KAAK;QACxB,UAAU,EAAE,SAAS,GAAG,KAAK;QAC7B,eAAe,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;KAC9C,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C,sEAAsE;AACtE,MAAM,UAAU,sBAAsB,CAAC,CAAyB;IAC9D,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,KAAK,IAAI,uBAAuB,CAAC;AAC1D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAMhC;IACC,MAAM,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IAC9B,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAC1C,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,eAAe,GAAG,UAAU,CAAC,CAAC;IACvD,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;AAC9C,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Where a quota counter is HEADED, from where it is now.\n *\n * Extracted out of `frontend/src/components/quotas/QuotaCard.tsx`, which owned\n * this privately (docs/plans/sales-agent.md, Phase 0 groundwork). Three callers\n * need the same answer and were going to compute it three ways:\n *\n *  - the quota card's forecast row, which is where it started;\n *  - the threshold notice, which decides whether to warn;\n *  - the usage profile's TRAJECTORY signal (D4 Class 2), which is the whole\n *    basis for \"when will they run out\" rather than \"are they out\".\n *\n * A projection that disagreed between the page and the offer would be the worst\n * possible split: the account reads one number on the card and gets an offer\n * argued from another.\n *\n * DEPENDENCY-FREE, so the browser imports it through the `./usage-projection`\n * subpath rather than keeping the copy it has now.\n */\n\n/** Milliseconds in a day, named because the arithmetic below reads better for it. */\nconst DAY_MS = 24 * 60 * 60 * 1000;\n\nexport interface UsageProjection {\n  /** Units the counter is pacing to reach by `resetAt`. */\n  projected: number;\n  /** `projected / limit`. Above 1 means the cap is reached before the reset. */\n  ratio: number;\n  /** Whether the pace exhausts the limit before the period ends. */\n  willBreach: boolean;\n  /** Fraction of the period already elapsed, 0–1. */\n  elapsedFraction: number;\n}\n\n/**\n * Project a flow counter to its period end, or `null` when there is nothing to\n * project from.\n *\n * Returns null rather than zero for every unprojectable case — no usage yet, an\n * unlimited or absent limit, a period that has not started, an unparseable\n * reset — because zero is a FORECAST and \"cannot say\" is not one. A caller that\n * treated the two alike would warn an account at 0% and offer against a\n * trajectory nobody measured.\n *\n * The burn rate is LINEAR, and that is a deliberate floor rather than a model:\n * real workloads spike, but a straight line still catches \"pacing three times\n * ahead of plan\", which is the case worth acting on. Anything cleverer wants the\n * history the profile store keeps (D16), not a better formula here.\n */\nexport function projectUsage(input: {\n  used: number;\n  limit: number;\n  resetAt: string | Date;\n  periodDays: number;\n  /** Defaults to now; injectable so a caller can project as of a period's end. */\n  now?: number;\n}): UsageProjection | null {\n  const { used, limit, periodDays } = input;\n  const reset = input.resetAt instanceof Date ? input.resetAt : new Date(input.resetAt);\n  if (Number.isNaN(reset.getTime())) return null;\n  // `limit <= 0` covers both an unset cap and the `-1` that means unlimited:\n  // neither has a ratio, and there is nothing to breach.\n  if (!(limit > 0) || !(used > 0) || !(periodDays > 0)) return null;\n\n  const now = input.now ?? Date.now();\n  const total = periodDays * DAY_MS;\n  const periodStart = reset.getTime() - total;\n  const elapsed = now - periodStart;\n  // Before the period opened, or exactly at its boundary: no elapsed time to\n  // divide by, and extrapolating from zero elapsed gives infinity.\n  if (elapsed <= 0) return null;\n\n  // Past the reset the period is over; the pace IS the usage, with no\n  // extrapolation, rather than a figure scaled by a fraction above one.\n  const scale = elapsed >= total ? 1 : total / elapsed;\n  const projected = Math.round(used * scale);\n  return {\n    projected,\n    ratio: projected / limit,\n    willBreach: projected > limit,\n    elapsedFraction: Math.min(1, elapsed / total),\n  };\n}\n\n/**\n * The band at which a projection is worth showing a person.\n *\n * Shared so the card's forecast row and the profile's pressure signal agree on\n * what \"approaching\" means. Below it there is a projection but no reason to say\n * anything, which is a different state from having no projection at all.\n */\nexport const PROJECTION_NOTICE_RATIO = 0.7;\n\n/** Whether a projection has crossed into the band worth surfacing. */\nexport function projectionWorthShowing(p: UsageProjection | null): boolean {\n  return p !== null && p.ratio >= PROJECTION_NOTICE_RATIO;\n}\n\n/**\n * Days until the counter reaches its limit at the current pace, or `null` when\n * it does not reach it inside the period.\n *\n * The TRAJECTORY signal's actual question (D4 Class 2) — \"how long have they\n * got\" is what decides whether an offer is timely, where the projected total\n * only says whether it is warranted. Fractional days are kept: rounding up to a\n * whole day loses exactly the urgency the signal is for.\n */\nexport function daysToExhaustion(input: {\n  used: number;\n  limit: number;\n  resetAt: string | Date;\n  periodDays: number;\n  now?: number;\n}): number | null {\n  const p = projectUsage(input);\n  if (!p || !p.willBreach) return null;\n  const { used, limit, periodDays } = input;\n  const perDay = used / (p.elapsedFraction * periodDays);\n  if (!(perDay > 0)) return null;\n  return Math.max(0, (limit - used) / perDay);\n}\n"]}

package/lib/types/visibility.js

@@ -19,4 +19,4 @@
  * `requireVisibilityWriteAccess` gates the writes.
  */
 export const VISIBILITIES = ['private', 'org', 'public'];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlzaWJpbGl0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy92aXNpYmlsaXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEM7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxRQUFRLENBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFRoZSBzaW5nbGUgc2hhcmluZyBtb2RlbCBmb3IgZXZlcnkgY2F0YWxvZyBlbnRpdHk6IHBpcGVsaW5lcywgcGx1Z2lucyxcbiAqIHBpcGVsaW5lIHRlbXBsYXRlcywgYW5kIGRhc2hib2FyZHMuXG4gKlxuICogVGhyZWUgcnVuZ3MsIHdpZGVuaW5nIGxlZnQgdG8gcmlnaHQ6XG4gKlxuICogLSBgcHJpdmF0ZWAg4oCUIG9ubHkgdGhlIEFVVEhPUiAoYGNyZWF0ZWRCeWApIGNhbiBzZWUgb3IgZWRpdCBpdC4gQSBwZXJzb25hbFxuICogICBkcmFmdDogc29tZXdoZXJlIHRvIGl0ZXJhdGUgYmVmb3JlIGFueW9uZSBlbHNlIGlzIGFmZmVjdGVkLlxuICogLSBgb3JnYCAgICAg4oCUIGV2ZXJ5b25lIGluIHRoZSBvd25pbmcgb3JnIGNhbiBzZWUgaXQ7IHRoZSByZXNvdXJjZSdzIGA6d3JpdGVgXG4gKiAgIHBlcm1pc3Npb24gZWRpdHMgaXQuIFRoaXMgaXMgdGhlIGRlZmF1bHQgd29ya2luZyBzdGF0ZSBmb3Igc2hhcmVkIGNvbnRlbnQuXG4gKiAtIGBwdWJsaWNgICDigJQgc2hhcmVkIGJleW9uZCB0aGUgb3JnOiBhIHRlYW0gYWxzbyBzZWVzIGl0cyBwYXJlbnQgb3JnJ3MgcHVibGljXG4gKiAgIHJvd3MsIGFuZCB0aGUgc3lzdGVtIG9yZydzIHB1YmxpYyByb3dzIGFyZSB0aGUgc2hhcmVkIGNhdGFsb2cgZXZlcnkgb3JnXG4gKiAgIHNlZXMuIFJlcXVpcmVzIHRoZSByZXNvdXJjZSdzIGA6cHVibGlzaGAgcGVybWlzc2lvbi5cbiAqXG4gKiBFbmZvcmNlbWVudCBsaXZlcyBpbiBleGFjdGx5IHR3byBwbGFjZXMsIHNvIG5vIGVudGl0eSBjYW4gZHJpZnQ6XG4gKiBgQWNjZXNzQ29udHJvbFF1ZXJ5QnVpbGRlcmAgYnVpbGRzIHRoZSByZWFkIHByZWRpY2F0ZSwgYW5kXG4gKiBgcmVxdWlyZVZpc2liaWxpdHlXcml0ZUFjY2Vzc2AgZ2F0ZXMgdGhlIHdyaXRlcy5cbiAqL1xuZXhwb3J0IGNvbnN0IFZJU0lCSUxJVElFUyA9IFsncHJpdmF0ZScsICdvcmcnLCAncHVibGljJ10gYXMgY29uc3Q7XG5leHBvcnQgdHlwZSBWaXNpYmlsaXR5ID0gKHR5cGVvZiBWSVNJQklMSVRJRVMpW251bWJlcl07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlzaWJpbGl0eS5qcyIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL3Zpc2liaWxpdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0Qzs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxTQUFTLEVBQUUsS0FBSyxFQUFFLFFBQVEsQ0FBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbi8qKlxuICogVGhlIHNpbmdsZSBzaGFyaW5nIG1vZGVsIGZvciBldmVyeSBjYXRhbG9nIGVudGl0eTogcGlwZWxpbmVzLCBwbHVnaW5zLFxuICogcGlwZWxpbmUgdGVtcGxhdGVzLCBhbmQgZGFzaGJvYXJkcy5cbiAqXG4gKiBUaHJlZSBydW5ncywgd2lkZW5pbmcgbGVmdCB0byByaWdodDpcbiAqXG4gKiAtIGBwcml2YXRlYCDigJQgb25seSB0aGUgQVVUSE9SIChgY3JlYXRlZEJ5YCkgY2FuIHNlZSBvciBlZGl0IGl0LiBBIHBlcnNvbmFsXG4gKiAgIGRyYWZ0OiBzb21ld2hlcmUgdG8gaXRlcmF0ZSBiZWZvcmUgYW55b25lIGVsc2UgaXMgYWZmZWN0ZWQuXG4gKiAtIGBvcmdgICAgICDigJQgZXZlcnlvbmUgaW4gdGhlIG93bmluZyBvcmcgY2FuIHNlZSBpdDsgdGhlIHJlc291cmNlJ3MgYDp3cml0ZWBcbiAqICAgcGVybWlzc2lvbiBlZGl0cyBpdC4gVGhpcyBpcyB0aGUgZGVmYXVsdCB3b3JraW5nIHN0YXRlIGZvciBzaGFyZWQgY29udGVudC5cbiAqIC0gYHB1YmxpY2AgIOKAlCBzaGFyZWQgYmV5b25kIHRoZSBvcmc6IGEgdGVhbSBhbHNvIHNlZXMgaXRzIHBhcmVudCBvcmcncyBwdWJsaWNcbiAqICAgcm93cywgYW5kIHRoZSBzeXN0ZW0gb3JnJ3MgcHVibGljIHJvd3MgYXJlIHRoZSBzaGFyZWQgY2F0YWxvZyBldmVyeSBvcmdcbiAqICAgc2Vlcy4gUmVxdWlyZXMgdGhlIHJlc291cmNlJ3MgYDpwdWJsaXNoYCBwZXJtaXNzaW9uLlxuICpcbiAqIEVuZm9yY2VtZW50IGxpdmVzIGluIGV4YWN0bHkgdHdvIHBsYWNlcywgc28gbm8gZW50aXR5IGNhbiBkcmlmdDpcbiAqIGBBY2Nlc3NDb250cm9sUXVlcnlCdWlsZGVyYCBidWlsZHMgdGhlIHJlYWQgcHJlZGljYXRlLCBhbmRcbiAqIGByZXF1aXJlVmlzaWJpbGl0eVdyaXRlQWNjZXNzYCBnYXRlcyB0aGUgd3JpdGVzLlxuICovXG5leHBvcnQgY29uc3QgVklTSUJJTElUSUVTID0gWydwcml2YXRlJywgJ29yZycsICdwdWJsaWMnXSBhcyBjb25zdDtcbmV4cG9ydCB0eXBlIFZpc2liaWxpdHkgPSAodHlwZW9mIFZJU0lCSUxJVElFUylbbnVtYmVyXTtcbiJdfQ==

package/lib/types/wire-vocabulary.d.ts

@@ -27,6 +27,13 @@ export declare const MESSAGE_TYPES: readonly ['announcement', 'conversation'];
 export type MessageType = (typeof MESSAGE_TYPES)[number];
 export declare const MESSAGE_PRIORITIES: readonly ['normal', 'high', 'urgent'];
 export type MessagePriority = (typeof MESSAGE_PRIORITIES)[number];
+/**
+ * Who SENT a root message, relative to the viewer: `me` (the viewing user
+ * authored it), `org` (the viewing org sent it — any member), `others` (it
+ * arrived from another org, announcements included).
+ */
+export declare const MESSAGE_SENT_BY: readonly ['me', 'org', 'others'];
+export type MessageSentBy = (typeof MESSAGE_SENT_BY)[number];
 export declare const SUBSCRIPTION_STATUSES: readonly ['active', 'canceled', 'past_due', 'trialing', 'incomplete'];
 export type SubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];
 export declare const BILLING_INTERVALS: readonly ['monthly', 'annual'];

package/lib/types/wire-vocabulary.js

@@ -37,6 +37,12 @@ export const RULE_SCOPES = ['org', 'published'];
 // -----------------------------------------------------------------------------
 export const MESSAGE_TYPES = ['announcement', 'conversation'];
 export const MESSAGE_PRIORITIES = ['normal', 'high', 'urgent'];
+/**
+ * Who SENT a root message, relative to the viewer: `me` (the viewing user
+ * authored it), `org` (the viewing org sent it — any member), `others` (it
+ * arrived from another org, announcements included).
+ */
+export const MESSAGE_SENT_BY = ['me', 'org', 'others'];
 // -----------------------------------------------------------------------------
 // Billing
 // -----------------------------------------------------------------------------
@@ -116,4 +122,4 @@ export const PLUGIN_SECURITY_DIGEST_MODES = ['immediate', 'daily', 'weekly'];
 // the labels were in a frontend mirror of both. One keyed catalog is importable
 // by the browser, so the mirror and the test that parsed this package's source
 // to detect drift are both gone.
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wire-vocabulary.js","sourceRoot":"","sources":["../../src/types/wire-vocabulary.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Closed string vocabularies that cross the wire between the services and the\n * browser. Each is an `as const` array (the runtime list a Zod enum, a Mongoose\n * enum or a drizzle `$type` builds from) plus the union type derived from it.\n *\n * Dependency-free on purpose: the frontend imports these types, so a value added\n * here reaches the UI's exhaustive label maps as a compile error instead of a\n * silently unhandled string. The Postgres CHECK constraints in each deploy\n * target's `postgres-init.sql` mirror the ones stored in SQL.\n */\n\n// -----------------------------------------------------------------------------\n// Compliance rules\n// -----------------------------------------------------------------------------\n\nexport const RULE_SEVERITIES = ['warning', 'error', 'critical'] as const;\nexport type RuleSeverity = (typeof RULE_SEVERITIES)[number];\n\nexport const RULE_TARGETS = ['plugin', 'pipeline'] as const;\nexport type RuleTarget = (typeof RULE_TARGETS)[number];\n\n/** Field-evaluation operators; the engine's implementations live in api/compliance. */\nexport const RULE_OPERATORS = [\n  'eq', 'neq',\n  'contains', 'notContains',\n  'regex',\n  'gt', 'gte', 'lt', 'lte',\n  'in', 'notIn',\n  'exists', 'notExists', 'notEmpty',\n  'countGt', 'countLt',\n  'lengthGt', 'lengthLt',\n] as const;\nexport type RuleOperator = (typeof RULE_OPERATORS)[number];\n\n/** Operators that test presence only and take no comparison value. */\nexport const VALUELESS_RULE_OPERATORS = ['exists', 'notExists', 'notEmpty'] as const satisfies readonly RuleOperator[];\n\n/** How a multi-condition rule combines its conditions. */\nexport const RULE_CONDITION_MODES = ['all', 'any'] as const;\nexport type RuleConditionMode = (typeof RULE_CONDITION_MODES)[number];\n\n/** `published` rules belong to the system org and apply by subscription. */\nexport const RULE_SCOPES = ['org', 'published'] as const;\nexport type RuleScope = (typeof RULE_SCOPES)[number];\n\n// -----------------------------------------------------------------------------\n// Messages\n// -----------------------------------------------------------------------------\n\nexport const MESSAGE_TYPES = ['announcement', 'conversation'] as const;\nexport type MessageType = (typeof MESSAGE_TYPES)[number];\n\nexport const MESSAGE_PRIORITIES = ['normal', 'high', 'urgent'] as const;\nexport type MessagePriority = (typeof MESSAGE_PRIORITIES)[number];\n\n// -----------------------------------------------------------------------------\n// Billing\n// -----------------------------------------------------------------------------\n\nexport const SUBSCRIPTION_STATUSES = ['active', 'canceled', 'past_due', 'trialing', 'incomplete'] as const;\nexport type SubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];\n\nexport const BILLING_INTERVALS = ['monthly', 'annual'] as const;\nexport type BillingInterval = (typeof BILLING_INTERVALS)[number];\n\n// -----------------------------------------------------------------------------\n// Identity\n// -----------------------------------------------------------------------------\n\n/** OIDC providers an org IdP config can name (GitHub is OAuth-only and refused by the OIDC engine). */\nexport const IDP_PROVIDERS = ['generic-oidc', 'cognito', 'google', 'github'] as const;\nexport type IdpProvider = (typeof IDP_PROVIDERS)[number];\n\n/** The federation protocol an org signs in over — one per org. */\nexport const IDP_PROTOCOLS = ['oidc', 'saml'] as const;\nexport type IdpProtocol = (typeof IDP_PROTOCOLS)[number];\n\n/**\n * Which SAML assertion attribute carries which identity field. An empty name\n * means \"use the common spellings\" (short names plus the Entra/Shibboleth URIs).\n */\nexport interface SamlAttributeMapping {\n  /** Attribute holding the user's email address. */\n  email?: string;\n  /** Attribute holding the display name. */\n  name?: string;\n  /** Attribute holding group memberships (drives JIT role mapping). */\n  groups?: string;\n}\n\n/** The coarse grant a permission role gives its members. */\nexport const ROLE_GRANTS = ['superadmin', 'admin', 'member'] as const;\nexport type RoleGrant = (typeof ROLE_GRANTS)[number];\n\n// -----------------------------------------------------------------------------\n// Plugin ecosystem (each mirrored by a CHECK in postgres-init.sql)\n// -----------------------------------------------------------------------------\n\n/** Publisher trust tier. */\nexport const PUBLISHER_TIERS = ['official', 'verified', 'community', 'unverified'] as const;\nexport type PublisherTier = (typeof PUBLISHER_TIERS)[number];\n\n/** A directory listing's lifecycle state. */\nexport const LISTING_STATES = ['listed', 'unmaintained', 'suspended', 'transferred'] as const;\nexport type ListingState = (typeof LISTING_STATES)[number];\n\n/** What a publish request asks the system org to do. */\nexport const PUBLISH_REQUEST_KINDS = [\n  'new_listing', 'new_version', 'listing_update', 'yank', 'unpause',\n  'transfer', 'claim', 'profile_change', 'advisory', 'verify', 'moderation', 'submission',\n] as const;\nexport type PublishRequestKind = (typeof PUBLISH_REQUEST_KINDS)[number];\n\nexport const PUBLISH_REQUEST_STATUSES = ['pending', 'pending_second_approval', 'approved', 'rejected', 'withdrawn'] as const;\nexport type PublishRequestStatus = (typeof PUBLISH_REQUEST_STATUSES)[number];\n\n/** The statuses a request is still \"open\" in (drives the one-open-request index). */\nexport const OPEN_PUBLISH_REQUEST_STATUSES = ['pending', 'pending_second_approval'] as const satisfies readonly PublishRequestStatus[];\n\n/** `security` requests jump the moderation queue. */\nexport const PUBLISH_REQUEST_LANES = ['standard', 'security'] as const;\nexport type PublishRequestLane = (typeof PUBLISH_REQUEST_LANES)[number];\n\n/** Install version policy: exact, `~`, `^`, or anything non-breaking. */\nexport const INSTALL_VERSION_POLICIES = ['pinned', 'patch', 'minor', 'latest'] as const;\nexport type InstallVersionPolicy = (typeof INSTALL_VERSION_POLICIES)[number];\n\nexport const INSTALL_STATUSES = ['active', 'pending_approval', 'denied'] as const;\nexport type InstallStatus = (typeof INSTALL_STATUSES)[number];\n\n/** The advisory severity at which a consumption policy blocks installs. */\nexport const BLOCK_ON_ADVISORY_LEVELS = ['critical', 'high', 'never'] as const;\nexport type BlockOnAdvisory = (typeof BLOCK_ON_ADVISORY_LEVELS)[number];\n\n/** Whether official plugins need an explicit install before a pipeline can use them. */\nexport const OFFICIAL_INSTALLS_MODES = ['implicit', 'explicit'] as const;\nexport type OfficialInstalls = (typeof OFFICIAL_INSTALLS_MODES)[number];\n\n/**\n * What happens when an org defines a plugin NAME that overrides something it\n * would otherwise resolve — a listing, or (for a team) its parent org's plugin.\n *\n * `allow` keeps today's behaviour: the override is silent beyond the dashboard\n * banner. `warn` is the same resolution with the fact recorded prominently.\n * `deny` refuses the upload, which is the only setting that actually stops a\n * team replacing the Official `trivy` for every pipeline that names it.\n */\nexport const SHADOWING_MODES = ['allow', 'warn', 'deny'] as const;\nexport type ShadowingMode = (typeof SHADOWING_MODES)[number];\n\nexport const REVIEW_STATUSES = ['published', 'held', 'removed'] as const;\nexport type ReviewStatus = (typeof REVIEW_STATUSES)[number];\n\n/** Why a held review is held. */\nexport const REVIEW_HOLD_REASONS = ['reports', 'burst', 'filter', 'security', 'moderator'] as const;\nexport type ReviewHoldReason = (typeof REVIEW_HOLD_REASONS)[number];\n\n/** A review report's category; `security` routes privately to the advisory path. */\nexport const REVIEW_REPORT_CATEGORIES = ['spam', 'abuse', 'off_topic', 'security'] as const;\nexport type ReviewReportCategory = (typeof REVIEW_REPORT_CATEGORIES)[number];\n\nexport const ADVISORY_SEVERITIES = ['critical', 'high', 'medium', 'low'] as const;\nexport type AdvisorySeverity = (typeof ADVISORY_SEVERITIES)[number];\n\nexport const ADVISORY_STATES = ['draft', 'published', 'withdrawn'] as const;\nexport type AdvisoryState = (typeof ADVISORY_STATES)[number];\n\nexport const ADVISORY_SOURCES = ['publisher', 'moderator', 'cve_rescan', 'review'] as const;\nexport type AdvisorySource = (typeof ADVISORY_SOURCES)[number];\n\n/**\n * An anonymous submission's lifecycle. `publishing` is the short claim an\n * approval takes before it copies the quarantined image out, so an expiry can\n * never delete the artifacts of a submission that is being published.\n */\nexport const SUBMISSION_STATUSES = [\n  'pending_verification', 'pending_review', 'publishing', 'gate_failed', 'approved', 'rejected', 'expired', 'claimed',\n] as const;\nexport type SubmissionStatus = (typeof SUBMISSION_STATUSES)[number];\n\n// -----------------------------------------------------------------------------\n// Plugin security notifications (per org)\n// -----------------------------------------------------------------------------\n\n/** Who receives an org's plugin security notices: `writers` = the uploader plus\n *  members holding `plugins:write`; `users` = the org's chosen members. */\nexport const PLUGIN_SECURITY_RECIPIENT_MODES = ['writers', 'users'] as const;\nexport type PluginSecurityRecipientMode = (typeof PLUGIN_SECURITY_RECIPIENT_MODES)[number];\n\n/** How rescan findings (N31) are batched; blocked builds (N30) are always immediate. */\nexport const PLUGIN_SECURITY_DIGEST_MODES = ['immediate', 'daily', 'weekly'] as const;\nexport type PluginSecurityDigestMode = (typeof PLUGIN_SECURITY_DIGEST_MODES)[number];\n\n// The build CLASS and SIZE vocabularies live in `build-catalog.ts`, together\n// with their labels, credit multipliers, tier floors and per-class slot\n// defaults. They are not here because the ids alone were never the whole fact:\n// the multiplier was in this file, the tier gate was in `quota-tiers.ts`, and\n// the labels were in a frontend mirror of both. One keyed catalog is importable\n// by the browser, so the mirror and the test that parsed this package's source\n// to detect drift are both gone.\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wire-vocabulary.js","sources":["../../src/types/wire-vocabulary.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Closed string vocabularies that cross the wire between the services and the\n * browser. Each is an `as const` array (the runtime list a Zod enum, a Mongoose\n * enum or a drizzle `$type` builds from) plus the union type derived from it.\n *\n * Dependency-free on purpose: the frontend imports these types, so a value added\n * here reaches the UI's exhaustive label maps as a compile error instead of a\n * silently unhandled string. The Postgres CHECK constraints in each deploy\n * target's `postgres-init.sql` mirror the ones stored in SQL.\n */\n\n// -----------------------------------------------------------------------------\n// Compliance rules\n// -----------------------------------------------------------------------------\n\nexport const RULE_SEVERITIES = ['warning', 'error', 'critical'] as const;\nexport type RuleSeverity = (typeof RULE_SEVERITIES)[number];\n\nexport const RULE_TARGETS = ['plugin', 'pipeline'] as const;\nexport type RuleTarget = (typeof RULE_TARGETS)[number];\n\n/** Field-evaluation operators; the engine's implementations live in api/compliance. */\nexport const RULE_OPERATORS = [\n  'eq', 'neq',\n  'contains', 'notContains',\n  'regex',\n  'gt', 'gte', 'lt', 'lte',\n  'in', 'notIn',\n  'exists', 'notExists', 'notEmpty',\n  'countGt', 'countLt',\n  'lengthGt', 'lengthLt',\n] as const;\nexport type RuleOperator = (typeof RULE_OPERATORS)[number];\n\n/** Operators that test presence only and take no comparison value. */\nexport const VALUELESS_RULE_OPERATORS = ['exists', 'notExists', 'notEmpty'] as const satisfies readonly RuleOperator[];\n\n/** How a multi-condition rule combines its conditions. */\nexport const RULE_CONDITION_MODES = ['all', 'any'] as const;\nexport type RuleConditionMode = (typeof RULE_CONDITION_MODES)[number];\n\n/** `published` rules belong to the system org and apply by subscription. */\nexport const RULE_SCOPES = ['org', 'published'] as const;\nexport type RuleScope = (typeof RULE_SCOPES)[number];\n\n// -----------------------------------------------------------------------------\n// Messages\n// -----------------------------------------------------------------------------\n\nexport const MESSAGE_TYPES = ['announcement', 'conversation'] as const;\nexport type MessageType = (typeof MESSAGE_TYPES)[number];\n\nexport const MESSAGE_PRIORITIES = ['normal', 'high', 'urgent'] as const;\nexport type MessagePriority = (typeof MESSAGE_PRIORITIES)[number];\n\n/**\n * Who SENT a root message, relative to the viewer: `me` (the viewing user\n * authored it), `org` (the viewing org sent it — any member), `others` (it\n * arrived from another org, announcements included).\n */\nexport const MESSAGE_SENT_BY = ['me', 'org', 'others'] as const;\nexport type MessageSentBy = (typeof MESSAGE_SENT_BY)[number];\n\n// -----------------------------------------------------------------------------\n// Billing\n// -----------------------------------------------------------------------------\n\nexport const SUBSCRIPTION_STATUSES = ['active', 'canceled', 'past_due', 'trialing', 'incomplete'] as const;\nexport type SubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];\n\nexport const BILLING_INTERVALS = ['monthly', 'annual'] as const;\nexport type BillingInterval = (typeof BILLING_INTERVALS)[number];\n\n// -----------------------------------------------------------------------------\n// Identity\n// -----------------------------------------------------------------------------\n\n/** OIDC providers an org IdP config can name (GitHub is OAuth-only and refused by the OIDC engine). */\nexport const IDP_PROVIDERS = ['generic-oidc', 'cognito', 'google', 'github'] as const;\nexport type IdpProvider = (typeof IDP_PROVIDERS)[number];\n\n/** The federation protocol an org signs in over — one per org. */\nexport const IDP_PROTOCOLS = ['oidc', 'saml'] as const;\nexport type IdpProtocol = (typeof IDP_PROTOCOLS)[number];\n\n/**\n * Which SAML assertion attribute carries which identity field. An empty name\n * means \"use the common spellings\" (short names plus the Entra/Shibboleth URIs).\n */\nexport interface SamlAttributeMapping {\n  /** Attribute holding the user's email address. */\n  email?: string;\n  /** Attribute holding the display name. */\n  name?: string;\n  /** Attribute holding group memberships (drives JIT role mapping). */\n  groups?: string;\n}\n\n/** The coarse grant a permission role gives its members. */\nexport const ROLE_GRANTS = ['superadmin', 'admin', 'member'] as const;\nexport type RoleGrant = (typeof ROLE_GRANTS)[number];\n\n// -----------------------------------------------------------------------------\n// Plugin ecosystem (each mirrored by a CHECK in postgres-init.sql)\n// -----------------------------------------------------------------------------\n\n/** Publisher trust tier. */\nexport const PUBLISHER_TIERS = ['official', 'verified', 'community', 'unverified'] as const;\nexport type PublisherTier = (typeof PUBLISHER_TIERS)[number];\n\n/** A directory listing's lifecycle state. */\nexport const LISTING_STATES = ['listed', 'unmaintained', 'suspended', 'transferred'] as const;\nexport type ListingState = (typeof LISTING_STATES)[number];\n\n/** What a publish request asks the system org to do. */\nexport const PUBLISH_REQUEST_KINDS = [\n  'new_listing', 'new_version', 'listing_update', 'yank', 'unpause',\n  'transfer', 'claim', 'profile_change', 'advisory', 'verify', 'moderation', 'submission',\n] as const;\nexport type PublishRequestKind = (typeof PUBLISH_REQUEST_KINDS)[number];\n\nexport const PUBLISH_REQUEST_STATUSES = ['pending', 'pending_second_approval', 'approved', 'rejected', 'withdrawn'] as const;\nexport type PublishRequestStatus = (typeof PUBLISH_REQUEST_STATUSES)[number];\n\n/** The statuses a request is still \"open\" in (drives the one-open-request index). */\nexport const OPEN_PUBLISH_REQUEST_STATUSES = ['pending', 'pending_second_approval'] as const satisfies readonly PublishRequestStatus[];\n\n/** `security` requests jump the moderation queue. */\nexport const PUBLISH_REQUEST_LANES = ['standard', 'security'] as const;\nexport type PublishRequestLane = (typeof PUBLISH_REQUEST_LANES)[number];\n\n/** Install version policy: exact, `~`, `^`, or anything non-breaking. */\nexport const INSTALL_VERSION_POLICIES = ['pinned', 'patch', 'minor', 'latest'] as const;\nexport type InstallVersionPolicy = (typeof INSTALL_VERSION_POLICIES)[number];\n\nexport const INSTALL_STATUSES = ['active', 'pending_approval', 'denied'] as const;\nexport type InstallStatus = (typeof INSTALL_STATUSES)[number];\n\n/** The advisory severity at which a consumption policy blocks installs. */\nexport const BLOCK_ON_ADVISORY_LEVELS = ['critical', 'high', 'never'] as const;\nexport type BlockOnAdvisory = (typeof BLOCK_ON_ADVISORY_LEVELS)[number];\n\n/** Whether official plugins need an explicit install before a pipeline can use them. */\nexport const OFFICIAL_INSTALLS_MODES = ['implicit', 'explicit'] as const;\nexport type OfficialInstalls = (typeof OFFICIAL_INSTALLS_MODES)[number];\n\n/**\n * What happens when an org defines a plugin NAME that overrides something it\n * would otherwise resolve — a listing, or (for a team) its parent org's plugin.\n *\n * `allow` keeps today's behaviour: the override is silent beyond the dashboard\n * banner. `warn` is the same resolution with the fact recorded prominently.\n * `deny` refuses the upload, which is the only setting that actually stops a\n * team replacing the Official `trivy` for every pipeline that names it.\n */\nexport const SHADOWING_MODES = ['allow', 'warn', 'deny'] as const;\nexport type ShadowingMode = (typeof SHADOWING_MODES)[number];\n\nexport const REVIEW_STATUSES = ['published', 'held', 'removed'] as const;\nexport type ReviewStatus = (typeof REVIEW_STATUSES)[number];\n\n/** Why a held review is held. */\nexport const REVIEW_HOLD_REASONS = ['reports', 'burst', 'filter', 'security', 'moderator'] as const;\nexport type ReviewHoldReason = (typeof REVIEW_HOLD_REASONS)[number];\n\n/** A review report's category; `security` routes privately to the advisory path. */\nexport const REVIEW_REPORT_CATEGORIES = ['spam', 'abuse', 'off_topic', 'security'] as const;\nexport type ReviewReportCategory = (typeof REVIEW_REPORT_CATEGORIES)[number];\n\nexport const ADVISORY_SEVERITIES = ['critical', 'high', 'medium', 'low'] as const;\nexport type AdvisorySeverity = (typeof ADVISORY_SEVERITIES)[number];\n\nexport const ADVISORY_STATES = ['draft', 'published', 'withdrawn'] as const;\nexport type AdvisoryState = (typeof ADVISORY_STATES)[number];\n\nexport const ADVISORY_SOURCES = ['publisher', 'moderator', 'cve_rescan', 'review'] as const;\nexport type AdvisorySource = (typeof ADVISORY_SOURCES)[number];\n\n/**\n * An anonymous submission's lifecycle. `publishing` is the short claim an\n * approval takes before it copies the quarantined image out, so an expiry can\n * never delete the artifacts of a submission that is being published.\n */\nexport const SUBMISSION_STATUSES = [\n  'pending_verification', 'pending_review', 'publishing', 'gate_failed', 'approved', 'rejected', 'expired', 'claimed',\n] as const;\nexport type SubmissionStatus = (typeof SUBMISSION_STATUSES)[number];\n\n// -----------------------------------------------------------------------------\n// Plugin security notifications (per org)\n// -----------------------------------------------------------------------------\n\n/** Who receives an org's plugin security notices: `writers` = the uploader plus\n *  members holding `plugins:write`; `users` = the org's chosen members. */\nexport const PLUGIN_SECURITY_RECIPIENT_MODES = ['writers', 'users'] as const;\nexport type PluginSecurityRecipientMode = (typeof PLUGIN_SECURITY_RECIPIENT_MODES)[number];\n\n/** How rescan findings (N31) are batched; blocked builds (N30) are always immediate. */\nexport const PLUGIN_SECURITY_DIGEST_MODES = ['immediate', 'daily', 'weekly'] as const;\nexport type PluginSecurityDigestMode = (typeof PLUGIN_SECURITY_DIGEST_MODES)[number];\n\n// The build CLASS and SIZE vocabularies live in `build-catalog.ts`, together\n// with their labels, credit multipliers, tier floors and per-class slot\n// defaults. They are not here because the ids alone were never the whole fact:\n// the multiplier was in this file, the tier gate was in `quota-tiers.ts`, and\n// the labels were in a frontend mirror of both. One keyed catalog is importable\n// by the browser, so the mirror and the test that parsed this package's source\n// to detect drift are both gone.\n"]}

package/lib/utils/alias-resolver.js

@@ -65,4 +65,4 @@ export function resolveRecipientAlias(recipientOrgId) {
         originalValue: recipientOrgId,
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/api-key.js

@@ -61,4 +61,4 @@ export function hashApiKey(key) {
 export function generateApiKey(prefix) {
     return `${prefix}_${randomBytes(API_KEY_SECRET_BYTES).toString('base64url')}`;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/audit.js

@@ -40,4 +40,4 @@ export function logAuditEvent(logger, audit) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXVkaXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYXVkaXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUd0QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRzdDOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FDM0IsTUFBc0IsRUFDdEIsS0FBaUI7SUFFakIsSUFBSSxDQUFDO1FBQ0gsK0VBQStFO1FBQy9FLDJFQUEyRTtRQUMzRSw4RUFBOEU7UUFDOUUsa0RBQWtEO1FBQ2xELE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLG1CQUFtQixDQUFDLEVBQUUsYUFBYSxFQUFFLE9BQU8sRUFBRSxHQUFHLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNsRixDQUFDO0lBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztRQUNiLG1FQUFtRTtRQUNuRSxxRUFBcUU7UUFDckUsK0NBQStDO1FBQy9DLElBQUksQ0FBQztZQUNILE1BQU0sQ0FBQyxJQUFJLENBQUMsNEJBQTRCLEVBQUU7Z0JBQ3hDLEtBQUssRUFBRSxLQUFLLENBQUMsS0FBSztnQkFDbEIsS0FBSyxFQUFFLFlBQVksQ0FBQyxHQUFHLENBQUM7YUFDekIsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUFDLE1BQU0sQ0FBQztZQUNQLHFEQUFxRDtRQUN2RCxDQUFDO0lBQ0gsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHR5cGUgd2luc3RvbiBmcm9tICd3aW5zdG9uJztcbmltcG9ydCB7IHNjcnViQXdzSWRlbnRpZmllcnMgfSBmcm9tICcuL2F3cy1zY3J1Yi5qcyc7XG5pbXBvcnQgeyBlcnJvck1lc3NhZ2UgfSBmcm9tICcuL3Jlc3BvbnNlLmpzJztcbmltcG9ydCB0eXBlIHsgQXVkaXRFdmVudCB9IGZyb20gJy4uL3R5cGVzL2F1ZGl0LWV2ZW50cy5qcyc7XG5cbi8qKlxuICogTG9nIGEgY3Jvc3Mtc2VydmljZSBhdWRpdCBldmVudCBhcyBhIHN0cnVjdHVyZWQgKHdpbnN0b24g4oaSIExva2kpIGxvZyBsaW5lLlxuICpcbiAqIFRoaXMgaXMgdGhlIHNob3J0LXJldGVudGlvbiBPUEVSQVRPUiBzaW5rLiBUaGUgZHVyYWJsZSwgaGFzaC1jaGFpbmVkIGNlbnRyYWxcbiAqIGF1ZGl0IHRyYWlsIGlzIGEgZGlmZmVyZW50IHNpbms6IGByZWNvcmRBdWRpdChldmVudClgLlxuICpcbiAqIEJlc3QtZWZmb3J0OiBpZiB0aGUgdW5kZXJseWluZyBsb2dnZXIgdHJhbnNwb3J0IGZhaWxzLCB0aGUgY2FsbGVyJ3NcbiAqIG11dGF0aW9uIHN0aWxsIHN1Y2NlZWRzIOKAlCB3ZSBuZXZlciBsZXQgYXVkaXQtd3JpdGUgZmFpbHVyZSByb2xsIGJhY2tcbiAqIHRoZSB1c2VyLXZpc2libGUgb3BlcmF0aW9uLiBUaGUgbGluZSBpcyB0YWdnZWQgYGV2ZW50Q2F0ZWdvcnk6ICdhdWRpdCdgXG4gKiBzbyBkb3duc3RyZWFtIGxvZyBhZ2dyZWdhdG9ycyAoTG9raSwgQ2xvdWRXYXRjaCkgY2FuIHJvdXRlIGF1ZGl0XG4gKiBldmVudHMgaW50byBhIHNlcGFyYXRlIGluZGV4LlxuICpcbiAqIEZvciBwbGF0Zm9ybSdzIG93biBhdWRpdCBldmVudHMgKHVzZXIubG9naW4sIG9yZy5jcmVhdGUsIOKApiksIHVzZVxuICogcGxhdGZvcm0ncyBgaGVscGVycy9hdWRpdC50c2AgaW5zdGVhZCDigJQgdGhvc2UgcGVyc2lzdCB0byBNb25nb0RCLlxuICovXG5leHBvcnQgZnVuY3Rpb24gbG9nQXVkaXRFdmVudChcbiAgbG9nZ2VyOiB3aW5zdG9uLkxvZ2dlcixcbiAgYXVkaXQ6IEF1ZGl0RXZlbnQsXG4pOiB2b2lkIHtcbiAgdHJ5IHtcbiAgICAvLyBTY3J1YiBhbnkgQVdTIGFjY291bnQtaWQtc2hhcGVkIHZhbHVlcyAoZS5nLiBhbiBBUk4gaW4gYGRldGFpbHNgKSBiZWZvcmUgdGhlXG4gICAgLy8gZXZlbnQgbGFuZHMgaW4gdGhlIGR1cmFibGUgbG9nIHN0b3JlIOKAlCB0aGUgbG9nZ2VyJ3Mgc2VjcmV0LWtleSByZWRhY3Rpb25cbiAgICAvLyBkb2Vzbid0IGNvdmVyIGFjY291bnQgaWRzLCBhbmQgdGhpcyBpcyBleGFjdGx5IHRoZSBwZXJzaXN0ZW5jZSBib3VuZGFyeSB0aGVcbiAgICAvLyBcIm5ldmVyIHBlcnNpc3QgYW4gQVdTIGFjY291bnQgaWRcIiBydWxlIHRhcmdldHMuXG4gICAgbG9nZ2VyLmluZm8oJ2F1ZGl0Jywgc2NydWJBd3NJZGVudGlmaWVycyh7IGV2ZW50Q2F0ZWdvcnk6ICdhdWRpdCcsIC4uLmF1ZGl0IH0pKTtcbiAgfSBjYXRjaCAoZXJyKSB7XG4gICAgLy8gVGhlIHdpbnN0b24gbG9nZ2VyIG5vcm1hbGx5IG5ldmVyIHRocm93cyBzeW5jaHJvbm91c2x5LCBidXQgaWYgYVxuICAgIC8vIHRyYW5zcG9ydCBleHBsb2RlcyBkdXJpbmcgYSByb3V0ZSBjYWxsLCB3ZSBkb24ndCB3YW50IHRoZSBtdXRhdGlvblxuICAgIC8vIHRvIGZhaWwgYmVjYXVzZSB0aGUgYXVkaXQgd3JpdGUgZGlkbid0IGxhbmQuXG4gICAgdHJ5IHtcbiAgICAgIGxvZ2dlci53YXJuKCdGYWlsZWQgdG8gZW1pdCBhdWRpdCBldmVudCcsIHtcbiAgICAgICAgZXZlbnQ6IGF1ZGl0LmV2ZW50LFxuICAgICAgICBlcnJvcjogZXJyb3JNZXNzYWdlKGVyciksXG4gICAgICB9KTtcbiAgICB9IGNhdGNoIHtcbiAgICAgIC8vIExvZ2dlciBpdHNlbGYgaXMgdW5yZWNvdmVyYWJsZSDigJQgZ2l2ZSB1cCBzaWxlbnRseS5cbiAgICB9XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXVkaXQuanMiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9hdWRpdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBR3RDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHN0M7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUMzQixNQUFzQixFQUN0QixLQUFpQjtJQUVqQixJQUFJLENBQUM7UUFDSCwrRUFBK0U7UUFDL0UsMkVBQTJFO1FBQzNFLDhFQUE4RTtRQUM5RSxrREFBa0Q7UUFDbEQsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsbUJBQW1CLENBQUMsRUFBRSxhQUFhLEVBQUUsT0FBTyxFQUFFLEdBQUcsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ2xGLENBQUM7SUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1FBQ2IsbUVBQW1FO1FBQ25FLHFFQUFxRTtRQUNyRSwrQ0FBK0M7UUFDL0MsSUFBSSxDQUFDO1lBQ0gsTUFBTSxDQUFDLElBQUksQ0FBQyw0QkFBNEIsRUFBRTtnQkFDeEMsS0FBSyxFQUFFLEtBQUssQ0FBQyxLQUFLO2dCQUNsQixLQUFLLEVBQUUsWUFBWSxDQUFDLEdBQUcsQ0FBQzthQUN6QixDQUFDLENBQUM7UUFDTCxDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQ1AscURBQXFEO1FBQ3ZELENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5pbXBvcnQgdHlwZSB3aW5zdG9uIGZyb20gJ3dpbnN0b24nO1xuaW1wb3J0IHsgc2NydWJBd3NJZGVudGlmaWVycyB9IGZyb20gJy4vYXdzLXNjcnViLmpzJztcbmltcG9ydCB7IGVycm9yTWVzc2FnZSB9IGZyb20gJy4vcmVzcG9uc2UuanMnO1xuaW1wb3J0IHR5cGUgeyBBdWRpdEV2ZW50IH0gZnJvbSAnLi4vdHlwZXMvYXVkaXQtZXZlbnRzLmpzJztcblxuLyoqXG4gKiBMb2cgYSBjcm9zcy1zZXJ2aWNlIGF1ZGl0IGV2ZW50IGFzIGEgc3RydWN0dXJlZCAod2luc3RvbiDihpIgTG9raSkgbG9nIGxpbmUuXG4gKlxuICogVGhpcyBpcyB0aGUgc2hvcnQtcmV0ZW50aW9uIE9QRVJBVE9SIHNpbmsuIFRoZSBkdXJhYmxlLCBoYXNoLWNoYWluZWQgY2VudHJhbFxuICogYXVkaXQgdHJhaWwgaXMgYSBkaWZmZXJlbnQgc2luazogYHJlY29yZEF1ZGl0KGV2ZW50KWAuXG4gKlxuICogQmVzdC1lZmZvcnQ6IGlmIHRoZSB1bmRlcmx5aW5nIGxvZ2dlciB0cmFuc3BvcnQgZmFpbHMsIHRoZSBjYWxsZXInc1xuICogbXV0YXRpb24gc3RpbGwgc3VjY2VlZHMg4oCUIHdlIG5ldmVyIGxldCBhdWRpdC13cml0ZSBmYWlsdXJlIHJvbGwgYmFja1xuICogdGhlIHVzZXItdmlzaWJsZSBvcGVyYXRpb24uIFRoZSBsaW5lIGlzIHRhZ2dlZCBgZXZlbnRDYXRlZ29yeTogJ2F1ZGl0J2BcbiAqIHNvIGRvd25zdHJlYW0gbG9nIGFnZ3JlZ2F0b3JzIChMb2tpLCBDbG91ZFdhdGNoKSBjYW4gcm91dGUgYXVkaXRcbiAqIGV2ZW50cyBpbnRvIGEgc2VwYXJhdGUgaW5kZXguXG4gKlxuICogRm9yIHBsYXRmb3JtJ3Mgb3duIGF1ZGl0IGV2ZW50cyAodXNlci5sb2dpbiwgb3JnLmNyZWF0ZSwg4oCmKSwgdXNlXG4gKiBwbGF0Zm9ybSdzIGBoZWxwZXJzL2F1ZGl0LnRzYCBpbnN0ZWFkIOKAlCB0aG9zZSBwZXJzaXN0IHRvIE1vbmdvREIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBsb2dBdWRpdEV2ZW50KFxuICBsb2dnZXI6IHdpbnN0b24uTG9nZ2VyLFxuICBhdWRpdDogQXVkaXRFdmVudCxcbik6IHZvaWQge1xuICB0cnkge1xuICAgIC8vIFNjcnViIGFueSBBV1MgYWNjb3VudC1pZC1zaGFwZWQgdmFsdWVzIChlLmcuIGFuIEFSTiBpbiBgZGV0YWlsc2ApIGJlZm9yZSB0aGVcbiAgICAvLyBldmVudCBsYW5kcyBpbiB0aGUgZHVyYWJsZSBsb2cgc3RvcmUg4oCUIHRoZSBsb2dnZXIncyBzZWNyZXQta2V5IHJlZGFjdGlvblxuICAgIC8vIGRvZXNuJ3QgY292ZXIgYWNjb3VudCBpZHMsIGFuZCB0aGlzIGlzIGV4YWN0bHkgdGhlIHBlcnNpc3RlbmNlIGJvdW5kYXJ5IHRoZVxuICAgIC8vIFwibmV2ZXIgcGVyc2lzdCBhbiBBV1MgYWNjb3VudCBpZFwiIHJ1bGUgdGFyZ2V0cy5cbiAgICBsb2dnZXIuaW5mbygnYXVkaXQnLCBzY3J1YkF3c0lkZW50aWZpZXJzKHsgZXZlbnRDYXRlZ29yeTogJ2F1ZGl0JywgLi4uYXVkaXQgfSkpO1xuICB9IGNhdGNoIChlcnIpIHtcbiAgICAvLyBUaGUgd2luc3RvbiBsb2dnZXIgbm9ybWFsbHkgbmV2ZXIgdGhyb3dzIHN5bmNocm9ub3VzbHksIGJ1dCBpZiBhXG4gICAgLy8gdHJhbnNwb3J0IGV4cGxvZGVzIGR1cmluZyBhIHJvdXRlIGNhbGwsIHdlIGRvbid0IHdhbnQgdGhlIG11dGF0aW9uXG4gICAgLy8gdG8gZmFpbCBiZWNhdXNlIHRoZSBhdWRpdCB3cml0ZSBkaWRuJ3QgbGFuZC5cbiAgICB0cnkge1xuICAgICAgbG9nZ2VyLndhcm4oJ0ZhaWxlZCB0byBlbWl0IGF1ZGl0IGV2ZW50Jywge1xuICAgICAgICBldmVudDogYXVkaXQuZXZlbnQsXG4gICAgICAgIGVycm9yOiBlcnJvck1lc3NhZ2UoZXJyKSxcbiAgICAgIH0pO1xuICAgIH0gY2F0Y2gge1xuICAgICAgLy8gTG9nZ2VyIGl0c2VsZiBpcyB1bnJlY292ZXJhYmxlIOKAlCBnaXZlIHVwIHNpbGVudGx5LlxuICAgIH1cbiAgfVxufVxuIl19

package/lib/utils/aws-scrub.js

@@ -64,4 +64,4 @@ export function scrubAwsIdentifiers(value) {
     }
     return value;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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