@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/services/version-vuln-policy.js

@@ -0,0 +1,242 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * THE vulnerability assessment of one resolved plugin version, for one org (and,
+ * optionally, one pipeline's risk acceptance). One function, three callers:
+ * `/plugins/lookup` (what synth pins), `/plugins/runtime-check` (what a running
+ * pipeline is about to execute) and the pipeline service's save-time contract
+ * check. Three copies of these rules drifted once already.
+ *
+ * Vulnerability state NEVER refuses a pipeline — not its save, its synth, its
+ * deploy or its run. What it produces is SEVERITY-GRADED warnings (and, from the
+ * callers, notifications to the pipeline's owners). The grades:
+ *
+ *   critical — a finding on the CISA Known Exploited Vulnerabilities list
+ *   error    — the version is FLAGGED (gated Criticals over the platform floor),
+ *              it has fixable Critical findings, or an org compliance rule on the
+ *              vulnerability attributes is in BLOCK mode and fails
+ *   warning  — fixable High findings over the org's `warnFixableHigh`, a version
+ *              never scanned, a scan older than `PLUGIN_SCAN_STALE_HOURS`, or a
+ *              compliance rule in WARN mode
+ *   info     — what a reader may want to know but need not act on
+ *
+ * A PIPELINE's active risk acceptance (`plugin_vuln_exposure`, triaged `accepted`
+ * with a reason and an expiry) downgrades the warnings about the findings it
+ * ACCEPTED to `info` ("accepted until …") — never one about a finding that
+ * appeared since, never a KEV one unless the acceptance said `kev: true`, and
+ * never the scan-freshness or compliance warnings (neither is about a finding).
+ */
+import { createComplianceClient } from './compliance-client.js';
+import { getServiceAuthHeader } from '../middleware/service-tokens.js';
+import { isSystemOrgId } from '../middleware/system-org.js';
+import { asScanFlag, describeFindings, failOnLabel, isGatedFinding, pluginVulnGateKev, scanFindingKey, } from '../types/plugin-scan.js';
+import { envInt } from '../utils/env.js';
+import { derivePluginImageCompliance, pluginRunsOwnImage } from '../utils/plugin-compliance.js';
+import { errorMessage } from '../utils/response.js';
+/** How loud a warning is, quietest first. */
+export const VULN_SEVERITIES = ['info', 'warning', 'error', 'critical'];
+/** The louder of two severities. */
+export function maxSeverity(a, b) {
+    return VULN_SEVERITIES.indexOf(a) >= VULN_SEVERITIES.indexOf(b) ? a : b;
+}
+/** Whether `s` is at least `floor`. */
+export function severityAtLeast(s, floor) {
+    return VULN_SEVERITIES.indexOf(s) >= VULN_SEVERITIES.indexOf(floor);
+}
+/** `PLUGIN_SCAN_STALE_HOURS` (default 72): a scan older than this is stale. */
+export function scanStaleHours() {
+    return envInt('PLUGIN_SCAN_STALE_HOURS', 72, { min: 1 });
+}
+const toDate = (v) => {
+    if (!v)
+        return null;
+    const d = v instanceof Date ? v : new Date(String(v));
+    return Number.isNaN(d.getTime()) ? null : d;
+};
+const summaryOf = (record) => (record.scanSummary && typeof record.scanSummary === 'object' && !Array.isArray(record.scanSummary)
+    ? record.scanSummary : null);
+/**
+ * When the version was last scanned: the later of the build-time `scannedAt` and
+ * the nightly rescan's `scan_summary.scannedAt`. Null = never.
+ */
+export function lastScannedAt(record) {
+    const build = toDate(record.scannedAt);
+    const summary = toDate(summaryOf(record)?.scannedAt);
+    if (!build)
+        return summary;
+    if (!summary)
+        return build;
+    return summary > build ? summary : build;
+}
+/** Whether the record runs a BUILT image of its own — the only thing a scan applies to. */
+function hasImage(record) {
+    return pluginRunsOwnImage(record) && typeof record.imageDigest === 'string' && record.imageDigest.length > 0;
+}
+/** Freshness of a version's scan: `none` (no image to scan), `unscanned`, `stale` or `fresh`. */
+export function scanFreshness(record, now = new Date()) {
+    if (!hasImage(record))
+        return { state: 'none', scannedAt: null };
+    const at = lastScannedAt(record);
+    if (!at)
+        return { state: 'unscanned', scannedAt: null };
+    return { state: now.getTime() - at.getTime() > scanStaleHours() * 3_600_000 ? 'stale' : 'fresh', scannedAt: at };
+}
+/** `UNSCANNED` / `SCAN_STALE` for a resolved version (empty for a fresh scan or an image-less plugin). */
+export function scanWarnings(record, now = new Date()) {
+    const ref = `${record.name}@${record.version}`;
+    const f = scanFreshness(record, now);
+    if (f.state === 'unscanned') {
+        return [{ code: 'UNSCANNED', severity: 'warning', message: `Plugin ${ref} has never been scanned for vulnerabilities; nothing is known about what its image contains.` }];
+    }
+    if (f.state === 'stale') {
+        const hours = scanStaleHours();
+        return [{
+                code: 'SCAN_STALE',
+                severity: 'warning',
+                message: `Plugin ${ref} was last scanned ${f.scannedAt.toISOString()}, more than ${hours}h ago; findings published since are not reflected.`,
+                scannedAt: f.scannedAt.toISOString(),
+                staleAfterHours: hours,
+            }];
+    }
+    return [];
+}
+/** The normalized scan facts of a resolved record. A summary describing another image is ignored. */
+export function versionScanFacts(record) {
+    const flag = record.scanFlaggedAt ? asScanFlag(record.scanFlag) : null;
+    const raw = summaryOf(record);
+    const digest = typeof raw?.imageDigest === 'string' ? raw.imageDigest : null;
+    const summary = raw && (digest === null || !record.imageDigest || digest === record.imageDigest) ? raw : null;
+    const findings = summary && Array.isArray(summary.findings)
+        ? summary.findings.filter((f) => f && typeof f.id === 'string').map((f) => ({ ...f, fixedIn: Array.isArray(f.fixedIn) ? f.fixedIn : [] }))
+        : (flag?.findings ?? []);
+    const num = (v) => (typeof v === 'number' ? v : null);
+    const kevCount = Math.max(num(summary?.kev) ?? 0, flag?.kev ?? 0, findings.filter((f) => f.kev === true).length);
+    return {
+        flagged: flag !== null,
+        flag,
+        criticalFixable: num(summary?.criticalFixable),
+        highFixable: num(summary?.highFixable) ?? num(record.vulnHighFixable),
+        critical: num(summary?.critical),
+        high: num(summary?.high),
+        kev: kevCount,
+        findings,
+        truncated: summary?.truncated === true,
+        scannedAt: lastScannedAt(record),
+    };
+}
+/**
+ * Whether `acceptance` covers EVERY one of `findings` (by finding key), and its
+ * KEV ones only when it accepted KEV. An empty set is never "covered": with
+ * nothing itemized there is nothing an acceptance can be shown to describe.
+ */
+function covers(acceptance, findings, truncated) {
+    if (!acceptance || truncated || findings.length === 0)
+        return false;
+    const keys = new Set(acceptance.findingKeys);
+    return findings.every((f) => keys.has(scanFindingKey(f)) && (f.kev !== true || acceptance.kev));
+}
+/** The loudest severity of `warnings`, or null for none. */
+export function severityOf(warnings) {
+    return warnings.reduce((acc, w) => (w.severity ? (acc ? maxSeverity(acc, w.severity) : w.severity) : acc), null);
+}
+/**
+ * The assessment of one resolved version (see the module doc). Never throws and
+ * never refuses: a compliance outage adds an `info` `COMPLIANCE_UNAVAILABLE`.
+ */
+export async function assessVersionVulns(input) {
+    const { orgId, record, policy, acceptance } = input;
+    const now = input.now ?? new Date();
+    const ref = `${record.name}@${record.version}`;
+    const facts = versionScanFacts(record);
+    const warnings = [...scanWarnings(record, now)];
+    const accepted = new Set();
+    const way = input.suggestedVersion ? ` Move to ${record.name}@${input.suggestedVersion}.` : '';
+    const suggested = input.suggestedVersion ? { suggestedVersion: input.suggestedVersion } : {};
+    const until = toDate(acceptance?.acceptedUntil)?.toISOString() ?? null;
+    /** Push a finding warning — or, when the pipeline accepted exactly those findings, its `info` downgrade. */
+    const finding = (code, severity, message, findings, extra = {}) => {
+        if (covers(acceptance, findings, facts.truncated)) {
+            for (const f of findings)
+                accepted.add(scanFindingKey(f));
+            warnings.push({
+                code: 'VULN_ACCEPTED',
+                severity: 'info',
+                message: `${message} Accepted for this pipeline${until ? ` until ${until}` : ''}.`,
+                findings: findings.map(scanFindingKey),
+                acceptedUntil: until,
+                kev: acceptance?.kev ?? false,
+                covers: code,
+            });
+            return;
+        }
+        warnings.push({ code, severity, message: `${message}${way}`, findings: findings.slice(0, 10), ...suggested, ...extra });
+    };
+    const kevFindings = facts.findings.filter((f) => f.kev === true);
+    if (facts.kev > 0) {
+        finding('VULN_KEV', 'critical', `${ref} has ${facts.kev} finding${facts.kev === 1 ? '' : 's'} on the CISA Known Exploited Vulnerabilities list${kevFindings.length ? `: ${describeFindings(kevFindings)}` : ''}.`, kevFindings);
+    }
+    const flag = facts.flag;
+    if (flag) {
+        const gated = facts.findings.filter((f) => isGatedFinding(f, pluginVulnGateKev(), flag.failOn ?? 'critical'));
+        finding('VULN_FLAGGED', 'error', `${ref} is flagged: a rescan found ${flag.gated} gated ${failOnLabel(flag.failOn ?? 'critical')} finding${flag.gated === 1 ? '' : 's'} over the platform limit${flag.findings.length ? ` (fix: ${describeFindings(flag.findings)})` : ''}.`, gated.length > 0 ? gated : flag.findings, { plugin: record.name, version: record.version, gated: flag.gated, high: flag.high });
+    }
+    else if ((facts.criticalFixable ?? 0) > 0) {
+        const crits = facts.findings.filter((f) => f.severity === 'critical' && f.fixedIn.length > 0);
+        finding('VULN_CRITICAL_FIXABLE', 'error', `${ref} has ${facts.criticalFixable} fixable Critical finding${facts.criticalFixable === 1 ? '' : 's'}${crits.length ? `: ${describeFindings(crits)}` : ''}.`, crits);
+    }
+    const highFixable = facts.highFixable ?? 0;
+    if (highFixable > 0) {
+        const highs = facts.findings.filter((f) => f.severity === 'high' && f.fixedIn.length > 0);
+        const over = policy.warnFixableHigh !== null && highFixable > policy.warnFixableHigh;
+        finding('VULN_HIGH_FIXABLE', over ? 'warning' : 'info', `${ref} has ${highFixable} fixable High finding${highFixable === 1 ? '' : 's'}${over ? `, over your organization's threshold of ${policy.warnFixableHigh}` : ''}.`, highs);
+    }
+    if (input.compliance !== false)
+        warnings.push(...await complianceVulnWarnings(orgId, record));
+    return { severity: severityOf(warnings), warnings, acceptedFindings: [...accepted], facts };
+}
+/** The compliance attributes a plugin's vulnerability rules read. */
+const VULN_RULE_FIELDS = new Set(['scanned', 'vulnCritical', 'vulnHigh', 'vulnMedium', 'vulnLow', 'vulnCriticalFixable', 'vulnHighFixable']);
+const fieldRoot = (field) => field.split(/[.[]/)[0] ?? field;
+let complianceClient = null;
+/** Test hook: replace the compliance client the assessment's compliance layer calls. */
+export function setVulnPolicyComplianceClientForTests(client) {
+    complianceClient = client;
+}
+/**
+ * The org's plugin compliance rules on the vulnerability attributes, evaluated
+ * against the RESOLVED version — the org's own row, its parent's, a system
+ * plugin or an installed marketplace version alike. A BLOCK-mode rule that fails
+ * is an `error`, a WARN-mode one a `warning`; neither refuses anything here
+ * (vulnerability state never stops a pipeline).
+ *
+ * Only the vuln / scanned rules count here: the plugin's other rules (tags,
+ * secrets, commands …) describe how a plugin is AUTHORED, which is its owner's
+ * concern at upload, not the consumer's at resolution — and a system plugin would
+ * otherwise fail every tenant's authoring rules.
+ */
+async function complianceVulnWarnings(orgId, record) {
+    if (isSystemOrgId(orgId) || !hasImage(record))
+        return [];
+    const facts = derivePluginImageCompliance(record, null).attributes;
+    const attributes = { name: record.name, version: record.version, ...facts };
+    try {
+        complianceClient ??= createComplianceClient();
+        const auth = getServiceAuthHeader({ serviceName: 'plugin', orgId, role: 'member' });
+        const result = await complianceClient.dryRunPlugin(orgId, attributes, auth);
+        const relevant = (v) => VULN_RULE_FIELDS.has(fieldRoot(v.field));
+        const as = (mode) => (v) => ({
+            code: 'COMPLIANCE_VULN_RULE',
+            severity: mode === 'block' ? 'error' : 'warning',
+            message: `${record.name}@${record.version}: ${v.message}`,
+            ruleId: v.ruleId,
+            ruleName: v.ruleName,
+            field: v.field,
+            mode,
+        });
+        return [...result.violations.filter(relevant).map(as('block')), ...result.warnings.filter(relevant).map(as('warn'))];
+    }
+    catch (err) {
+        return [{ code: 'COMPLIANCE_UNAVAILABLE', severity: 'info', message: `Your organization's plugin vulnerability rules could not be checked for ${record.name}@${record.version} (${errorMessage(err)}).` }];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version-vuln-policy.js","sourceRoot":"","sources":["../../src/services/version-vuln-policy.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,sBAAsB,EAA4B,MAAM,wBAAwB,CAAC;AAC1F,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EACL,UAAU,EAAE,gBAAgB,EAAE,WAAW,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,GAE7F,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,2BAA2B,EAAE,kBAAkB,EAAwD,MAAM,+BAA+B,CAAC;AACtJ,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,6CAA6C;AAC7C,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,CAAU,CAAC;AAGjF,oCAAoC;AACpC,MAAM,UAAU,WAAW,CAAC,CAAe,EAAE,CAAe;IAC1D,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1E,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,eAAe,CAAC,CAAe,EAAE,KAAmB;IAClE,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AACtE,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,cAAc;IAC5B,OAAO,MAAM,CAAC,yBAAyB,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AAC3D,CAAC;AAaD,MAAM,MAAM,GAAG,CAAC,CAAU,EAAe,EAAE;IACzC,IAAI,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACpB,MAAM,CAAC,GAAG,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9C,CAAC,CAAC;AAEF,MAAM,SAAS,GAAG,CAAC,MAA0C,EAAkC,EAAE,CAC/F,CAAC,MAAM,CAAC,WAAW,IAAI,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC;IACjG,CAAC,CAAC,MAAM,CAAC,WAAsC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAE5D;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,MAAwD;IACpF,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC;IACrD,IAAI,CAAC,KAAK;QAAE,OAAO,OAAO,CAAC;IAC3B,IAAI,CAAC,OAAO;QAAE,OAAO,KAAK,CAAC;IAC3B,OAAO,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC;AAC3C,CAAC;AAED,2FAA2F;AAC3F,SAAS,QAAQ,CAAC,MAAqB;IACrC,OAAO,kBAAkB,CAAC,MAAM,CAAC,IAAI,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ,IAAI,MAAM,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;AAC/G,CAAC;AAED,iGAAiG;AACjG,MAAM,UAAU,aAAa,CAAC,MAAqB,EAAE,GAAG,GAAG,IAAI,IAAI,EAAE;IACnE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IACjE,MAAM,EAAE,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE;QAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IACxD,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,cAAc,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;AACnH,CAAC;AAuBD,0GAA0G;AAC1G,MAAM,UAAU,YAAY,CAAC,MAAqB,EAAE,GAAG,GAAG,IAAI,IAAI,EAAE;IAClE,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;IAC/C,MAAM,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACrC,IAAI,CAAC,CAAC,KAAK,KAAK,WAAW,EAAE,CAAC;QAC5B,OAAO,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,GAAG,8FAA8F,EAAE,CAAC,CAAC;IAC5K,CAAC;IACD,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,cAAc,EAAE,CAAC;QAC/B,OAAO,CAAC;gBACN,IAAI,EAAE,YAAY;gBAClB,QAAQ,EAAE,SAAS;gBACnB,OAAO,EAAE,UAAU,GAAG,qBAAqB,CAAC,CAAC,SAAU,CAAC,WAAW,EAAE,eAAe,KAAK,oDAAoD;gBAC7I,SAAS,EAAE,CAAC,CAAC,SAAU,CAAC,WAAW,EAAE;gBACrC,eAAe,EAAE,KAAK;aACvB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAsCD,qGAAqG;AACrG,MAAM,UAAU,gBAAgB,CAAC,MAAqB;IACpD,MAAM,IAAI,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACvE,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAC9B,MAAM,MAAM,GAAG,OAAO,GAAG,EAAE,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7E,MAAM,OAAO,GAAG,GAAG,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,IAAI,MAAM,KAAK,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;IAC9G,MAAM,QAAQ,GAAG,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;QACzD,CAAC,CAAE,OAAO,CAAC,QAAgC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACnK,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;IAC3B,MAAM,GAAG,GAAG,CAAC,CAAU,EAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC9E,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;IACjH,OAAO;QACL,OAAO,EAAE,IAAI,KAAK,IAAI;QACtB,IAAI;QACJ,eAAe,EAAE,GAAG,CAAC,OAAO,EAAE,eAAe,CAAC;QAC9C,WAAW,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,eAAe,CAAC;QACrE,QAAQ,EAAE,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC;QAChC,IAAI,EAAE,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC;QACxB,GAAG,EAAE,QAAQ;QACb,QAAQ;QACR,SAAS,EAAE,OAAO,EAAE,SAAS,KAAK,IAAI;QACtC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC;KACjC,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,MAAM,CAAC,UAA6C,EAAE,QAAsC,EAAE,SAAkB;IACvH,IAAI,CAAC,UAAU,IAAI,SAAS,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACpE,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAC7C,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;AAClG,CAAC;AA0BD,4DAA4D;AAC5D,MAAM,UAAU,UAAU,CAAC,QAAoD;IAC7E,OAAO,QAAQ,CAAC,MAAM,CAAsB,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;AACxI,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,KAAuB;IAC9D,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IACpD,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;IACpC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;IAC/C,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,QAAQ,GAAkB,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAC/D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,MAAM,GAAG,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,YAAY,MAAM,CAAC,IAAI,IAAI,KAAK,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/F,MAAM,SAAS,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,KAAK,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7F,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,EAAE,WAAW,EAAE,IAAI,IAAI,CAAC;IAEvE,4GAA4G;IAC5G,MAAM,OAAO,GAAG,CAAC,IAAiF,EAAE,QAAsB,EAAE,OAAe,EAAE,QAA6B,EACxK,KAAK,GAAyE,EAAE,EAAE,EAAE;QACpF,IAAI,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YAClD,KAAK,MAAM,CAAC,IAAI,QAAQ;gBAAE,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1D,QAAQ,CAAC,IAAI,CAAC;gBACZ,IAAI,EAAE,eAAe;gBACrB,QAAQ,EAAE,MAAM;gBAChB,OAAO,EAAE,GAAG,OAAO,8BAA8B,KAAK,CAAC,CAAC,CAAC,UAAU,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG;gBAClF,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC;gBACtC,aAAa,EAAE,KAAK;gBACpB,GAAG,EAAE,UAAU,EAAE,GAAG,IAAI,KAAK;gBAC7B,MAAM,EAAE,IAAI;aACb,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,GAAG,EAAE,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,SAAS,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;IAC1H,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC;IACjE,IAAI,KAAK,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;QAClB,OAAO,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,GAAG,QAAQ,KAAK,CAAC,GAAG,WAAW,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,oDAAoD,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,gBAAgB,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC;IAClO,CAAC;IACD,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACxB,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE,IAAI,CAAC,MAAM,IAAI,UAAU,CAAC,CAAC,CAAC;QAC9G,OAAO,CAAC,cAAc,EAAE,OAAO,EAAE,GAAG,GAAG,+BAA+B,IAAI,CAAC,KAAK,UAAU,WAAW,CAAC,IAAI,CAAC,MAAM,IAAI,UAAU,CAAC,WAAW,IAAI,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,2BAA2B,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAC1Q,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IACpI,CAAC;SAAM,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;QAC5C,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,UAAU,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC9F,OAAO,CAAC,uBAAuB,EAAE,OAAO,EAAE,GAAG,GAAG,QAAQ,KAAK,CAAC,eAAe,4BAA4B,KAAK,CAAC,eAAe,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IAClN,CAAC;IACD,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,IAAI,CAAC,CAAC;IAC3C,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;QACpB,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC1F,MAAM,IAAI,GAAG,MAAM,CAAC,eAAe,KAAK,IAAI,IAAI,WAAW,GAAG,MAAM,CAAC,eAAe,CAAC;QACrF,OAAO,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,EACpD,GAAG,GAAG,QAAQ,WAAW,wBAAwB,WAAW,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,2CAA2C,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IAC/K,CAAC;IAED,IAAI,KAAK,CAAC,UAAU,KAAK,KAAK;QAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,MAAM,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9F,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC;AAC9F,CAAC;AAED,qEAAqE;AACrE,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,EAAE,qBAAqB,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAE7I,MAAM,SAAS,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC;AAI7E,IAAI,gBAAgB,GAA4B,IAAI,CAAC;AAErD,wFAAwF;AACxF,MAAM,UAAU,qCAAqC,CAAC,MAA+B;IACnF,gBAAgB,GAAG,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,KAAK,UAAU,sBAAsB,CAAC,KAAa,EAAE,MAAqB;IACxE,IAAI,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,EAAE,CAAC;IACzD,MAAM,KAAK,GAAG,2BAA2B,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,UAAU,CAAC;IACnE,MAAM,UAAU,GAA+B,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,GAAG,KAAK,EAAE,CAAC;IACxG,IAAI,CAAC;QACH,gBAAgB,KAAK,sBAAsB,EAAE,CAAC;QAC9C,MAAM,IAAI,GAAG,oBAAoB,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QACpF,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,YAAY,CAAC,KAAK,EAAE,UAAqC,EAAE,IAAI,CAAC,CAAC;QACvG,MAAM,QAAQ,GAAG,CAAC,CAAsB,EAAE,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QACtF,MAAM,EAAE,GAAG,CAAC,IAAsB,EAAE,EAAE,CAAC,CAAC,CAAsB,EAAe,EAAE,CAAC,CAAC;YAC/E,IAAI,EAAE,sBAAsB;YAC5B,QAAQ,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;YAChD,OAAO,EAAE,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,EAAE;YACzD,MAAM,EAAE,CAAC,CAAC,MAAM;YAChB,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,KAAK,EAAE,CAAC,CAAC,KAAK;YACd,IAAI;SACL,CAAC,CAAC;QACH,OAAO,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACvH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,EAAE,IAAI,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,2EAA2E,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,KAAK,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7M,CAAC;AACH,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * THE vulnerability assessment of one resolved plugin version, for one org (and,\n * optionally, one pipeline's risk acceptance). One function, three callers:\n * `/plugins/lookup` (what synth pins), `/plugins/runtime-check` (what a running\n * pipeline is about to execute) and the pipeline service's save-time contract\n * check. Three copies of these rules drifted once already.\n *\n * Vulnerability state NEVER refuses a pipeline — not its save, its synth, its\n * deploy or its run. What it produces is SEVERITY-GRADED warnings (and, from the\n * callers, notifications to the pipeline's owners). The grades:\n *\n *   critical — a finding on the CISA Known Exploited Vulnerabilities list\n *   error    — the version is FLAGGED (gated Criticals over the platform floor),\n *              it has fixable Critical findings, or an org compliance rule on the\n *              vulnerability attributes is in BLOCK mode and fails\n *   warning  — fixable High findings over the org's `warnFixableHigh`, a version\n *              never scanned, a scan older than `PLUGIN_SCAN_STALE_HOURS`, or a\n *              compliance rule in WARN mode\n *   info     — what a reader may want to know but need not act on\n *\n * A PIPELINE's active risk acceptance (`plugin_vuln_exposure`, triaged `accepted`\n * with a reason and an expiry) downgrades the warnings about the findings it\n * ACCEPTED to `info` (\"accepted until …\") — never one about a finding that\n * appeared since, never a KEV one unless the acceptance said `kev: true`, and\n * never the scan-freshness or compliance warnings (neither is about a finding).\n */\n\nimport { createComplianceClient, type ComplianceViolation } from './compliance-client.js';\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport { isSystemOrgId } from '../middleware/system-org.js';\nimport {\n  asScanFlag, describeFindings, failOnLabel, isGatedFinding, pluginVulnGateKev, scanFindingKey,\n  type PluginScanFinding, type PluginScanFlag,\n} from '../types/plugin-scan.js';\nimport { envInt } from '../utils/env.js';\nimport { derivePluginImageCompliance, pluginRunsOwnImage, type PluginComplianceAttributes, type PluginImageRow } from '../utils/plugin-compliance.js';\nimport { errorMessage } from '../utils/response.js';\n\n/** How loud a warning is, quietest first. */\nexport const VULN_SEVERITIES = ['info', 'warning', 'error', 'critical'] as const;\nexport type VulnSeverity = typeof VULN_SEVERITIES[number];\n\n/** The louder of two severities. */\nexport function maxSeverity(a: VulnSeverity, b: VulnSeverity): VulnSeverity {\n  return VULN_SEVERITIES.indexOf(a) >= VULN_SEVERITIES.indexOf(b) ? a : b;\n}\n\n/** Whether `s` is at least `floor`. */\nexport function severityAtLeast(s: VulnSeverity, floor: VulnSeverity): boolean {\n  return VULN_SEVERITIES.indexOf(s) >= VULN_SEVERITIES.indexOf(floor);\n}\n\n/** `PLUGIN_SCAN_STALE_HOURS` (default 72): a scan older than this is stale. */\nexport function scanStaleHours(): number {\n  return envInt('PLUGIN_SCAN_STALE_HOURS', 72, { min: 1 });\n}\n\n/** The scan-related fields of a resolved record (an org row or a listed record). */\nexport interface ScannedRecord extends PluginImageRow {\n  name: string;\n  version: string;\n  scannedAt?: Date | string | null;\n  scanSummary?: unknown;\n  scanFlaggedAt?: Date | string | null;\n  scanFlag?: unknown;\n  vulnHighFixable?: unknown;\n}\n\nconst toDate = (v: unknown): Date | null => {\n  if (!v) return null;\n  const d = v instanceof Date ? v : new Date(String(v));\n  return Number.isNaN(d.getTime()) ? null : d;\n};\n\nconst summaryOf = (record: Pick<ScannedRecord, 'scanSummary'>): Record<string, unknown> | null =>\n  (record.scanSummary && typeof record.scanSummary === 'object' && !Array.isArray(record.scanSummary)\n    ? record.scanSummary as Record<string, unknown> : null);\n\n/**\n * When the version was last scanned: the later of the build-time `scannedAt` and\n * the nightly rescan's `scan_summary.scannedAt`. Null = never.\n */\nexport function lastScannedAt(record: Pick<ScannedRecord, 'scannedAt' | 'scanSummary'>): Date | null {\n  const build = toDate(record.scannedAt);\n  const summary = toDate(summaryOf(record)?.scannedAt);\n  if (!build) return summary;\n  if (!summary) return build;\n  return summary > build ? summary : build;\n}\n\n/** Whether the record runs a BUILT image of its own — the only thing a scan applies to. */\nfunction hasImage(record: ScannedRecord): boolean {\n  return pluginRunsOwnImage(record) && typeof record.imageDigest === 'string' && record.imageDigest.length > 0;\n}\n\n/** Freshness of a version's scan: `none` (no image to scan), `unscanned`, `stale` or `fresh`. */\nexport function scanFreshness(record: ScannedRecord, now = new Date()): { state: 'none' | 'unscanned' | 'stale' | 'fresh'; scannedAt: Date | null } {\n  if (!hasImage(record)) return { state: 'none', scannedAt: null };\n  const at = lastScannedAt(record);\n  if (!at) return { state: 'unscanned', scannedAt: null };\n  return { state: now.getTime() - at.getTime() > scanStaleHours() * 3_600_000 ? 'stale' : 'fresh', scannedAt: at };\n}\n\n/** One severity-graded vulnerability warning. */\nexport type VulnWarning =\n  | {\n    code: 'VULN_KEV' | 'VULN_FLAGGED' | 'VULN_CRITICAL_FIXABLE' | 'VULN_HIGH_FIXABLE';\n    severity: VulnSeverity;\n    message: string;\n    findings: PluginScanFinding[];\n    suggestedVersion?: string;\n    /** `VULN_FLAGGED` carries the flag's counts (the shape the rescan-flag warning always had). */\n    plugin?: string;\n    version?: string;\n    /** The flag's gated count (findings at or above its `failOn`). */\n    gated?: number;\n    high?: number;\n  }\n  | { code: 'VULN_ACCEPTED'; severity: 'info'; message: string; findings: string[]; acceptedUntil: string | null; kev: boolean; covers: string }\n  | { code: 'UNSCANNED'; severity: VulnSeverity; message: string }\n  | { code: 'SCAN_STALE'; severity: VulnSeverity; message: string; scannedAt: string; staleAfterHours: number }\n  | { code: 'COMPLIANCE_VULN_RULE'; severity: VulnSeverity; message: string; ruleId: string; ruleName: string; field: string; mode: 'block' | 'warn' }\n  | { code: 'COMPLIANCE_UNAVAILABLE'; severity: VulnSeverity; message: string };\n\n/** `UNSCANNED` / `SCAN_STALE` for a resolved version (empty for a fresh scan or an image-less plugin). */\nexport function scanWarnings(record: ScannedRecord, now = new Date()): VulnWarning[] {\n  const ref = `${record.name}@${record.version}`;\n  const f = scanFreshness(record, now);\n  if (f.state === 'unscanned') {\n    return [{ code: 'UNSCANNED', severity: 'warning', message: `Plugin ${ref} has never been scanned for vulnerabilities; nothing is known about what its image contains.` }];\n  }\n  if (f.state === 'stale') {\n    const hours = scanStaleHours();\n    return [{\n      code: 'SCAN_STALE',\n      severity: 'warning',\n      message: `Plugin ${ref} was last scanned ${f.scannedAt!.toISOString()}, more than ${hours}h ago; findings published since are not reflected.`,\n      scannedAt: f.scannedAt!.toISOString(),\n      staleAfterHours: hours,\n    }];\n  }\n  return [];\n}\n\n/** The vulnerability fields of an org's consumption policy (pipeline-data's `ConsumptionPolicy` satisfies it). */\nexport interface VulnConsumptionPolicy {\n  /** Fixable High findings above this many raise a `warning`; null = never (they stay `info`). */\n  warnFixableHigh: number | null;\n}\n\n/**\n * A pipeline's ACTIVE risk acceptance of one version / image: the finding keys\n * ({@link scanFindingKey}) it accepted, whether it accepted KEV findings, and\n * until when. Built by pipeline-data from `plugin_vuln_exposure`.\n */\nexport interface VulnAcceptance {\n  findingKeys: readonly string[];\n  kev: boolean;\n  acceptedUntil: Date | string | null;\n}\n\n/** What a version's stored scan says, normalized from `scan_summary` (for its image) and `scan_flag`. */\nexport interface VersionScanFacts {\n  flagged: boolean;\n  flag: PluginScanFlag | null;\n  /** Fixable Critical / High findings (null = not known). */\n  criticalFixable: number | null;\n  highFixable: number | null;\n  /** Totals including unfixable findings (null = not known). */\n  critical: number | null;\n  high: number | null;\n  /** KEV-listed Critical + High findings. */\n  kev: number;\n  /** Every Critical/High finding the scan itemized (the summary's list, else the flag's). */\n  findings: PluginScanFinding[];\n  /** The summary cut its findings list — a subset check over it cannot be trusted. */\n  truncated: boolean;\n  scannedAt: Date | null;\n}\n\n/** The normalized scan facts of a resolved record. A summary describing another image is ignored. */\nexport function versionScanFacts(record: ScannedRecord): VersionScanFacts {\n  const flag = record.scanFlaggedAt ? asScanFlag(record.scanFlag) : null;\n  const raw = summaryOf(record);\n  const digest = typeof raw?.imageDigest === 'string' ? raw.imageDigest : null;\n  const summary = raw && (digest === null || !record.imageDigest || digest === record.imageDigest) ? raw : null;\n  const findings = summary && Array.isArray(summary.findings)\n    ? (summary.findings as PluginScanFinding[]).filter((f) => f && typeof f.id === 'string').map((f) => ({ ...f, fixedIn: Array.isArray(f.fixedIn) ? f.fixedIn : [] }))\n    : (flag?.findings ?? []);\n  const num = (v: unknown): number | null => (typeof v === 'number' ? v : null);\n  const kevCount = Math.max(num(summary?.kev) ?? 0, flag?.kev ?? 0, findings.filter((f) => f.kev === true).length);\n  return {\n    flagged: flag !== null,\n    flag,\n    criticalFixable: num(summary?.criticalFixable),\n    highFixable: num(summary?.highFixable) ?? num(record.vulnHighFixable),\n    critical: num(summary?.critical),\n    high: num(summary?.high),\n    kev: kevCount,\n    findings,\n    truncated: summary?.truncated === true,\n    scannedAt: lastScannedAt(record),\n  };\n}\n\n/**\n * Whether `acceptance` covers EVERY one of `findings` (by finding key), and its\n * KEV ones only when it accepted KEV. An empty set is never \"covered\": with\n * nothing itemized there is nothing an acceptance can be shown to describe.\n */\nfunction covers(acceptance: VulnAcceptance | null | undefined, findings: readonly PluginScanFinding[], truncated: boolean): boolean {\n  if (!acceptance || truncated || findings.length === 0) return false;\n  const keys = new Set(acceptance.findingKeys);\n  return findings.every((f) => keys.has(scanFindingKey(f)) && (f.kev !== true || acceptance.kev));\n}\n\n/** Input to {@link assessVersionVulns}. */\nexport interface VersionVulnInput {\n  orgId: string;\n  record: ScannedRecord;\n  policy: VulnConsumptionPolicy;\n  /** The pipeline's active acceptance of this version / image, when the caller has a pipeline. */\n  acceptance?: VulnAcceptance | null;\n  /** The newest unflagged version the owner can move to, named on the finding warnings. */\n  suggestedVersion?: string | null;\n  /** Run the org's compliance rules (a network call). Default true. */\n  compliance?: boolean;\n  now?: Date;\n}\n\n/** The assessment: every warning, the loudest severity, and which accepted findings it downgraded. */\nexport interface VersionVulnAssessment {\n  /** `null` when there is nothing to say. */\n  severity: VulnSeverity | null;\n  warnings: VulnWarning[];\n  /** Finding keys an acceptance downgraded (empty = no acceptance applied). */\n  acceptedFindings: string[];\n  facts: VersionScanFacts;\n}\n\n/** The loudest severity of `warnings`, or null for none. */\nexport function severityOf(warnings: ReadonlyArray<{ severity?: VulnSeverity }>): VulnSeverity | null {\n  return warnings.reduce<VulnSeverity | null>((acc, w) => (w.severity ? (acc ? maxSeverity(acc, w.severity) : w.severity) : acc), null);\n}\n\n/**\n * The assessment of one resolved version (see the module doc). Never throws and\n * never refuses: a compliance outage adds an `info` `COMPLIANCE_UNAVAILABLE`.\n */\nexport async function assessVersionVulns(input: VersionVulnInput): Promise<VersionVulnAssessment> {\n  const { orgId, record, policy, acceptance } = input;\n  const now = input.now ?? new Date();\n  const ref = `${record.name}@${record.version}`;\n  const facts = versionScanFacts(record);\n  const warnings: VulnWarning[] = [...scanWarnings(record, now)];\n  const accepted = new Set<string>();\n  const way = input.suggestedVersion ? ` Move to ${record.name}@${input.suggestedVersion}.` : '';\n  const suggested = input.suggestedVersion ? { suggestedVersion: input.suggestedVersion } : {};\n  const until = toDate(acceptance?.acceptedUntil)?.toISOString() ?? null;\n\n  /** Push a finding warning — or, when the pipeline accepted exactly those findings, its `info` downgrade. */\n  const finding = (code: 'VULN_KEV' | 'VULN_FLAGGED' | 'VULN_CRITICAL_FIXABLE' | 'VULN_HIGH_FIXABLE', severity: VulnSeverity, message: string, findings: PluginScanFinding[],\n    extra: { plugin?: string; version?: string; gated?: number; high?: number } = {}) => {\n    if (covers(acceptance, findings, facts.truncated)) {\n      for (const f of findings) accepted.add(scanFindingKey(f));\n      warnings.push({\n        code: 'VULN_ACCEPTED',\n        severity: 'info',\n        message: `${message} Accepted for this pipeline${until ? ` until ${until}` : ''}.`,\n        findings: findings.map(scanFindingKey),\n        acceptedUntil: until,\n        kev: acceptance?.kev ?? false,\n        covers: code,\n      });\n      return;\n    }\n    warnings.push({ code, severity, message: `${message}${way}`, findings: findings.slice(0, 10), ...suggested, ...extra });\n  };\n\n  const kevFindings = facts.findings.filter((f) => f.kev === true);\n  if (facts.kev > 0) {\n    finding('VULN_KEV', 'critical', `${ref} has ${facts.kev} finding${facts.kev === 1 ? '' : 's'} on the CISA Known Exploited Vulnerabilities list${kevFindings.length ? `: ${describeFindings(kevFindings)}` : ''}.`, kevFindings);\n  }\n  const flag = facts.flag;\n  if (flag) {\n    const gated = facts.findings.filter((f) => isGatedFinding(f, pluginVulnGateKev(), flag.failOn ?? 'critical'));\n    finding('VULN_FLAGGED', 'error', `${ref} is flagged: a rescan found ${flag.gated} gated ${failOnLabel(flag.failOn ?? 'critical')} finding${flag.gated === 1 ? '' : 's'} over the platform limit${flag.findings.length ? ` (fix: ${describeFindings(flag.findings)})` : ''}.`,\n      gated.length > 0 ? gated : flag.findings, { plugin: record.name, version: record.version, gated: flag.gated, high: flag.high });\n  } else if ((facts.criticalFixable ?? 0) > 0) {\n    const crits = facts.findings.filter((f) => f.severity === 'critical' && f.fixedIn.length > 0);\n    finding('VULN_CRITICAL_FIXABLE', 'error', `${ref} has ${facts.criticalFixable} fixable Critical finding${facts.criticalFixable === 1 ? '' : 's'}${crits.length ? `: ${describeFindings(crits)}` : ''}.`, crits);\n  }\n  const highFixable = facts.highFixable ?? 0;\n  if (highFixable > 0) {\n    const highs = facts.findings.filter((f) => f.severity === 'high' && f.fixedIn.length > 0);\n    const over = policy.warnFixableHigh !== null && highFixable > policy.warnFixableHigh;\n    finding('VULN_HIGH_FIXABLE', over ? 'warning' : 'info',\n      `${ref} has ${highFixable} fixable High finding${highFixable === 1 ? '' : 's'}${over ? `, over your organization's threshold of ${policy.warnFixableHigh}` : ''}.`, highs);\n  }\n\n  if (input.compliance !== false) warnings.push(...await complianceVulnWarnings(orgId, record));\n  return { severity: severityOf(warnings), warnings, acceptedFindings: [...accepted], facts };\n}\n\n/** The compliance attributes a plugin's vulnerability rules read. */\nconst VULN_RULE_FIELDS = new Set(['scanned', 'vulnCritical', 'vulnHigh', 'vulnMedium', 'vulnLow', 'vulnCriticalFixable', 'vulnHighFixable']);\n\nconst fieldRoot = (field: string): string => field.split(/[.[]/)[0] ?? field;\n\ntype ComplianceClient = Pick<ReturnType<typeof createComplianceClient>, 'dryRunPlugin'>;\n\nlet complianceClient: ComplianceClient | null = null;\n\n/** Test hook: replace the compliance client the assessment's compliance layer calls. */\nexport function setVulnPolicyComplianceClientForTests(client: ComplianceClient | null): void {\n  complianceClient = client;\n}\n\n/**\n * The org's plugin compliance rules on the vulnerability attributes, evaluated\n * against the RESOLVED version — the org's own row, its parent's, a system\n * plugin or an installed marketplace version alike. A BLOCK-mode rule that fails\n * is an `error`, a WARN-mode one a `warning`; neither refuses anything here\n * (vulnerability state never stops a pipeline).\n *\n * Only the vuln / scanned rules count here: the plugin's other rules (tags,\n * secrets, commands …) describe how a plugin is AUTHORED, which is its owner's\n * concern at upload, not the consumer's at resolution — and a system plugin would\n * otherwise fail every tenant's authoring rules.\n */\nasync function complianceVulnWarnings(orgId: string, record: ScannedRecord): Promise<VulnWarning[]> {\n  if (isSystemOrgId(orgId) || !hasImage(record)) return [];\n  const facts = derivePluginImageCompliance(record, null).attributes;\n  const attributes: PluginComplianceAttributes = { name: record.name, version: record.version, ...facts };\n  try {\n    complianceClient ??= createComplianceClient();\n    const auth = getServiceAuthHeader({ serviceName: 'plugin', orgId, role: 'member' });\n    const result = await complianceClient.dryRunPlugin(orgId, attributes as Record<string, unknown>, auth);\n    const relevant = (v: ComplianceViolation) => VULN_RULE_FIELDS.has(fieldRoot(v.field));\n    const as = (mode: 'block' | 'warn') => (v: ComplianceViolation): VulnWarning => ({\n      code: 'COMPLIANCE_VULN_RULE',\n      severity: mode === 'block' ? 'error' : 'warning',\n      message: `${record.name}@${record.version}: ${v.message}`,\n      ruleId: v.ruleId,\n      ruleName: v.ruleName,\n      field: v.field,\n      mode,\n    });\n    return [...result.violations.filter(relevant).map(as('block')), ...result.warnings.filter(relevant).map(as('warn'))];\n  } catch (err) {\n    return [{ code: 'COMPLIANCE_UNAVAILABLE', severity: 'info', message: `Your organization's plugin vulnerability rules could not be checked for ${record.name}@${record.version} (${errorMessage(err)}).` }];\n  }\n}\n"]}

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

@@ -0,0 +1,63 @@
+/**
+ * The AI provider + model catalog, as DATA ONLY.
+ *
+ * Dependency-free and env-free so the browser imports it directly
+ * (`@pipeline-builder/api-core/ai-catalog`) — the frontend's model picker and the
+ * backend's provider registry read the one list, instead of the frontend keeping a
+ * hand-maintained mirror that drifted every time a model shipped. Anything that
+ * reads the environment (the OpenAI-compatible endpoint, provider key env vars)
+ * stays in `constants/ai-providers.ts`, which re-exports this.
+ */
+/** Metadata for a single AI model. */
+export interface AIModelInfo {
+    /** Model identifier used in API calls (e.g. "claude-sonnet-5-5"). */
+    id: string;
+    /** Human-readable display name (e.g. "Claude Sonnet 5.5"). */
+    name: string;
+}
+/** Metadata for an AI provider with its available models. */
+export interface AIProviderInfo {
+    /** Provider identifier (e.g. "anthropic", "openai", "google"). */
+    id: string;
+    /** Human-readable display name (e.g. "Anthropic"). */
+    name: string;
+    /** Models available for this provider. */
+    models: AIModelInfo[];
+    /**
+     * The provider authenticates with the DEPLOYMENT's own credentials (an IAM
+     * role), not an API key — so there is no key for an organization to bring.
+     * Absent = key-based.
+     *
+     * This is the ONE place that fact is recorded. Everything that asks "can an
+     * org hold its own key for this provider?" reads {@link AI_KEY_PROVIDER_IDS}
+     * or {@link isKeylessProviderId}: the settings picker that offers the slot,
+     * the platform that stores and re-encrypts it, the internal route that serves
+     * it, and the model selection that spends it. They disagreed once — the
+     * picker offered Amazon Bedrock, the platform encrypted the key and reported
+     * it `configured`, and no AI call could ever use it.
+     */
+    keyless?: true;
+}
+/**
+ * Standard AI provider catalog — single source of truth for all supported
+ * providers and their models. The FIRST model of a provider is its default
+ * (what a provider-only request resolves to), so order matters.
+ */
+export declare const AI_PROVIDER_CATALOG: Record<string, AIProviderInfo>;
+/**
+ * Provider ids an organization CAN hold its own API key for — the catalog minus
+ * the keyless providers ({@link AIProviderInfo.keyless}).
+ *
+ * The single list behind every org-key surface: the settings picker offers these
+ * slots, the platform stores and re-encrypts these fields, `GET
+ * /internal/ai/keys/:orgId/:provider` serves only these, and org-aware model
+ * selection spends only these. A provider absent here has no org key by
+ * construction, so no caller needs its own exclusion.
+ */
+export declare const AI_KEY_PROVIDER_IDS: readonly string[];
+/** True when the provider authenticates with the deployment's own credentials rather than a key. */
+export declare function isKeylessProviderId(providerId: string): boolean;
+/** Display names by provider id — the catalog's names, for UI surfaces that list providers. */
+export declare const AI_PROVIDER_NAMES: Record<string, string>;
+/** Model lists by provider id — the catalog's models, for UI surfaces that need only those. */
+export declare const AI_PROVIDER_MODELS: Record<string, AIModelInfo[]>;

package/lib/types/ai-catalog.js

@@ -0,0 +1,82 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Standard AI provider catalog — single source of truth for all supported
+ * providers and their models. The FIRST model of a provider is its default
+ * (what a provider-only request resolves to), so order matters.
+ */
+export const AI_PROVIDER_CATALOG = {
+    'anthropic': {
+        id: 'anthropic',
+        name: 'Anthropic',
+        models: [
+            { id: 'claude-sonnet-5-5', name: 'Claude Sonnet 5.5' },
+            { id: 'claude-opus-5-5', name: 'Claude Opus 5.5' },
+            { id: 'claude-fable-5-1', name: 'Claude Fable 5.1' },
+            { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5' },
+        ],
+    },
+    'openai': {
+        id: 'openai',
+        name: 'OpenAI',
+        models: [
+            { id: 'gpt-5.6-sol', name: 'GPT-5.6 Sol' },
+            { id: 'gpt-5.6-terra', name: 'GPT-5.6 Terra' },
+            { id: 'gpt-5.6-luna', name: 'GPT-5.6 Luna' },
+        ],
+    },
+    'google': {
+        id: 'google',
+        name: 'Google',
+        models: [
+            { id: 'gemini-3.7-flash', name: 'Gemini 3.7 Flash' },
+            { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro' },
+        ],
+    },
+    'xai': {
+        id: 'xai',
+        name: 'xAI (Grok)',
+        models: [
+            { id: 'grok-4.6', name: 'Grok 4.6' },
+            { id: 'grok-4.5', name: 'Grok 4.5' },
+            { id: 'grok-4.3', name: 'Grok 4.3' },
+        ],
+    },
+    'amazon-bedrock': {
+        id: 'amazon-bedrock',
+        name: 'Amazon Bedrock',
+        // Authenticated by the deployment's IAM role, never an org-supplied key.
+        keyless: true,
+        // Bedrock ids are region-scoped cross-region inference profiles; the `us.`
+        // prefix targets US regions — swap the prefix (eu./apac./…) to match your
+        // deploy region, and confirm availability in the Bedrock console.
+        models: [
+            { id: 'us.anthropic.claude-sonnet-5-5', name: 'Claude Sonnet 5.5' },
+            { id: 'us.anthropic.claude-opus-5-5', name: 'Claude Opus 5.5' },
+            { id: 'us.anthropic.claude-haiku-4-5-20251001-v1:0', name: 'Claude Haiku 4.5' },
+            { id: 'us.amazon.nova-pro-v1:0', name: 'Amazon Nova Pro' },
+        ],
+    },
+};
+/**
+ * Provider ids an organization CAN hold its own API key for — the catalog minus
+ * the keyless providers ({@link AIProviderInfo.keyless}).
+ *
+ * The single list behind every org-key surface: the settings picker offers these
+ * slots, the platform stores and re-encrypts these fields, `GET
+ * /internal/ai/keys/:orgId/:provider` serves only these, and org-aware model
+ * selection spends only these. A provider absent here has no org key by
+ * construction, so no caller needs its own exclusion.
+ */
+export const AI_KEY_PROVIDER_IDS = Object.values(AI_PROVIDER_CATALOG)
+    .filter((p) => !p.keyless)
+    .map((p) => p.id);
+/** True when the provider authenticates with the deployment's own credentials rather than a key. */
+export function isKeylessProviderId(providerId) {
+    return AI_PROVIDER_CATALOG[providerId]?.keyless === true;
+}
+/** Display names by provider id — the catalog's names, for UI surfaces that list providers. */
+export const AI_PROVIDER_NAMES = Object.fromEntries(Object.values(AI_PROVIDER_CATALOG).map((p) => [p.id, p.name]));
+/** Model lists by provider id — the catalog's models, for UI surfaces that need only those. */
+export const AI_PROVIDER_MODELS = Object.fromEntries(Object.values(AI_PROVIDER_CATALOG).map((p) => [p.id, p.models]));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-catalog.js","sourceRoot":"","sources":["../../src/types/ai-catalog.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The AI provider + model catalog, as DATA ONLY.\n *\n * Dependency-free and env-free so the browser imports it directly\n * (`@pipeline-builder/api-core/ai-catalog`) — the frontend's model picker and the\n * backend's provider registry read the one list, instead of the frontend keeping a\n * hand-maintained mirror that drifted every time a model shipped. Anything that\n * reads the environment (the OpenAI-compatible endpoint, provider key env vars)\n * stays in `constants/ai-providers.ts`, which re-exports this.\n */\n\n/** Metadata for a single AI model. */\nexport interface AIModelInfo {\n  /** Model identifier used in API calls (e.g. \"claude-sonnet-5-5\"). */\n  id: string;\n  /** Human-readable display name (e.g. \"Claude Sonnet 5.5\"). */\n  name: string;\n}\n\n/** Metadata for an AI provider with its available models. */\nexport interface AIProviderInfo {\n  /** Provider identifier (e.g. \"anthropic\", \"openai\", \"google\"). */\n  id: string;\n  /** Human-readable display name (e.g. \"Anthropic\"). */\n  name: string;\n  /** Models available for this provider. */\n  models: AIModelInfo[];\n  /**\n   * The provider authenticates with the DEPLOYMENT's own credentials (an IAM\n   * role), not an API key — so there is no key for an organization to bring.\n   * Absent = key-based.\n   *\n   * This is the ONE place that fact is recorded. Everything that asks \"can an\n   * org hold its own key for this provider?\" reads {@link AI_KEY_PROVIDER_IDS}\n   * or {@link isKeylessProviderId}: the settings picker that offers the slot,\n   * the platform that stores and re-encrypts it, the internal route that serves\n   * it, and the model selection that spends it. They disagreed once — the\n   * picker offered Amazon Bedrock, the platform encrypted the key and reported\n   * it `configured`, and no AI call could ever use it.\n   */\n  keyless?: true;\n}\n\n/**\n * Standard AI provider catalog — single source of truth for all supported\n * providers and their models. The FIRST model of a provider is its default\n * (what a provider-only request resolves to), so order matters.\n */\nexport const AI_PROVIDER_CATALOG: Record<string, AIProviderInfo> = {\n  'anthropic': {\n    id: 'anthropic',\n    name: 'Anthropic',\n    models: [\n      { id: 'claude-sonnet-5-5', name: 'Claude Sonnet 5.5' },\n      { id: 'claude-opus-5-5', name: 'Claude Opus 5.5' },\n      { id: 'claude-fable-5-1', name: 'Claude Fable 5.1' },\n      { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5' },\n    ],\n  },\n  'openai': {\n    id: 'openai',\n    name: 'OpenAI',\n    models: [\n      { id: 'gpt-5.6-sol', name: 'GPT-5.6 Sol' },\n      { id: 'gpt-5.6-terra', name: 'GPT-5.6 Terra' },\n      { id: 'gpt-5.6-luna', name: 'GPT-5.6 Luna' },\n    ],\n  },\n  'google': {\n    id: 'google',\n    name: 'Google',\n    models: [\n      { id: 'gemini-3.7-flash', name: 'Gemini 3.7 Flash' },\n      { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro' },\n    ],\n  },\n  'xai': {\n    id: 'xai',\n    name: 'xAI (Grok)',\n    models: [\n      { id: 'grok-4.6', name: 'Grok 4.6' },\n      { id: 'grok-4.5', name: 'Grok 4.5' },\n      { id: 'grok-4.3', name: 'Grok 4.3' },\n    ],\n  },\n  'amazon-bedrock': {\n    id: 'amazon-bedrock',\n    name: 'Amazon Bedrock',\n    // Authenticated by the deployment's IAM role, never an org-supplied key.\n    keyless: true,\n    // Bedrock ids are region-scoped cross-region inference profiles; the `us.`\n    // prefix targets US regions — swap the prefix (eu./apac./…) to match your\n    // deploy region, and confirm availability in the Bedrock console.\n    models: [\n      { id: 'us.anthropic.claude-sonnet-5-5', name: 'Claude Sonnet 5.5' },\n      { id: 'us.anthropic.claude-opus-5-5', name: 'Claude Opus 5.5' },\n      { id: 'us.anthropic.claude-haiku-4-5-20251001-v1:0', name: 'Claude Haiku 4.5' },\n      { id: 'us.amazon.nova-pro-v1:0', name: 'Amazon Nova Pro' },\n    ],\n  },\n};\n\n/**\n * Provider ids an organization CAN hold its own API key for — the catalog minus\n * the keyless providers ({@link AIProviderInfo.keyless}).\n *\n * The single list behind every org-key surface: the settings picker offers these\n * slots, the platform stores and re-encrypts these fields, `GET\n * /internal/ai/keys/:orgId/:provider` serves only these, and org-aware model\n * selection spends only these. A provider absent here has no org key by\n * construction, so no caller needs its own exclusion.\n */\nexport const AI_KEY_PROVIDER_IDS: readonly string[] = Object.values(AI_PROVIDER_CATALOG)\n  .filter((p) => !p.keyless)\n  .map((p) => p.id);\n\n/** True when the provider authenticates with the deployment's own credentials rather than a key. */\nexport function isKeylessProviderId(providerId: string): boolean {\n  return AI_PROVIDER_CATALOG[providerId]?.keyless === true;\n}\n\n/** Display names by provider id — the catalog's names, for UI surfaces that list providers. */\nexport const AI_PROVIDER_NAMES: Record<string, string> = Object.fromEntries(\n  Object.values(AI_PROVIDER_CATALOG).map((p) => [p.id, p.name]),\n);\n\n/** Model lists by provider id — the catalog's models, for UI surfaces that need only those. */\nexport const AI_PROVIDER_MODELS: Record<string, AIModelInfo[]> = Object.fromEntries(\n  Object.values(AI_PROVIDER_CATALOG).map((p) => [p.id, p.models]),\n);\n"]}