@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/types/pipeline.d.ts

@@ -22,6 +22,45 @@ export declare const ComputeType: {
     readonly X2_LARGE: 'X2_LARGE';
 };
 export type ComputeType = ValueOf<typeof ComputeType>;
+/**
+ * vCPU each CodeBuild compute size provides, for turning a build's DURATION
+ * into `cpuCredits` (one credit = one vCPU-minute).
+ *
+ * Derived from the same AWS table the `ComputeType` doc above cites, and kept
+ * beside it on purpose: the memory/vCPU figures in that comment and the numbers
+ * here are the same fact, and splitting them is how one gets updated alone.
+ *
+ * `X2_LARGE` is 72 vCPU — thirty-six times SMALL. That ratio is why pipeline
+ * execution cannot be charged by wall-clock alone, and why ingesting it
+ * (Phase 4) re-derives the tier ladder rather than simply adding to it.
+ */
+export declare const CODEBUILD_COMPUTE_VCPU: Readonly<Record<ComputeType, number>>;
+/**
+ * AWS's own spelling of a compute size, as `BatchGetBuilds` returns it
+ * (`environment.computeType`), narrowed to ours.
+ *
+ * Needed because the two vocabularies differ: the pipeline config stores
+ * `MEDIUM`, AWS answers `BUILD_GENERAL1_MEDIUM`, and a wrong match here would
+ * price a build at the wrong vCPU rather than failing visibly. Anything
+ * unrecognised returns `null` — an unknown size must be reported as unknown, not
+ * silently priced as SMALL, which is the cheapest and therefore the most
+ * flattering guess.
+ */
+export declare function normalizeComputeType(raw: string | undefined | null): ComputeType | null;
+/**
+ * Credits one CodeBuild action consumed, from its duration and compute size.
+ *
+ * Rounds UP to the whole credit, matching the plugin-build meter
+ * (`creditsForBuild`) — two meters feeding one counter must round the same way
+ * or the counter means neither.
+ *
+ * Returns `null` rather than 0 when either input is missing, and the distinction
+ * is the point: a build with no measured duration was not observed, and
+ * reporting that as zero consumption would make the coverage gap look like
+ * idleness. The ingest counts those separately (`measured="false"`) so the
+ * coverage ratio is visible BEFORE anyone prices a tier off this series.
+ */
+export declare function computeCreditsFor(durationMs: number | null | undefined, computeType: ComputeType | null): number | null;
 /**
  * Types of pipeline steps that can be created by plugins
  *

package/lib/types/pipeline.js

@@ -16,6 +16,62 @@ export const ComputeType = {
     LARGE: 'LARGE',
     X2_LARGE: 'X2_LARGE',
 };
+/**
+ * vCPU each CodeBuild compute size provides, for turning a build's DURATION
+ * into `cpuCredits` (one credit = one vCPU-minute).
+ *
+ * Derived from the same AWS table the `ComputeType` doc above cites, and kept
+ * beside it on purpose: the memory/vCPU figures in that comment and the numbers
+ * here are the same fact, and splitting them is how one gets updated alone.
+ *
+ * `X2_LARGE` is 72 vCPU — thirty-six times SMALL. That ratio is why pipeline
+ * execution cannot be charged by wall-clock alone, and why ingesting it
+ * (Phase 4) re-derives the tier ladder rather than simply adding to it.
+ */
+export const CODEBUILD_COMPUTE_VCPU = {
+    SMALL: 2,
+    MEDIUM: 4,
+    LARGE: 8,
+    X2_LARGE: 72,
+};
+/**
+ * AWS's own spelling of a compute size, as `BatchGetBuilds` returns it
+ * (`environment.computeType`), narrowed to ours.
+ *
+ * Needed because the two vocabularies differ: the pipeline config stores
+ * `MEDIUM`, AWS answers `BUILD_GENERAL1_MEDIUM`, and a wrong match here would
+ * price a build at the wrong vCPU rather than failing visibly. Anything
+ * unrecognised returns `null` — an unknown size must be reported as unknown, not
+ * silently priced as SMALL, which is the cheapest and therefore the most
+ * flattering guess.
+ */
+export function normalizeComputeType(raw) {
+    if (!raw)
+        return null;
+    const upper = raw.toUpperCase();
+    const bare = upper.startsWith('BUILD_GENERAL1_') ? upper.slice('BUILD_GENERAL1_'.length) : upper;
+    // AWS spells the largest one `2XLARGE`; ours is `X2_LARGE`.
+    const key = bare === '2XLARGE' || bare === 'X2LARGE' ? 'X2_LARGE' : bare;
+    return Object.keys(CODEBUILD_COMPUTE_VCPU).find((c) => c === key) ?? null;
+}
+/**
+ * Credits one CodeBuild action consumed, from its duration and compute size.
+ *
+ * Rounds UP to the whole credit, matching the plugin-build meter
+ * (`creditsForBuild`) — two meters feeding one counter must round the same way
+ * or the counter means neither.
+ *
+ * Returns `null` rather than 0 when either input is missing, and the distinction
+ * is the point: a build with no measured duration was not observed, and
+ * reporting that as zero consumption would make the coverage gap look like
+ * idleness. The ingest counts those separately (`measured="false"`) so the
+ * coverage ratio is visible BEFORE anyone prices a tier off this series.
+ */
+export function computeCreditsFor(durationMs, computeType) {
+    if (durationMs == null || !(durationMs > 0) || !computeType)
+        return null;
+    return Math.ceil((durationMs / 60_000) * CODEBUILD_COMPUTE_VCPU[computeType]);
+}
 /**
  * Types of pipeline steps that can be created by plugins
  *
@@ -28,4 +84,4 @@ export const PluginType = {
     SHELL_STEP: 'ShellStep',
     MANUAL_APPROVAL_STEP: 'ManualApprovalStep',
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../../src/types/pipeline.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAWtC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,QAAQ,EAAE,UAAU;CACZ,CAAC;AAGX;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAA0C;IAC3E,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC;IACT,KAAK,EAAE,CAAC;IACR,QAAQ,EAAE,EAAE;CACb,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAA8B;IACjE,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,MAAM,KAAK,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;IAChC,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACjG,4DAA4D;IAC5D,MAAM,GAAG,GAAG,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC;IACzE,OAAQ,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,IAAI,IAAI,CAAC;AAC/F,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,iBAAiB,CAAC,UAAqC,EAAE,WAA+B;IACtG,IAAI,UAAU,IAAI,IAAI,IAAI,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,WAAW;QAAE,OAAO,IAAI,CAAC;IACzE,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,GAAG,MAAM,CAAC,GAAG,sBAAsB,CAAC,WAAW,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,eAAe,EAAE,eAAe;IAChC,UAAU,EAAE,WAAW;IACvB,oBAAoB,EAAE,oBAAoB;CAClC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared pipeline types used by both pipeline-core and pipeline-data\n */\n\n/**\n * Utility type to extract the union of all values from an object type\n */\ntype ValueOf<T> = T[keyof T];\n\n/**\n * AWS CodeBuild compute resource sizes\n *\n * @property SMALL - 3 GB memory, 2 vCPUs\n * @property MEDIUM - 7 GB memory, 4 vCPUs\n * @property LARGE - 15 GB memory, 8 vCPUs\n * @property X2_LARGE - 145 GB memory, 72 vCPUs\n *\n * @see https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html\n */\nexport const ComputeType = {\n  SMALL: 'SMALL',\n  MEDIUM: 'MEDIUM',\n  LARGE: 'LARGE',\n  X2_LARGE: 'X2_LARGE',\n} as const;\nexport type ComputeType = ValueOf<typeof ComputeType>;\n\n/**\n * vCPU each CodeBuild compute size provides, for turning a build's DURATION\n * into `cpuCredits` (one credit = one vCPU-minute).\n *\n * Derived from the same AWS table the `ComputeType` doc above cites, and kept\n * beside it on purpose: the memory/vCPU figures in that comment and the numbers\n * here are the same fact, and splitting them is how one gets updated alone.\n *\n * `X2_LARGE` is 72 vCPU — thirty-six times SMALL. That ratio is why pipeline\n * execution cannot be charged by wall-clock alone, and why ingesting it\n * (Phase 4) re-derives the tier ladder rather than simply adding to it.\n */\nexport const CODEBUILD_COMPUTE_VCPU: Readonly<Record<ComputeType, number>> = {\n  SMALL: 2,\n  MEDIUM: 4,\n  LARGE: 8,\n  X2_LARGE: 72,\n};\n\n/**\n * AWS's own spelling of a compute size, as `BatchGetBuilds` returns it\n * (`environment.computeType`), narrowed to ours.\n *\n * Needed because the two vocabularies differ: the pipeline config stores\n * `MEDIUM`, AWS answers `BUILD_GENERAL1_MEDIUM`, and a wrong match here would\n * price a build at the wrong vCPU rather than failing visibly. Anything\n * unrecognised returns `null` — an unknown size must be reported as unknown, not\n * silently priced as SMALL, which is the cheapest and therefore the most\n * flattering guess.\n */\nexport function normalizeComputeType(raw: string | undefined | null): ComputeType | null {\n  if (!raw) return null;\n  const upper = raw.toUpperCase();\n  const bare = upper.startsWith('BUILD_GENERAL1_') ? upper.slice('BUILD_GENERAL1_'.length) : upper;\n  // AWS spells the largest one `2XLARGE`; ours is `X2_LARGE`.\n  const key = bare === '2XLARGE' || bare === 'X2LARGE' ? 'X2_LARGE' : bare;\n  return (Object.keys(CODEBUILD_COMPUTE_VCPU) as ComputeType[]).find((c) => c === key) ?? null;\n}\n\n/**\n * Credits one CodeBuild action consumed, from its duration and compute size.\n *\n * Rounds UP to the whole credit, matching the plugin-build meter\n * (`creditsForBuild`) — two meters feeding one counter must round the same way\n * or the counter means neither.\n *\n * Returns `null` rather than 0 when either input is missing, and the distinction\n * is the point: a build with no measured duration was not observed, and\n * reporting that as zero consumption would make the coverage gap look like\n * idleness. The ingest counts those separately (`measured=\"false\"`) so the\n * coverage ratio is visible BEFORE anyone prices a tier off this series.\n */\nexport function computeCreditsFor(durationMs: number | null | undefined, computeType: ComputeType | null): number | null {\n  if (durationMs == null || !(durationMs > 0) || !computeType) return null;\n  return Math.ceil((durationMs / 60_000) * CODEBUILD_COMPUTE_VCPU[computeType]);\n}\n\n/**\n * Types of pipeline steps that can be created by plugins\n *\n * @property CODE_BUILD_STEP - Full CodeBuild step with custom build environment\n * @property SHELL_STEP - Simple shell step without custom build environment\n * @property MANUAL_APPROVAL_STEP - Native CDK approval gate (no Docker image, no commands)\n */\nexport const PluginType = {\n  CODE_BUILD_STEP: 'CodeBuildStep',\n  SHELL_STEP: 'ShellStep',\n  MANUAL_APPROVAL_STEP: 'ManualApprovalStep',\n} as const;\nexport type PluginType = ValueOf<typeof PluginType>;\n\n/**\n * Metadata type for storing configuration and custom properties\n *\n * Supports:\n * - Standard key-value pairs (string, boolean, number)\n * - Custom AWS CDK keys with the pattern `aws:cdk:{namespace}:{key}`\n *   (all lowercase — matches the format produced by `getCustomKey`)\n *\n * @example\n * ```typescript\n * const metadata: MetaDataType = {\n *   BUILD_ENV: 'production',\n *   NODE_VERSION: '18',\n *   ENABLE_CACHE: true,\n *   MAX_RETRIES: 3\n * };\n * ```\n */\nexport type MetaDataType =\n  Record<string, string | boolean | number> &\n  { [K in `aws:cdk:${string}`]?: unknown };\n"]}

package/lib/types/plugin-health.d.ts

@@ -23,8 +23,6 @@ export declare const HEALTH_COMPONENTS: readonly ['runtime', 'vulns', 'freshness
 export type HealthComponent = (typeof HEALTH_COMPONENTS)[number];
 /** Nominal weight of each component (they sum to 100). */
 export declare const HEALTH_WEIGHTS: Readonly<Record<HealthComponent, number>>;
-/** Human labels for the breakdown panel. */
-export declare const HEALTH_COMPONENT_LABELS: Readonly<Record<HealthComponent, string>>;
 /** Fewer available components than this ⇒ no score. */
 export declare const HEALTH_MIN_COMPONENTS = 3;
 /** Runs needed in the window before the success rate counts. */

package/lib/types/plugin-health.js

@@ -32,16 +32,6 @@ export const HEALTH_WEIGHTS = {
     docs: 10,
     rating: 10,
 };
-/** Human labels for the breakdown panel. */
-export const HEALTH_COMPONENT_LABELS = {
-    runtime: 'Runtime success (30 days)',
-    vulns: 'Known vulnerabilities',
-    freshness: 'Freshness',
-    signed: 'Signed image',
-    smokeTest: 'Smoke test declared',
-    docs: 'README and license',
-    rating: 'Rating',
-};
 /** Fewer available components than this ⇒ no score. */
 export const HEALTH_MIN_COMPONENTS = 3;
 /** Runs needed in the window before the success rate counts. */
@@ -181,4 +171,4 @@ export function healthBand(score) {
         return 'fair';
     return 'poor';
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-health.js","sourceRoot":"","sources":["../../src/types/plugin-health.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The plugin HEALTH SCORE (docs/plugin-publishing.md): one 0–100\n * number per listing, from seven components. Pure and dependency-free so the\n * plugin service (the stats sweep), the frontend (the breakdown panel's\n * labels) and the tests share one definition.\n *\n * Each component scores 0..1 and carries a fixed weight. A component whose\n * inputs are missing is DROPPED and the remaining weights are renormalized; with\n * fewer than {@link HEALTH_MIN_COMPONENTS} components the score is null (\"not\n * enough data\"), never a guess.\n *\n * | component  | weight | score                                                                 |\n * |------------|--------|-----------------------------------------------------------------------|\n * | runtime    | 25     | 30-day success rate; only with ≥ 20 runs                              |\n * | vulns      | 20     | 1 − 0.5·critical − 0.1·high (floor 0), latest listed version; scanned only |\n * | freshness  | 15     | release age (≤90d 1 → 0 at 540d) averaged with base-image age (≤60d 1 → 0 at 365d) when recorded |\n * | signed     | 10     | image digest present and signed ⇒ 1                                   |\n * | smokeTest  | 10     | smoke test declared ⇒ 1                                               |\n * | docs       | 10     | README 0.5 + license 0.5                                              |\n * | rating     | 10     | Bayesian rating / 5; only with ≥ 3 ratings                            |\n */\n\nexport const HEALTH_COMPONENTS = ['runtime', 'vulns', 'freshness', 'signed', 'smokeTest', 'docs', 'rating'] as const;\nexport type HealthComponent = (typeof HEALTH_COMPONENTS)[number];\n\n/** Nominal weight of each component (they sum to 100). */\nexport const HEALTH_WEIGHTS: Readonly<Record<HealthComponent, number>> = {\n  runtime: 25,\n  vulns: 20,\n  freshness: 15,\n  signed: 10,\n  smokeTest: 10,\n  docs: 10,\n  rating: 10,\n};\n\n/** Human labels for the breakdown panel. */\nexport const HEALTH_COMPONENT_LABELS: Readonly<Record<HealthComponent, string>> = {\n  runtime: 'Runtime success (30 days)',\n  vulns: 'Known vulnerabilities',\n  freshness: 'Freshness',\n  signed: 'Signed image',\n  smokeTest: 'Smoke test declared',\n  docs: 'README and license',\n  rating: 'Rating',\n};\n\n/** Fewer available components than this ⇒ no score. */\nexport const HEALTH_MIN_COMPONENTS = 3;\n/** Runs needed in the window before the success rate counts. */\nexport const HEALTH_MIN_RUNS = 20;\n/** Ratings needed before the rating counts. */\nexport const HEALTH_MIN_RATINGS = 3;\n/** Release age: full marks up to this many days, zero at {@link HEALTH_RELEASE_ZERO_DAYS}. */\nexport const HEALTH_RELEASE_FULL_DAYS = 90;\nexport const HEALTH_RELEASE_ZERO_DAYS = 540;\n/** Base-image age: full marks up to this many days, zero at {@link HEALTH_BASE_IMAGE_ZERO_DAYS}. */\nexport const HEALTH_BASE_IMAGE_FULL_DAYS = 60;\nexport const HEALTH_BASE_IMAGE_ZERO_DAYS = 365;\n\n/** One component's contribution: its 0..1 score (null = missing, dropped) and its nominal weight. */\nexport interface HealthComponentScore {\n  score: number | null;\n  weight: number;\n}\nexport type HealthBreakdown = Record<HealthComponent, HealthComponentScore>;\n\nexport interface HealthResult {\n  /** 0–100 integer, or null with fewer than {@link HEALTH_MIN_COMPONENTS} components. */\n  score: number | null;\n  breakdown: HealthBreakdown;\n}\n\n/**\n * What the score is computed from. Every field is optional: `undefined` / null\n * means \"not known\", which drops the component (or, for freshness, that half).\n */\nexport interface HealthInputs {\n  /** Terminal runs in the 30-day window, and the share that succeeded (0..1). */\n  runs30d?: number | null;\n  successRate30d?: number | null;\n  /** The latest listed version's scan; `scannedAt` null ⇒ never scanned. */\n  vulnCritical?: number | null;\n  vulnHigh?: number | null;\n  scannedAt?: Date | string | null;\n  /** When the latest listed version was published. */\n  lastReleaseAt?: Date | string | null;\n  /** The latest listed version's base image `created` time, when recorded. */\n  baseImageCreatedAt?: Date | string | null;\n  /** Latest listed version has an image digest AND a signature (its `public/*` copy). */\n  signed?: boolean | null;\n  smokeTestDeclared?: boolean | null;\n  hasReadme?: boolean | null;\n  hasLicense?: boolean | null;\n  ratingBayes?: number | null;\n  ratingCount?: number | null;\n}\n\nconst DAY_MS = 86_400_000;\n\nconst round3 = (n: number): number => Math.round(n * 1000) / 1000;\nconst clamp01 = (n: number): number => Math.min(1, Math.max(0, n));\n\nfunction toTime(d: Date | string | null | undefined): number | null {\n  if (d === null || d === undefined) return null;\n  const t = new Date(d).getTime();\n  return Number.isFinite(t) ? t : null;\n}\n\n/** 1 up to `fullDays`, falling linearly to 0 at `zeroDays` (a future date counts as fresh). */\nexport function ageScore(ageDays: number, fullDays: number, zeroDays: number): number {\n  if (ageDays <= fullDays) return 1;\n  if (ageDays >= zeroDays) return 0;\n  return clamp01(1 - (ageDays - fullDays) / (zeroDays - fullDays));\n}\n\n/** The vulnerability component: 1 − 0.5·critical − 0.1·high, floored at 0. */\nexport function vulnScore(critical: number, high: number): number {\n  return clamp01(1 - 0.5 * Math.max(0, critical) - 0.1 * Math.max(0, high));\n}\n\nfunction runtimeComponent(i: HealthInputs): number | null {\n  if (i.runs30d === null || i.runs30d === undefined || i.runs30d < HEALTH_MIN_RUNS) return null;\n  if (i.successRate30d === null || i.successRate30d === undefined || !Number.isFinite(i.successRate30d)) return null;\n  return clamp01(i.successRate30d);\n}\n\nfunction vulnsComponent(i: HealthInputs): number | null {\n  if (toTime(i.scannedAt) === null) return null;\n  return vulnScore(i.vulnCritical ?? 0, i.vulnHigh ?? 0);\n}\n\nfunction freshnessComponent(i: HealthInputs, now: number): number | null {\n  const parts: number[] = [];\n  const release = toTime(i.lastReleaseAt);\n  if (release !== null) parts.push(ageScore((now - release) / DAY_MS, HEALTH_RELEASE_FULL_DAYS, HEALTH_RELEASE_ZERO_DAYS));\n  const base = toTime(i.baseImageCreatedAt);\n  if (base !== null) parts.push(ageScore((now - base) / DAY_MS, HEALTH_BASE_IMAGE_FULL_DAYS, HEALTH_BASE_IMAGE_ZERO_DAYS));\n  if (parts.length === 0) return null;\n  return parts.reduce((a, b) => a + b, 0) / parts.length;\n}\n\nconst flag = (b: boolean | null | undefined): number | null => (b === null || b === undefined ? null : b ? 1 : 0);\n\nfunction docsComponent(i: HealthInputs): number | null {\n  if ((i.hasReadme === null || i.hasReadme === undefined) && (i.hasLicense === null || i.hasLicense === undefined)) return null;\n  return (i.hasReadme ? 0.5 : 0) + (i.hasLicense ? 0.5 : 0);\n}\n\nfunction ratingComponent(i: HealthInputs): number | null {\n  if (i.ratingCount === null || i.ratingCount === undefined || i.ratingCount < HEALTH_MIN_RATINGS) return null;\n  if (i.ratingBayes === null || i.ratingBayes === undefined || !Number.isFinite(i.ratingBayes)) return null;\n  return clamp01(i.ratingBayes / 5);\n}\n\n/** The health score and its per-component breakdown. Pure; `now` is injectable for tests. */\nexport function computeHealthScore(inputs: HealthInputs, now: Date = new Date()): HealthResult {\n  const t = now.getTime();\n  const raw: Record<HealthComponent, number | null> = {\n    runtime: runtimeComponent(inputs),\n    vulns: vulnsComponent(inputs),\n    freshness: freshnessComponent(inputs, t),\n    signed: flag(inputs.signed),\n    smokeTest: flag(inputs.smokeTestDeclared),\n    docs: docsComponent(inputs),\n    rating: ratingComponent(inputs),\n  };\n  const breakdown = {} as HealthBreakdown;\n  let weighted = 0;\n  let totalWeight = 0;\n  let available = 0;\n  for (const c of HEALTH_COMPONENTS) {\n    const score = raw[c];\n    breakdown[c] = { score: score === null ? null : round3(score), weight: HEALTH_WEIGHTS[c] };\n    if (score === null) continue;\n    available++;\n    weighted += score * HEALTH_WEIGHTS[c];\n    totalWeight += HEALTH_WEIGHTS[c];\n  }\n  const score = available < HEALTH_MIN_COMPONENTS || totalWeight === 0 ? null : Math.round((100 * weighted) / totalWeight);\n  return { score, breakdown };\n}\n\n/**\n * A publisher's health: the install-weighted mean of its listings' scores\n * (listings with no score are skipped; when no listing has installs, the plain\n * mean). Null when no listing has a score.\n */\nexport function publisherHealthScore(listings: ReadonlyArray<{ healthScore: number | null; installCount: number }>): number | null {\n  const scored = listings.filter((l): l is { healthScore: number; installCount: number } =>\n    l.healthScore !== null && Number.isFinite(l.healthScore));\n  if (scored.length === 0) return null;\n  const weightOf = (n: number) => Math.max(0, n);\n  const totalInstalls = scored.reduce((a, l) => a + weightOf(l.installCount), 0);\n  if (totalInstalls === 0) return Math.round(scored.reduce((a, l) => a + l.healthScore, 0) / scored.length);\n  return Math.round(scored.reduce((a, l) => a + l.healthScore * weightOf(l.installCount), 0) / totalInstalls);\n}\n\n/**\n * A publisher's 30-day success rate across its listings, weighted by runs.\n * Null when none of its listings ran in the window.\n */\nexport function publisherSuccessRate(listings: ReadonlyArray<{ successRate30d: number | null; runs30d: number }>): number | null {\n  let runs = 0;\n  let succeeded = 0;\n  for (const l of listings) {\n    if (l.successRate30d === null || !Number.isFinite(l.successRate30d) || l.runs30d <= 0) continue;\n    runs += l.runs30d;\n    succeeded += l.successRate30d * l.runs30d;\n  }\n  return runs === 0 ? null : round3(succeeded / runs);\n}\n\n/** Display band for a score: good ≥ 80, fair ≥ 50, poor below, unknown when null. */\nexport type HealthBand = 'good' | 'fair' | 'poor' | 'unknown';\nexport const HEALTH_BAND_GOOD = 80;\nexport const HEALTH_BAND_FAIR = 50;\n\nexport function healthBand(score: number | null | undefined): HealthBand {\n  if (score === null || score === undefined || !Number.isFinite(score)) return 'unknown';\n  if (score >= HEALTH_BAND_GOOD) return 'good';\n  if (score >= HEALTH_BAND_FAIR) return 'fair';\n  return 'poor';\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-health.js","sourceRoot":"","sources":["../../src/types/plugin-health.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The plugin HEALTH SCORE (docs/plugin-publishing.md): one 0–100\n * number per listing, from seven components. Pure and dependency-free so the\n * plugin service (the stats sweep), the frontend (the breakdown panel's\n * labels) and the tests share one definition.\n *\n * Each component scores 0..1 and carries a fixed weight. A component whose\n * inputs are missing is DROPPED and the remaining weights are renormalized; with\n * fewer than {@link HEALTH_MIN_COMPONENTS} components the score is null (\"not\n * enough data\"), never a guess.\n *\n * | component  | weight | score                                                                 |\n * |------------|--------|-----------------------------------------------------------------------|\n * | runtime    | 25     | 30-day success rate; only with ≥ 20 runs                              |\n * | vulns      | 20     | 1 − 0.5·critical − 0.1·high (floor 0), latest listed version; scanned only |\n * | freshness  | 15     | release age (≤90d 1 → 0 at 540d) averaged with base-image age (≤60d 1 → 0 at 365d) when recorded |\n * | signed     | 10     | image digest present and signed ⇒ 1                                   |\n * | smokeTest  | 10     | smoke test declared ⇒ 1                                               |\n * | docs       | 10     | README 0.5 + license 0.5                                              |\n * | rating     | 10     | Bayesian rating / 5; only with ≥ 3 ratings                            |\n */\n\nexport const HEALTH_COMPONENTS = ['runtime', 'vulns', 'freshness', 'signed', 'smokeTest', 'docs', 'rating'] as const;\nexport type HealthComponent = (typeof HEALTH_COMPONENTS)[number];\n\n/** Nominal weight of each component (they sum to 100). */\nexport const HEALTH_WEIGHTS: Readonly<Record<HealthComponent, number>> = {\n  runtime: 25,\n  vulns: 20,\n  freshness: 15,\n  signed: 10,\n  smokeTest: 10,\n  docs: 10,\n  rating: 10,\n};\n\n/** Fewer available components than this ⇒ no score. */\nexport const HEALTH_MIN_COMPONENTS = 3;\n/** Runs needed in the window before the success rate counts. */\nexport const HEALTH_MIN_RUNS = 20;\n/** Ratings needed before the rating counts. */\nexport const HEALTH_MIN_RATINGS = 3;\n/** Release age: full marks up to this many days, zero at {@link HEALTH_RELEASE_ZERO_DAYS}. */\nexport const HEALTH_RELEASE_FULL_DAYS = 90;\nexport const HEALTH_RELEASE_ZERO_DAYS = 540;\n/** Base-image age: full marks up to this many days, zero at {@link HEALTH_BASE_IMAGE_ZERO_DAYS}. */\nexport const HEALTH_BASE_IMAGE_FULL_DAYS = 60;\nexport const HEALTH_BASE_IMAGE_ZERO_DAYS = 365;\n\n/** One component's contribution: its 0..1 score (null = missing, dropped) and its nominal weight. */\nexport interface HealthComponentScore {\n  score: number | null;\n  weight: number;\n}\nexport type HealthBreakdown = Record<HealthComponent, HealthComponentScore>;\n\nexport interface HealthResult {\n  /** 0–100 integer, or null with fewer than {@link HEALTH_MIN_COMPONENTS} components. */\n  score: number | null;\n  breakdown: HealthBreakdown;\n}\n\n/**\n * What the score is computed from. Every field is optional: `undefined` / null\n * means \"not known\", which drops the component (or, for freshness, that half).\n */\nexport interface HealthInputs {\n  /** Terminal runs in the 30-day window, and the share that succeeded (0..1). */\n  runs30d?: number | null;\n  successRate30d?: number | null;\n  /** The latest listed version's scan; `scannedAt` null ⇒ never scanned. */\n  vulnCritical?: number | null;\n  vulnHigh?: number | null;\n  scannedAt?: Date | string | null;\n  /** When the latest listed version was published. */\n  lastReleaseAt?: Date | string | null;\n  /** The latest listed version's base image `created` time, when recorded. */\n  baseImageCreatedAt?: Date | string | null;\n  /** Latest listed version has an image digest AND a signature (its `public/*` copy). */\n  signed?: boolean | null;\n  smokeTestDeclared?: boolean | null;\n  hasReadme?: boolean | null;\n  hasLicense?: boolean | null;\n  ratingBayes?: number | null;\n  ratingCount?: number | null;\n}\n\nconst DAY_MS = 86_400_000;\n\nconst round3 = (n: number): number => Math.round(n * 1000) / 1000;\nconst clamp01 = (n: number): number => Math.min(1, Math.max(0, n));\n\nfunction toTime(d: Date | string | null | undefined): number | null {\n  if (d === null || d === undefined) return null;\n  const t = new Date(d).getTime();\n  return Number.isFinite(t) ? t : null;\n}\n\n/** 1 up to `fullDays`, falling linearly to 0 at `zeroDays` (a future date counts as fresh). */\nexport function ageScore(ageDays: number, fullDays: number, zeroDays: number): number {\n  if (ageDays <= fullDays) return 1;\n  if (ageDays >= zeroDays) return 0;\n  return clamp01(1 - (ageDays - fullDays) / (zeroDays - fullDays));\n}\n\n/** The vulnerability component: 1 − 0.5·critical − 0.1·high, floored at 0. */\nexport function vulnScore(critical: number, high: number): number {\n  return clamp01(1 - 0.5 * Math.max(0, critical) - 0.1 * Math.max(0, high));\n}\n\nfunction runtimeComponent(i: HealthInputs): number | null {\n  if (i.runs30d === null || i.runs30d === undefined || i.runs30d < HEALTH_MIN_RUNS) return null;\n  if (i.successRate30d === null || i.successRate30d === undefined || !Number.isFinite(i.successRate30d)) return null;\n  return clamp01(i.successRate30d);\n}\n\nfunction vulnsComponent(i: HealthInputs): number | null {\n  if (toTime(i.scannedAt) === null) return null;\n  return vulnScore(i.vulnCritical ?? 0, i.vulnHigh ?? 0);\n}\n\nfunction freshnessComponent(i: HealthInputs, now: number): number | null {\n  const parts: number[] = [];\n  const release = toTime(i.lastReleaseAt);\n  if (release !== null) parts.push(ageScore((now - release) / DAY_MS, HEALTH_RELEASE_FULL_DAYS, HEALTH_RELEASE_ZERO_DAYS));\n  const base = toTime(i.baseImageCreatedAt);\n  if (base !== null) parts.push(ageScore((now - base) / DAY_MS, HEALTH_BASE_IMAGE_FULL_DAYS, HEALTH_BASE_IMAGE_ZERO_DAYS));\n  if (parts.length === 0) return null;\n  return parts.reduce((a, b) => a + b, 0) / parts.length;\n}\n\nconst flag = (b: boolean | null | undefined): number | null => (b === null || b === undefined ? null : b ? 1 : 0);\n\nfunction docsComponent(i: HealthInputs): number | null {\n  if ((i.hasReadme === null || i.hasReadme === undefined) && (i.hasLicense === null || i.hasLicense === undefined)) return null;\n  return (i.hasReadme ? 0.5 : 0) + (i.hasLicense ? 0.5 : 0);\n}\n\nfunction ratingComponent(i: HealthInputs): number | null {\n  if (i.ratingCount === null || i.ratingCount === undefined || i.ratingCount < HEALTH_MIN_RATINGS) return null;\n  if (i.ratingBayes === null || i.ratingBayes === undefined || !Number.isFinite(i.ratingBayes)) return null;\n  return clamp01(i.ratingBayes / 5);\n}\n\n/** The health score and its per-component breakdown. Pure; `now` is injectable for tests. */\nexport function computeHealthScore(inputs: HealthInputs, now: Date = new Date()): HealthResult {\n  const t = now.getTime();\n  const raw: Record<HealthComponent, number | null> = {\n    runtime: runtimeComponent(inputs),\n    vulns: vulnsComponent(inputs),\n    freshness: freshnessComponent(inputs, t),\n    signed: flag(inputs.signed),\n    smokeTest: flag(inputs.smokeTestDeclared),\n    docs: docsComponent(inputs),\n    rating: ratingComponent(inputs),\n  };\n  const breakdown = {} as HealthBreakdown;\n  let weighted = 0;\n  let totalWeight = 0;\n  let available = 0;\n  for (const c of HEALTH_COMPONENTS) {\n    const score = raw[c];\n    breakdown[c] = { score: score === null ? null : round3(score), weight: HEALTH_WEIGHTS[c] };\n    if (score === null) continue;\n    available++;\n    weighted += score * HEALTH_WEIGHTS[c];\n    totalWeight += HEALTH_WEIGHTS[c];\n  }\n  const score = available < HEALTH_MIN_COMPONENTS || totalWeight === 0 ? null : Math.round((100 * weighted) / totalWeight);\n  return { score, breakdown };\n}\n\n/**\n * A publisher's health: the install-weighted mean of its listings' scores\n * (listings with no score are skipped; when no listing has installs, the plain\n * mean). Null when no listing has a score.\n */\nexport function publisherHealthScore(listings: ReadonlyArray<{ healthScore: number | null; installCount: number }>): number | null {\n  const scored = listings.filter((l): l is { healthScore: number; installCount: number } =>\n    l.healthScore !== null && Number.isFinite(l.healthScore));\n  if (scored.length === 0) return null;\n  const weightOf = (n: number) => Math.max(0, n);\n  const totalInstalls = scored.reduce((a, l) => a + weightOf(l.installCount), 0);\n  if (totalInstalls === 0) return Math.round(scored.reduce((a, l) => a + l.healthScore, 0) / scored.length);\n  return Math.round(scored.reduce((a, l) => a + l.healthScore * weightOf(l.installCount), 0) / totalInstalls);\n}\n\n/**\n * A publisher's 30-day success rate across its listings, weighted by runs.\n * Null when none of its listings ran in the window.\n */\nexport function publisherSuccessRate(listings: ReadonlyArray<{ successRate30d: number | null; runs30d: number }>): number | null {\n  let runs = 0;\n  let succeeded = 0;\n  for (const l of listings) {\n    if (l.successRate30d === null || !Number.isFinite(l.successRate30d) || l.runs30d <= 0) continue;\n    runs += l.runs30d;\n    succeeded += l.successRate30d * l.runs30d;\n  }\n  return runs === 0 ? null : round3(succeeded / runs);\n}\n\n/** Display band for a score: good ≥ 80, fair ≥ 50, poor below, unknown when null. */\nexport type HealthBand = 'good' | 'fair' | 'poor' | 'unknown';\nexport const HEALTH_BAND_GOOD = 80;\nexport const HEALTH_BAND_FAIR = 50;\n\nexport function healthBand(score: number | null | undefined): HealthBand {\n  if (score === null || score === undefined || !Number.isFinite(score)) return 'unknown';\n  if (score >= HEALTH_BAND_GOOD) return 'good';\n  if (score >= HEALTH_BAND_FAIR) return 'fair';\n  return 'poor';\n}\n"]}

package/lib/types/plugin-scan.d.ts

@@ -7,25 +7,50 @@ export interface PluginScanFinding {
     packageVersion: string;
     /** Versions that fix it; empty = no fix available (not fixable). */
     fixedIn: string[];
+    /**
+     * CISA lists it as KNOWN EXPLOITED (grype's `knownExploited`). Absent =
+     * not listed. A KEV Critical is gated even when unfixable, and only an
+     * ADVISORY-ID waiver can exempt it — see {@link applyVulnWaivers}.
+     */
+    kev?: boolean;
+    /**
+     * EPSS probability (0–1) that it is exploited in the next 30 days, as grype
+     * reports it; absent when the DB carries no score. Context for a reader
+     * ranking findings, never a gate input — a probability is not a verdict.
+     */
+    epss?: number;
 }
 /**
- * `scan_flag` on a version the nightly rescan flagged: its fixable
- * Critical/High counts at that rescan and the top fixable findings. Set while
- * fixable Criticals exceed `PLUGIN_VULN_MAX_CRITICAL`, cleared when a rescan
- * finds them resolved.
+ * `scan_flag` on a version the nightly rescan flagged: its GATED Critical
+ * count and fixable High count at that rescan, and the top gated findings. Set
+ * while gated findings exceed `PLUGIN_VULN_MAX_FINDINGS`, cleared when a
+ * rescan finds them resolved.
  */
 export interface PluginScanFlag {
-    /** Fixable Critical findings. */
-    critical: number;
+    /**
+     * Gated findings — at or above `failOn` (default Critical): fixable ones,
+     * plus unfixable KEV-listed ones under `PLUGIN_VULN_GATE_KEV`.
+     */
+    gated: number;
+    /** Of `gated`, the KEV-listed ones (CISA known exploited). Absent = none. */
+    kev?: number;
     /** Fixable High findings. */
     high: number;
-    /** The floor it was compared against (`PLUGIN_VULN_MAX_CRITICAL`). */
-    maxCritical: number;
+    /** The floor it was compared against (`PLUGIN_VULN_MAX_FINDINGS`). */
+    maxFindings: number;
+    /**
+     * The `PLUGIN_VULN_FAIL_ON` it was gated at, when that was `high` (then
+     * `gated` counts Critical AND High findings). Absent = `critical`.
+     * Carried on the flag because the services that RENDER it (the resolver,
+     * the dashboard) do not share the plugin service's environment.
+     */
+    failOn?: 'high';
     /** At most {@link SCAN_FLAG_TOP_FINDINGS} fixable findings, Criticals first. */
     findings: PluginScanFinding[];
 }
 /**
- * `scan_summary` on every in-use version: the LAST rescan's findings, written
+ * `scan_summary` on every scanned version: the LATEST scan's findings — written
+ * by the build that established the version and rewritten by every rescan —
  * whether or not the gate tripped.
  *
  * Distinct from {@link PluginScanFlag}, which exists only while a version is over
@@ -33,37 +58,137 @@ export interface PluginScanFlag {
  * report whose job is to show Critical AND High exposure had no source to read.
  * What a report SHOWS and what a build REFUSES are different questions, and
  * conflating them meant the answer to the first was "nothing".
+ *
+ * It is also the rescan's BASELINE. "Is anything new?" is answered by diffing
+ * finding identities against the previous summary ({@link newScanFindings}),
+ * not by comparing counts: one CVE fixed and a different one published leaves
+ * the count unchanged and hides a brand-new Critical.
+ *
+ * CONTRACT — read by the reporting / exposure code in pipeline-data. Fields are
+ * only ever added; every field below is present on every summary written.
  */
 export interface PluginScanSummary {
-    /** Fixable Critical findings at the last rescan. */
+    /** Fixable Critical findings. */
     criticalFixable: number;
-    /** Fixable High findings at the last rescan. */
+    /** Fixable High findings. */
     highFixable: number;
-    /** Totals including unfixable findings, for context. */
+    /** Totals including unfixable findings. */
     critical: number;
     high: number;
-    /** At most {@link SCAN_FLAG_TOP_FINDINGS} findings, Criticals first. */
+    medium: number;
+    low: number;
+    /** KEV-listed (CISA known exploited) Critical + High findings. */
+    kev: number;
+    /**
+     * EVERY Critical and High finding — fixable AND unfixable — Criticals first,
+     * capped at {@link SCAN_SUMMARY_MAX_FINDINGS}. `truncated` says whether the
+     * cap cut it; the counts above are never capped.
+     */
     findings: PluginScanFinding[];
-    /** When the rescan that produced this ran (ISO). */
+    truncated: boolean;
+    /**
+     * Keys ({@link scanFindingKey}) of the findings a `PLUGIN_VULN_WAIVERS` entry
+     * exempted from the floor at this scan. They are still in `findings` — a
+     * waiver changes the verdict, not what the image contains.
+     */
+    waived: string[];
+    /** When this scan ran (ISO). */
     scannedAt: string;
+    /** Which path wrote it. */
+    trigger: 'build' | 'rescan' | 'promote';
     /** The image this describes. A version rebuilt on a patched base is a
      *  different artifact, so a summary without its digest cannot be trusted. */
-    imageDigest?: string;
+    imageDigest: string;
+    /**
+     * When the vulnerability DB the scan matched against was BUILT (ISO), or null
+     * when it could not be read. A scan is only as current as its DB: a clean
+     * result from a week-old DB says nothing about this week's CVEs.
+     */
+    dbBuiltAt: string | null;
+    /**
+     * Executables in the image that NO SBOM package accounts for — UPX-packed or
+     * stripped Go, Haskell, GraalVM native images, Node SEA bundles, vendored
+     * browsers. The scanner cannot see inside them, so their CVEs are invisible to
+     * every count above. Paths, sorted, capped at {@link SCAN_SUMMARY_MAX_BINARIES}.
+     * Informational: never a gate.
+     */
+    uncataloguedBinaries: string[];
 }
+/** Findings a summary itemizes. Counts are never capped; this bounds the jsonb. */
+export declare const SCAN_SUMMARY_MAX_FINDINGS = 500;
+/** Uncatalogued binaries a summary lists. */
+export declare const SCAN_SUMMARY_MAX_BINARIES = 200;
+/**
+ * A finding's identity: the advisory in a specific package version. The same
+ * CVE in two packages is two findings; the same CVE reported again after a
+ * rescan is the same one.
+ */
+export declare function scanFindingKey(f: Pick<PluginScanFinding, 'id' | 'packageName' | 'packageVersion'>): string;
+/**
+ * The Critical/High findings in `after` that the previous summary did not
+ * carry — what N31 and an advisory draft are about.
+ *
+ * No previous summary means no baseline: every finding is new. A TRUNCATED
+ * baseline knows only its first {@link SCAN_SUMMARY_MAX_FINDINGS} findings
+ * (Criticals first), so a finding missing from it is new only if the baseline
+ * provably listed every finding of that severity — otherwise it may simply have
+ * been cut, and reporting it as new would be a false alarm on every pass.
+ */
+export declare function newScanFindings(before: Pick<PluginScanSummary, 'findings' | 'truncated' | 'critical'> | null | undefined, after: readonly PluginScanFinding[]): PluginScanFinding[];
 /** Findings a flag / gate message carries. */
 export declare const SCAN_FLAG_TOP_FINDINGS = 10;
 /** Lookup / resolution warning code for a flagged version. */
 export declare const VULN_FLAGGED_WARNING = "VULN_FLAGGED";
 /**
- * `PLUGIN_VULN_MAX_CRITICAL`: the platform floor — a version with MORE fixable
- * Critical findings than this fails its build (`PLUGIN_VULN_GATE`) and is
+ * `PLUGIN_VULN_MAX_FINDINGS`: the platform floor — a version with MORE gated
+ * findings (fixable, or KEV-listed, at or above `PLUGIN_VULN_FAIL_ON`) than
+ * this fails its build (`PLUGIN_VULN_GATE`) and is
  * flagged by the rescan. Default `0`; `-1` disables the floor (and the flag).
  */
-export declare function pluginVulnMaxCritical(): number;
+export declare function pluginVulnMaxFindings(): number;
+/**
+ * The lowest severity the floor gates on — the plugin service's `--fail-on`.
+ * Only `critical` and `high` are possible: those are the severities a scan
+ * itemizes (Medium/Low are counted, never listed), and a floor can only gate on
+ * findings it can name, waive and report.
+ */
+export type PluginVulnFailOn = 'critical' | 'high';
+/**
+ * `PLUGIN_VULN_FAIL_ON` (default `critical`): the severity at and above which a
+ * fixable (or KEV-listed) finding counts against `PLUGIN_VULN_MAX_FINDINGS`.
+ * `high` gates Critical AND High. Any other value resolves to `high`, the
+ * STRICTER setting: the failure mode of a typo must be "the gate blocks more",
+ * never "the gate blocks less".
+ */
+export declare function pluginVulnFailOn(): PluginVulnFailOn;
+/** Whether a severity is at or above the gating threshold. */
+export declare function atOrAboveFailOn(severity: PluginScanFinding['severity'], failOn?: PluginVulnFailOn): boolean;
+/**
+ * The scanner's fixable count at or above the threshold — what the floor reads
+ * when a scan recorded counts but no findings to derive it from.
+ */
+export declare function gatedFixableCount(counts: {
+    vulnCriticalFixable: number | null;
+    vulnHighFixable: number | null;
+}, failOn?: PluginVulnFailOn): number;
+/** `Critical` / `Critical or High` — the gated severities, for messages. */
+export declare function failOnLabel(failOn?: PluginVulnFailOn): string;
+/**
+ * `PLUGIN_VULN_GATE_KEV` (default true): a Critical CISA lists as known
+ * exploited counts against the floor even when it has NO fix. Off, KEV findings
+ * are gated exactly like any other Critical (fixable only).
+ */
+export declare function pluginVulnGateKev(): boolean;
+/**
+ * Whether a finding counts against the floor: a fixable finding at or above
+ * `PLUGIN_VULN_FAIL_ON` (default Critical), or — under `PLUGIN_VULN_GATE_KEV`
+ * — a KEV-listed one at or above it with or without a fix.
+ */
+export declare function isGatedFinding(f: Pick<PluginScanFinding, 'severity' | 'fixedIn' | 'kev'>, kevGate?: boolean, failOn?: PluginVulnFailOn): boolean;
 /**
  * A scoped, EXPIRING exemption from the vulnerability floor for one plugin.
  *
- * `PLUGIN_VULN_MAX_CRITICAL` is the only other lever and it is far too blunt:
+ * `PLUGIN_VULN_MAX_FINDINGS` is the only other lever and it is far too blunt:
  * raising it above 0 exempts every plugin from every Critical. Some images
  * genuinely cannot reach zero — a browser-bundling test runner (artillery ships
  * Chromium through its own @playwright/browser-chromium dependency, playwright
@@ -75,9 +200,10 @@ export declare function pluginVulnMaxCritical(): number;
  * Three properties make this an exemption rather than a hole, and all three are
  * enforced below rather than documented and hoped for:
  *
- *   SCOPED    to one plugin, to named packages, AND to the system org. A new
- *             Critical in any other package still fails the gate, so a waiver
- *             cannot grow silently into "this plugin is exempt". The org bound
+ *   SCOPED    to one plugin (or, fleet-wide, to named advisories only), to
+ *             named packages/advisories, AND to the system org. A new Critical
+ *             in anything not named still fails the gate, so a waiver cannot
+ *             grow silently into "this plugin is exempt". The org bound
  *             matters because plugin names are unique per (name, version,
  *             orgId) and NOT globally: without it, any tenant could inherit an
  *             exemption by naming their plugin `artillery`.
@@ -88,15 +214,27 @@ export declare function pluginVulnMaxCritical(): number;
  *             metric, the audit record and the build message instead of
  *             vanishing from the count.
  *
- * Format — entries `;`-separated, fields `:`-separated, packages `,`-separated:
+ * Format — entries `;`-separated, fields `:`-separated, targets `,`-separated.
+ * A target is a package name (`chromium`) or an advisory id (`GO-2026-6612`),
+ * matched against the finding's package or id respectively:
  *
  *   PLUGIN_VULN_WAIVERS=artillery:2026-12-31:chromium,chrome;playwright:2026-12-31:firefox
  *
+ * FLEET-WIDE (`*` as the plugin) is for one advisory that every bundler of a
+ * toolchain inherits — a Go stdlib CVE reaches every prebuilt Go binary at once,
+ * and listing each plugin hides that it is one decision. It may name ADVISORY
+ * IDS ONLY: `*:2026-12-31:stdlib` would waive every present and future stdlib
+ * Critical in every plugin, including ones a rebuild could clear, so a package
+ * name under `*` is rejected. `*` takes no `@version` (versions are per plugin)
+ * and keeps the system-org bound and the expiry:
+ *
+ *   PLUGIN_VULN_WAIVERS=*:2026-12-31:GO-2026-6612,GO-2026-6604
+ *
  * A malformed entry is DROPPED, never treated as a wildcard: the failure mode
  * of a typo must be "the gate still blocks", not "everything is waived".
  */
 export interface VulnWaiver {
-    /** Plugin name the waiver applies to (exact match). */
+    /** Plugin name the waiver applies to (exact match), or {@link WAIVE_ALL_PLUGINS}. */
     plugin: string;
     /**
      * Plugin version the waiver is limited to, or null for every version.
@@ -109,9 +247,14 @@ export interface VulnWaiver {
     version: string | null;
     /** Inclusive expiry (UTC date). After it the entry has no effect. */
     expires: Date;
-    /** Package names whose findings are exempt. Never empty — see parseVulnWaivers. */
+    /**
+     * Package names and/or advisory ids whose findings are exempt. Never empty —
+     * see parseVulnWaivers. Advisory ids only when `plugin` is `*`.
+     */
     packages: string[];
 }
+/** The `plugin` of a fleet-wide waiver. Advisory ids only — see VulnWaiver. */
+export declare const WAIVE_ALL_PLUGINS = "*";
 /** A dropped entry and why, so the operator can be told instead of guessing. */
 export interface VulnWaiverProblem {
     entry: string;
@@ -142,37 +285,46 @@ export interface WaiverOutcome {
     counted: PluginScanFinding[];
     /** Findings an unexpired waiver exempted (empty when none applied). */
     waived: PluginScanFinding[];
+    /** The entries that exempted at least one finding — what "this waiver is still doing something" is measured by. */
+    matched: VulnWaiver[];
 }
+/** One waiver entry's identity: the plugin it names (with its pin) and its targets. */
+export declare function vulnWaiverLabels(w: Pick<VulnWaiver, 'plugin' | 'version' | 'packages'>): {
+    plugin: string;
+    targets: string;
+};
 /**
  * Split findings into what still counts and what an unexpired waiver exempts.
  *
- * Matching is on the package name a waiver names, case-insensitively, and only
- * for findings that are FIXABLE — an unfixable finding never counted toward the
- * floor, so "waiving" it would overstate what the waiver does.
+ * Matching is on the package name or advisory id a waiver names,
+ * case-insensitively, and only for findings that are GATED
+ * ({@link isGatedFinding}) — an ungated finding never counted toward the floor,
+ * so "waiving" it would overstate what the waiver does.
+ *
+ * A KEV-listed finding is exempted by an ADVISORY-ID target only, never by a
+ * package name. `artillery:…:chromium` is a judgement about Chromium's ordinary
+ * churn; it was not written about, and must not silently cover, the one
+ * Chromium CVE that is being exploited today. Naming that CVE is the deliberate
+ * act an exemption for it requires.
  */
 export declare function applyVulnWaivers(pluginName: string, findings: readonly PluginScanFinding[], waivers?: readonly VulnWaiver[], now?: Date, orgId?: string, pluginVersion?: string): WaiverOutcome;
-/** Whether `fixableCritical` breaks the platform floor (never, when disabled). */
-export declare function exceedsVulnFloor(fixableCritical: number | null | undefined, max?: number): boolean;
-/**
- * `PLUGIN_BLOCK_ON_NEW_CRITICAL` (default false): resolution SKIPS flagged
- * versions for ranges and the default (falling back to the newest unflagged
- * one), and an exact pin to a flagged version is refused 409
- * `PLUGIN_VERSION_VULN_BLOCKED`. Off: flagged versions resolve with a
- * `VULN_FLAGGED` warning.
- */
-export declare function blockOnNewCritical(): boolean;
+/** Whether `gatedCritical` breaks the platform floor (never, when disabled). */
+export declare function exceedsVulnFloor(gated: number | null | undefined, max?: number): boolean;
 /** `pkg@1.2.3 → 1.2.4` / `pkg@1.2.3 (no fix)`. */
 export declare function describeFix(f: Pick<PluginScanFinding, 'packageName' | 'packageVersion' | 'fixedIn'>): string;
 /** `CVE-1 (openssl@3.0.1 → 3.0.2); CVE-2 (…)` for the first `limit` findings. */
 export declare function describeFindings(findings: readonly PluginScanFinding[], limit?: number): string;
 /** The warning text for a flagged version: `x@v has N fixable Critical findings — rebuild or upgrade`. */
-export declare function vulnFlaggedMessage(ref: string, flag: Pick<PluginScanFlag, 'critical'>): string;
+export declare function vulnFlaggedMessage(ref: string, flag: Pick<PluginScanFlag, 'gated' | 'kev' | 'failOn'>): string;
 /** A `VULN_FLAGGED` lookup warning (the lookup envelope's `warnings[]` entry). */
 export interface VulnFlaggedWarning {
     code: typeof VULN_FLAGGED_WARNING;
+    /** `critical` when a gated finding is on CISA KEV, else `error` (a flag never refuses anything). */
+    severity: 'error' | 'critical';
     plugin: string;
     version: string;
-    critical: number;
+    /** The flag's gated count (see {@link PluginScanFlag.gated}). */
+    gated: number;
     high: number;
     message: string;
     /** Top fixable findings with their fixed versions. */
@@ -180,7 +332,5 @@ export interface VulnFlaggedWarning {
 }
 /** Build the `VULN_FLAGGED` warning for `plugin@version`. */
 export declare function vulnFlaggedWarning(plugin: string, version: string, flag: PluginScanFlag): VulnFlaggedWarning;
-/** The 409 message for an exact pin to a flagged version while blocking. */
-export declare function vulnBlockedMessage(plugin: string, version: string, flag: PluginScanFlag): string;
 /** Narrow an unknown `scan_flag` jsonb value. */
 export declare function asScanFlag(value: unknown): PluginScanFlag | null;