@pipeline-builder/api-core 5.0.8 → 5.0.9

package/lib/types/index.d.ts

@@ -19,4 +19,4 @@ export { ASK_AGENT_PROPOSER, ASK_PROPOSED_BY_HEADER, PROPOSED_BY_DETAIL_KEY, ask
 export { isEcosystemNotificationEvent, parseEcosystemNotifyRequest, nextEcosystemDigestTime, renderEcosystemManagerChange, renderEcosystemDigest, type EcosystemNotificationEventId, type EcosystemNotificationChannel, ECOSYSTEM_EMAIL_PREFERENCE_FIELDS, type EcosystemEmailPreferenceField, ECOSYSTEM_EMAIL_PREFERENCE_FIELD_NAMES, ECOSYSTEM_NOTIFICATION_EVENTS, type EcosystemRecipientSpec, type EcosystemNotifyRequest, } from './ecosystem-notifications.js';
 export { publisherTermsVersion, publisherHandleProblem, isOfficialAutoApprovalEnabled, isPluginPublishingEnabled, isAnonymousSubmissionsEnabled, isPluginReviewsEnabled, OFFICIAL_CATALOG_LOADER_ACCOUNT, DEFAULT_PUBLISHER_TERMS_VERSION, BUILTIN_RESERVED_HANDLES, TENANT_REQUEST_KINDS, PUBLISH_PERMISSION_REQUEST_KINDS, VERIFY_REQUEST_KINDS, STEP_UP_REQUEST_KINDS, REQUEST_SLA_HOURS, } from './ecosystem.js';
 export { ageScore, vulnScore, computeHealthScore, publisherHealthScore, publisherSuccessRate, healthBand, HEALTH_COMPONENTS, HEALTH_WEIGHTS, type HealthBreakdown, type HealthComponentScore, type HealthResult, type HealthInputs, type HealthBand, } from './plugin-health.js';
-export { asScanFlag, blockOnNewCritical, describeFindings, describeFix, exceedsVulnFloor, pluginVulnMaxCritical, SCAN_FLAG_TOP_FINDINGS, vulnBlockedMessage, vulnFlaggedMessage, vulnFlaggedWarning, type PluginScanFinding, type PluginScanFlag, type PluginScanSummary, type VulnFlaggedWarning, } from './plugin-scan.js';
+export { applyVulnWaivers, asScanFlag, blockOnNewCritical, describeFindings, describeFix, exceedsVulnFloor, parseVulnWaivers, parseVulnWaiversVerbose, pluginVulnMaxCritical, SCAN_FLAG_TOP_FINDINGS, vulnBlockedMessage, vulnFlaggedMessage, vulnFlaggedWarning, type PluginScanFinding, type PluginScanFlag, type PluginScanSummary, type VulnFlaggedWarning, type VulnWaiver, type VulnWaiverParse, type VulnWaiverProblem, type WaiverOutcome, } from './plugin-scan.js';

package/lib/types/index.js

@@ -21,5 +21,5 @@ export { ASK_AGENT_PROPOSER, ASK_PROPOSED_BY_HEADER, PROPOSED_BY_DETAIL_KEY, ask
 export { isEcosystemNotificationEvent, parseEcosystemNotifyRequest, nextEcosystemDigestTime, renderEcosystemManagerChange, renderEcosystemDigest, ECOSYSTEM_EMAIL_PREFERENCE_FIELDS, ECOSYSTEM_EMAIL_PREFERENCE_FIELD_NAMES, ECOSYSTEM_NOTIFICATION_EVENTS, } from './ecosystem-notifications.js';
 export { publisherTermsVersion, publisherHandleProblem, isOfficialAutoApprovalEnabled, isPluginPublishingEnabled, isAnonymousSubmissionsEnabled, isPluginReviewsEnabled, OFFICIAL_CATALOG_LOADER_ACCOUNT, DEFAULT_PUBLISHER_TERMS_VERSION, BUILTIN_RESERVED_HANDLES, TENANT_REQUEST_KINDS, PUBLISH_PERMISSION_REQUEST_KINDS, VERIFY_REQUEST_KINDS, STEP_UP_REQUEST_KINDS, REQUEST_SLA_HOURS, } from './ecosystem.js';
 export { ageScore, vulnScore, computeHealthScore, publisherHealthScore, publisherSuccessRate, healthBand, HEALTH_COMPONENTS, HEALTH_WEIGHTS, } from './plugin-health.js';
-export { asScanFlag, blockOnNewCritical, describeFindings, describeFix, exceedsVulnFloor, pluginVulnMaxCritical, SCAN_FLAG_TOP_FINDINGS, vulnBlockedMessage, vulnFlaggedMessage, vulnFlaggedWarning, } from './plugin-scan.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EACL,gBAAgB,EAEhB,YAAY,EAMZ,iBAAiB,GAMlB,MAAM,aAAa,CAAC;AACrB,cAAc,eAAe,CAAC;AAC9B,OAAO,EAMN,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEN,MAAM,wBAAwB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAmC,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,EAC1B,iBAAiB,EAEjB,qBAAqB,EAErB,0BAA0B,EAC1B,gBAAgB,GAGjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEN,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,aAAa,EAGb,WAAW,EACX,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EAEb,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,2BAA2B,EAC3B,2BAA2B,EAC3B,0BAA0B,EAC1B,yBAAyB,EACzB,qBAAqB,EACrB,gBAAgB,EAChB,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,YAAY,EAGZ,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAEN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,oBAAoB,EACpB,mBAAmB,GAEpB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,8BAA8B,EAC9B,+BAA+B,EAC/B,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,cAAc,EACd,WAAW,EACX,eAAe,EACf,kBAAkB,GAYnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,4BAA4B,EAC5B,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,EAC5B,qBAAqB,EAGrB,iCAAiC,EAEjC,sCAAsC,EACtC,6BAA6B,GAG9B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,6BAA6B,EAC7B,yBAAyB,EACzB,6BAA6B,EAC7B,sBAAsB,EACtB,+BAA+B,EAC/B,+BAA+B,EAC/B,wBAAwB,EACxB,oBAAoB,EACpB,gCAAgC,EAChC,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,QAAQ,EACR,SAAS,EACT,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,UAAU,EACV,iBAAiB,EACjB,cAAc,GAMf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,GAKnB,MAAM,kBAAkB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport { ErrorCode, getStatusForErrorCode } from './error-codes.js';\nexport {\n  isValidQuotaType,\n  type TokenScope,\n  TOKEN_SCOPES,\n  type PrincipalType,\n  type TokenUse,\n  type AuthMethod,\n  type AssuranceLevel,\n  type QuotaType,\n  VALID_QUOTA_TYPES,\n  type QuotaCheckResult,\n  type QuotaInfo,\n  type ApiResponse,\n  type JwtPayload,\n  type HealthCheckResponse,\n} from './common.js';\nexport * from './pipeline.js';\nexport {\n  type Lifecycle,\n  type Criticality,\n  type OwnerType,\n  type EntityLink,\n  type EntityLabels,\n} from './catalog-metadata.js';\nexport {\n  type TemplateInput,\n} from './pipeline-template.js';\nexport * from './visibility.js';\nexport * from './reserved-tags.js';\nexport * from './wire-vocabulary.js';\nexport { type ComplianceExemptionRequest } from './compliance-exemption.js';\nexport {\n  PLUGIN_SUMMARY_MAX,\n  PLUGIN_README_MAX_BYTES,\n  PLUGIN_CHANGELOG_MAX_BYTES,\n  PLUGIN_CATEGORIES,\n  type PluginCatalogCategory,\n  PLUGIN_CATALOG_FIELDS,\n  type PluginCatalogField,\n  PLUGIN_CATALOG_LINK_FIELDS,\n  METADATA_SOURCES,\n  type MetadataSource,\n  type MetadataSources,\n} from './plugin-catalog.js';\nexport {\n  type HttpRequest,\n} from './http.js';\nexport {\n  tierAllowsTeams,\n  isBillingEnabled,\n  isValidTier,\n  getTierLimits,\n  type QuotaTier,\n  type QuotaTierLimits,\n  QUOTA_TIERS,\n  VALID_TIERS,\n  STANDARD_TIERS,\n  TEAM_CAPABLE_TIERS,\n  DEFAULT_TIER,\n  QUOTA_RESET_DAYS,\n  nextQuotaResetDate,\n} from './quota-tiers.js';\nexport * from './feature-flags.js';\nexport {\n  permissionLabel,\n  isValidPermission,\n  isSystemOrgOnlyPermission,\n  isOrgAssignablePermission,\n  normalizePermissionSubset,\n  intersectPermissions,\n  resolveUserPermissions,\n  confinePermissionsToOrg,\n  hasPermission,\n  type Permission,\n  ALL_PERMISSIONS,\n  PERMISSION_GATES,\n  PERMISSION_CATALOG,\n  SUPERADMIN_ONLY_PERMISSIONS,\n  SYSTEM_ORG_ONLY_PERMISSIONS,\n  ORG_ASSIGNABLE_PERMISSIONS,\n  ORG_ASSIGNABLE_CATEGORIES,\n  READ_ONLY_PERMISSIONS,\n  ROLE_PERMISSIONS,\n  ECOSYSTEM_MANAGER_PERMISSIONS,\n  TEAM_LEAD_PERMISSIONS,\n} from './permissions.js';\nexport {\n  METADATA_KEY_CATALOG,\n  MetadataKeys,\n  type MetadataKey,\n  type MetadataKeyOption,\n  METADATA_KEY_GROUPS,\n} from './metadata-keys.js';\nexport {\n  type AuditEvent,\n} from './audit-events.js';\nexport {\n  REMOTE_AUDIT_ACTIONS,\n  isRemoteAuditAction,\n  type RemoteAuditAction,\n} from './remote-audit-actions.js';\nexport {\n  ASK_AGENT_PROPOSER,\n  ASK_PROPOSED_BY_HEADER,\n  PROPOSED_BY_DETAIL_KEY,\n  askProposalAuditDetails,\n  readProposerClaim,\n  withProposalProvenance,\n  ORG_SETTING_PROPOSAL_ALLOWLIST,\n  ORG_SETTING_PROPOSAL_EXCLUSIONS,\n  ORG_SETTING_PROPOSAL_KEYS,\n  isProposableOrgSetting,\n  isValidOrgSettingValue,\n  orgSettingSpec,\n  pickAllowed,\n  diffOrgSettings,\n  orgSettingRequests,\n  type AskProposalProvenance,\n  type ProposerClaim,\n  type OrgSettingChange,\n  type OrgSettingKey,\n  type OrgSettingPatch,\n  type OrgSettingRequest,\n  type OrgSettingShape,\n  type OrgSettingSpec,\n  type OrgSettingSurface,\n  type OrgSettingValue,\n  type PickAllowedResult,\n} from './ask-proposals.js';\nexport {\n  isEcosystemNotificationEvent,\n  parseEcosystemNotifyRequest,\n  nextEcosystemDigestTime,\n  renderEcosystemManagerChange,\n  renderEcosystemDigest,\n  type EcosystemNotificationEventId,\n  type EcosystemNotificationChannel,\n  ECOSYSTEM_EMAIL_PREFERENCE_FIELDS,\n  type EcosystemEmailPreferenceField,\n  ECOSYSTEM_EMAIL_PREFERENCE_FIELD_NAMES,\n  ECOSYSTEM_NOTIFICATION_EVENTS,\n  type EcosystemRecipientSpec,\n  type EcosystemNotifyRequest,\n} from './ecosystem-notifications.js';\nexport {\n  publisherTermsVersion,\n  publisherHandleProblem,\n  isOfficialAutoApprovalEnabled,\n  isPluginPublishingEnabled,\n  isAnonymousSubmissionsEnabled,\n  isPluginReviewsEnabled,\n  OFFICIAL_CATALOG_LOADER_ACCOUNT,\n  DEFAULT_PUBLISHER_TERMS_VERSION,\n  BUILTIN_RESERVED_HANDLES,\n  TENANT_REQUEST_KINDS,\n  PUBLISH_PERMISSION_REQUEST_KINDS,\n  VERIFY_REQUEST_KINDS,\n  STEP_UP_REQUEST_KINDS,\n  REQUEST_SLA_HOURS,\n} from './ecosystem.js';\nexport {\n  ageScore,\n  vulnScore,\n  computeHealthScore,\n  publisherHealthScore,\n  publisherSuccessRate,\n  healthBand,\n  HEALTH_COMPONENTS,\n  HEALTH_WEIGHTS,\n  type HealthBreakdown,\n  type HealthComponentScore,\n  type HealthResult,\n  type HealthInputs,\n  type HealthBand,\n} from './plugin-health.js';\nexport {\n  asScanFlag,\n  blockOnNewCritical,\n  describeFindings,\n  describeFix,\n  exceedsVulnFloor,\n  pluginVulnMaxCritical,\n  SCAN_FLAG_TOP_FINDINGS,\n  vulnBlockedMessage,\n  vulnFlaggedMessage,\n  vulnFlaggedWarning,\n  type PluginScanFinding,\n  type PluginScanFlag,\n  type PluginScanSummary,\n  type VulnFlaggedWarning,\n} from './plugin-scan.js';\n"]}
+export { applyVulnWaivers, asScanFlag, blockOnNewCritical, describeFindings, describeFix, exceedsVulnFloor, parseVulnWaivers, parseVulnWaiversVerbose, pluginVulnMaxCritical, SCAN_FLAG_TOP_FINDINGS, vulnBlockedMessage, vulnFlaggedMessage, vulnFlaggedWarning, } from './plugin-scan.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport { ErrorCode, getStatusForErrorCode } from './error-codes.js';\nexport {\n  isValidQuotaType,\n  type TokenScope,\n  TOKEN_SCOPES,\n  type PrincipalType,\n  type TokenUse,\n  type AuthMethod,\n  type AssuranceLevel,\n  type QuotaType,\n  VALID_QUOTA_TYPES,\n  type QuotaCheckResult,\n  type QuotaInfo,\n  type ApiResponse,\n  type JwtPayload,\n  type HealthCheckResponse,\n} from './common.js';\nexport * from './pipeline.js';\nexport {\n  type Lifecycle,\n  type Criticality,\n  type OwnerType,\n  type EntityLink,\n  type EntityLabels,\n} from './catalog-metadata.js';\nexport {\n  type TemplateInput,\n} from './pipeline-template.js';\nexport * from './visibility.js';\nexport * from './reserved-tags.js';\nexport * from './wire-vocabulary.js';\nexport { type ComplianceExemptionRequest } from './compliance-exemption.js';\nexport {\n  PLUGIN_SUMMARY_MAX,\n  PLUGIN_README_MAX_BYTES,\n  PLUGIN_CHANGELOG_MAX_BYTES,\n  PLUGIN_CATEGORIES,\n  type PluginCatalogCategory,\n  PLUGIN_CATALOG_FIELDS,\n  type PluginCatalogField,\n  PLUGIN_CATALOG_LINK_FIELDS,\n  METADATA_SOURCES,\n  type MetadataSource,\n  type MetadataSources,\n} from './plugin-catalog.js';\nexport {\n  type HttpRequest,\n} from './http.js';\nexport {\n  tierAllowsTeams,\n  isBillingEnabled,\n  isValidTier,\n  getTierLimits,\n  type QuotaTier,\n  type QuotaTierLimits,\n  QUOTA_TIERS,\n  VALID_TIERS,\n  STANDARD_TIERS,\n  TEAM_CAPABLE_TIERS,\n  DEFAULT_TIER,\n  QUOTA_RESET_DAYS,\n  nextQuotaResetDate,\n} from './quota-tiers.js';\nexport * from './feature-flags.js';\nexport {\n  permissionLabel,\n  isValidPermission,\n  isSystemOrgOnlyPermission,\n  isOrgAssignablePermission,\n  normalizePermissionSubset,\n  intersectPermissions,\n  resolveUserPermissions,\n  confinePermissionsToOrg,\n  hasPermission,\n  type Permission,\n  ALL_PERMISSIONS,\n  PERMISSION_GATES,\n  PERMISSION_CATALOG,\n  SUPERADMIN_ONLY_PERMISSIONS,\n  SYSTEM_ORG_ONLY_PERMISSIONS,\n  ORG_ASSIGNABLE_PERMISSIONS,\n  ORG_ASSIGNABLE_CATEGORIES,\n  READ_ONLY_PERMISSIONS,\n  ROLE_PERMISSIONS,\n  ECOSYSTEM_MANAGER_PERMISSIONS,\n  TEAM_LEAD_PERMISSIONS,\n} from './permissions.js';\nexport {\n  METADATA_KEY_CATALOG,\n  MetadataKeys,\n  type MetadataKey,\n  type MetadataKeyOption,\n  METADATA_KEY_GROUPS,\n} from './metadata-keys.js';\nexport {\n  type AuditEvent,\n} from './audit-events.js';\nexport {\n  REMOTE_AUDIT_ACTIONS,\n  isRemoteAuditAction,\n  type RemoteAuditAction,\n} from './remote-audit-actions.js';\nexport {\n  ASK_AGENT_PROPOSER,\n  ASK_PROPOSED_BY_HEADER,\n  PROPOSED_BY_DETAIL_KEY,\n  askProposalAuditDetails,\n  readProposerClaim,\n  withProposalProvenance,\n  ORG_SETTING_PROPOSAL_ALLOWLIST,\n  ORG_SETTING_PROPOSAL_EXCLUSIONS,\n  ORG_SETTING_PROPOSAL_KEYS,\n  isProposableOrgSetting,\n  isValidOrgSettingValue,\n  orgSettingSpec,\n  pickAllowed,\n  diffOrgSettings,\n  orgSettingRequests,\n  type AskProposalProvenance,\n  type ProposerClaim,\n  type OrgSettingChange,\n  type OrgSettingKey,\n  type OrgSettingPatch,\n  type OrgSettingRequest,\n  type OrgSettingShape,\n  type OrgSettingSpec,\n  type OrgSettingSurface,\n  type OrgSettingValue,\n  type PickAllowedResult,\n} from './ask-proposals.js';\nexport {\n  isEcosystemNotificationEvent,\n  parseEcosystemNotifyRequest,\n  nextEcosystemDigestTime,\n  renderEcosystemManagerChange,\n  renderEcosystemDigest,\n  type EcosystemNotificationEventId,\n  type EcosystemNotificationChannel,\n  ECOSYSTEM_EMAIL_PREFERENCE_FIELDS,\n  type EcosystemEmailPreferenceField,\n  ECOSYSTEM_EMAIL_PREFERENCE_FIELD_NAMES,\n  ECOSYSTEM_NOTIFICATION_EVENTS,\n  type EcosystemRecipientSpec,\n  type EcosystemNotifyRequest,\n} from './ecosystem-notifications.js';\nexport {\n  publisherTermsVersion,\n  publisherHandleProblem,\n  isOfficialAutoApprovalEnabled,\n  isPluginPublishingEnabled,\n  isAnonymousSubmissionsEnabled,\n  isPluginReviewsEnabled,\n  OFFICIAL_CATALOG_LOADER_ACCOUNT,\n  DEFAULT_PUBLISHER_TERMS_VERSION,\n  BUILTIN_RESERVED_HANDLES,\n  TENANT_REQUEST_KINDS,\n  PUBLISH_PERMISSION_REQUEST_KINDS,\n  VERIFY_REQUEST_KINDS,\n  STEP_UP_REQUEST_KINDS,\n  REQUEST_SLA_HOURS,\n} from './ecosystem.js';\nexport {\n  ageScore,\n  vulnScore,\n  computeHealthScore,\n  publisherHealthScore,\n  publisherSuccessRate,\n  healthBand,\n  HEALTH_COMPONENTS,\n  HEALTH_WEIGHTS,\n  type HealthBreakdown,\n  type HealthComponentScore,\n  type HealthResult,\n  type HealthInputs,\n  type HealthBand,\n} from './plugin-health.js';\nexport {\n  applyVulnWaivers,\n  asScanFlag,\n  blockOnNewCritical,\n  describeFindings,\n  describeFix,\n  exceedsVulnFloor,\n  parseVulnWaivers,\n  parseVulnWaiversVerbose,\n  pluginVulnMaxCritical,\n  SCAN_FLAG_TOP_FINDINGS,\n  vulnBlockedMessage,\n  vulnFlaggedMessage,\n  vulnFlaggedWarning,\n  type PluginScanFinding,\n  type PluginScanFlag,\n  type PluginScanSummary,\n  type VulnFlaggedWarning,\n  type VulnWaiver,\n  type VulnWaiverParse,\n  type VulnWaiverProblem,\n  type WaiverOutcome,\n} from './plugin-scan.js';\n"]}

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

@@ -60,6 +60,97 @@ export declare const VULN_FLAGGED_WARNING = "VULN_FLAGGED";
  * flagged by the rescan. Default `0`; `-1` disables the floor (and the flag).
  */
 export declare function pluginVulnMaxCritical(): number;
+/**
+ * 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:
+ * 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
+ * downloads Firefox) is at upstream's latest and still carries fixable findings,
+ * because browsers ship CVE fixes weekly while pinned builds lag by design.
+ * Without a narrow exemption the only options are "block the plugin forever" or
+ * "disable the floor for everything".
+ *
+ * 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
+ *             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`.
+ *   EXPIRING  every entry carries a date and stops applying after it. A waiver
+ *             nobody revisits becomes permanent; this one lapses on its own and
+ *             the plugin starts failing again, which is the intended prompt.
+ *   VISIBLE   what was waived is returned to the caller, so it reaches the
+ *             metric, the audit record and the build message instead of
+ *             vanishing from the count.
+ *
+ * Format — entries `;`-separated, fields `:`-separated, packages `,`-separated:
+ *
+ *   PLUGIN_VULN_WAIVERS=artillery:2026-12-31:chromium,chrome;playwright:2026-12-31:firefox
+ *
+ * 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: string;
+    /**
+     * Plugin version the waiver is limited to, or null for every version.
+     *
+     * A waiver is a judgement about a SPECIFIC image — "this release of artillery
+     * bundles a Chromium we cannot patch". Left unpinned it silently carries to
+     * every future version, including ones whose findings nobody has looked at,
+     * which is how a narrow exemption becomes a standing one.
+     */
+    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. */
+    packages: string[];
+}
+/** A dropped entry and why, so the operator can be told instead of guessing. */
+export interface VulnWaiverProblem {
+    entry: string;
+    reason: string;
+}
+/** Parsed waivers plus the entries that were rejected. */
+export interface VulnWaiverParse {
+    waivers: VulnWaiver[];
+    problems: VulnWaiverProblem[];
+}
+/**
+ * Parse `PLUGIN_VULN_WAIVERS`, REPORTING what was dropped.
+ *
+ * Dropping a malformed entry is the safe direction — a typo must not become a
+ * wildcard — but silently dropping it is a usability trap: the operator sets a
+ * waiver, the gate keeps blocking, and nothing anywhere says why. Callers that
+ * can surface it (service boot) use this; `parseVulnWaivers` is the shorthand
+ * for the ones that cannot.
+ *
+ * Entry grammar: `<plugin>[@<version>]:<YYYY-MM-DD>:<pkg>[,<pkg>…]`
+ */
+export declare function parseVulnWaiversVerbose(raw?: string | undefined): VulnWaiverParse;
+/** Parse `PLUGIN_VULN_WAIVERS`. Malformed or incomplete entries are dropped. */
+export declare function parseVulnWaivers(raw?: string | undefined): VulnWaiver[];
+/** What a waiver removed from the count, and what still counts. */
+export interface WaiverOutcome {
+    /** Findings the floor still counts. */
+    counted: PluginScanFinding[];
+    /** Findings an unexpired waiver exempted (empty when none applied). */
+    waived: PluginScanFinding[];
+}
+/**
+ * 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.
+ */
+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;
 /**

package/lib/types/plugin-scan.js

@@ -12,6 +12,7 @@
  * count fixable Critical findings only, because an unfixable one can't be
  * acted on by rebuilding or upgrading.
  */
+import { SYSTEM_ORG_ID } from '../middleware/system-org.js';
 import { envBool, envInt } from '../utils/env.js';
 /** Findings a flag / gate message carries. */
 export const SCAN_FLAG_TOP_FINDINGS = 10;
@@ -25,6 +26,102 @@ export const VULN_FLAGGED_WARNING = 'VULN_FLAGGED';
 export function pluginVulnMaxCritical() {
     return envInt('PLUGIN_VULN_MAX_CRITICAL', 0, { min: -1 });
 }
+/**
+ * Parse `PLUGIN_VULN_WAIVERS`, REPORTING what was dropped.
+ *
+ * Dropping a malformed entry is the safe direction — a typo must not become a
+ * wildcard — but silently dropping it is a usability trap: the operator sets a
+ * waiver, the gate keeps blocking, and nothing anywhere says why. Callers that
+ * can surface it (service boot) use this; `parseVulnWaivers` is the shorthand
+ * for the ones that cannot.
+ *
+ * Entry grammar: `<plugin>[@<version>]:<YYYY-MM-DD>:<pkg>[,<pkg>…]`
+ */
+export function parseVulnWaiversVerbose(raw = process.env.PLUGIN_VULN_WAIVERS) {
+    const waivers = [];
+    const problems = [];
+    if (!raw?.trim())
+        return { waivers, problems };
+    const reject = (entry, reason) => { problems.push({ entry: entry.trim(), reason }); };
+    for (const entry of raw.split(';')) {
+        if (!entry.trim())
+            continue;
+        const [target, expires, packages] = entry.split(':').map((f) => f?.trim() ?? '');
+        // Every field is REQUIRED. An entry missing its package list would
+        // otherwise read as "waive this plugin entirely", which is the one thing
+        // this must not be able to express.
+        if (!target || !expires || !packages) {
+            reject(entry, 'expected <plugin>[@<version>]:<YYYY-MM-DD>:<package>[,<package>…]');
+            continue;
+        }
+        const at = target.indexOf('@');
+        const plugin = at === -1 ? target : target.slice(0, at).trim();
+        const version = at === -1 ? null : target.slice(at + 1).trim();
+        if (!plugin) {
+            reject(entry, 'no plugin name');
+            continue;
+        }
+        if (at !== -1 && !version) {
+            reject(entry, "'@' with no version — omit it to cover every version");
+            continue;
+        }
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(expires)) {
+            reject(entry, `expiry '${expires}' is not YYYY-MM-DD`);
+            continue;
+        }
+        const when = new Date(`${expires}T23:59:59.999Z`);
+        if (Number.isNaN(when.getTime())) {
+            reject(entry, `expiry '${expires}' is not a real date`);
+            continue;
+        }
+        const names = packages.split(',').map((n) => n.trim()).filter(Boolean);
+        if (names.length === 0) {
+            reject(entry, 'no package names');
+            continue;
+        }
+        waivers.push({ plugin, version, expires: when, packages: names });
+    }
+    return { waivers, problems };
+}
+/** Parse `PLUGIN_VULN_WAIVERS`. Malformed or incomplete entries are dropped. */
+export function parseVulnWaivers(raw = process.env.PLUGIN_VULN_WAIVERS) {
+    return parseVulnWaiversVerbose(raw).waivers;
+}
+/**
+ * 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.
+ */
+export function applyVulnWaivers(pluginName, findings, waivers = parseVulnWaivers(), now = new Date(), orgId, pluginVersion) {
+    // SYSTEM ORG ONLY. Plugin names are unique per (name, version, orgId), NOT
+    // globally — any tenant can create a plugin called `artillery`. Matching on
+    // the name alone would hand every one of them the operator's exemption, so a
+    // tenant could inherit a waiver simply by choosing the name, and ship an
+    // image whose Criticals the gate then waved through. The waivers exist for the
+    // Official catalog the operator curates, which lives in the system org; a
+    // caller that cannot say which org this build belongs to gets no waiver.
+    if (orgId === undefined || orgId.toLowerCase() !== SYSTEM_ORG_ID)
+        return { counted: [...findings], waived: [] };
+    const active = waivers.filter((w) => w.plugin === pluginName
+        && w.expires.getTime() >= now.getTime()
+        // A version-pinned waiver covers that version only. An unpinned one covers
+        // every version, which is why the pin is worth writing.
+        && (w.version === null || w.version === pluginVersion));
+    if (active.length === 0)
+        return { counted: [...findings], waived: [] };
+    const exempt = new Set(active.flatMap((w) => w.packages.map((n) => n.toLowerCase())));
+    const counted = [];
+    const waived = [];
+    for (const f of findings) {
+        if (f.fixedIn.length > 0 && exempt.has(f.packageName.toLowerCase()))
+            waived.push(f);
+        else
+            counted.push(f);
+    }
+    return { counted, waived };
+}
 /** Whether `fixableCritical` breaks the platform floor (never, when disabled). */
 export function exceedsVulnFloor(fixableCritical, max = pluginVulnMaxCritical()) {
     return max >= 0 && (fixableCritical ?? 0) > max;
@@ -87,4 +184,4 @@ export function asScanFlag(value) {
         findings: findings.map((f) => ({ ...f, fixedIn: Array.isArray(f.fixedIn) ? f.fixedIn : [] })),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-scan.js","sourceRoot":"","sources":["../../src/types/plugin-scan.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Plugin image scan gates (docs/plugin-publishing.md \"Scan gates\"): the shared\n * vocabulary of the build-time gate, the nightly rescan's flag, and the\n * resolution warning / block — used by the plugin service (which stores and\n * enforces them), the resolver in pipeline-data (which skips or warns), and the\n * dashboard (which shows them).\n *\n * A finding is FIXABLE when grype reports a fixed version for it\n * (`vulnerability.fix.state == \"fixed\"` with at least one version): the gates\n * count fixable Critical findings only, because an unfixable one can't be\n * acted on by rebuilding or upgrading.\n */\n\nimport { envBool, envInt } from '../utils/env.js';\n\n/** One Critical/High finding as the flag and the gate messages carry it. */\nexport interface PluginScanFinding {\n  /** The vulnerability id (CVE-…, GHSA-…). */\n  id: string;\n  severity: 'critical' | 'high';\n  packageName: string;\n  packageVersion: string;\n  /** Versions that fix it; empty = no fix available (not fixable). */\n  fixedIn: string[];\n}\n\n/**\n * `scan_flag` on a version the nightly rescan flagged: its fixable\n * Critical/High counts at that rescan and the top fixable findings. Set while\n * fixable Criticals exceed `PLUGIN_VULN_MAX_CRITICAL`, cleared when a rescan\n * finds them resolved.\n */\nexport interface PluginScanFlag {\n  /** Fixable Critical findings. */\n  critical: number;\n  /** Fixable High findings. */\n  high: number;\n  /** The floor it was compared against (`PLUGIN_VULN_MAX_CRITICAL`). */\n  maxCritical: number;\n  /** At most {@link SCAN_FLAG_TOP_FINDINGS} fixable findings, Criticals first. */\n  findings: PluginScanFinding[];\n}\n\n/**\n * `scan_summary` on every in-use version: the LAST rescan's findings, written\n * whether or not the gate tripped.\n *\n * Distinct from {@link PluginScanFlag}, which exists only while a version is over\n * the floor. A version carrying nothing but High findings is never flagged — so a\n * report whose job is to show Critical AND High exposure had no source to read.\n * What a report SHOWS and what a build REFUSES are different questions, and\n * conflating them meant the answer to the first was \"nothing\".\n */\nexport interface PluginScanSummary {\n  /** Fixable Critical findings at the last rescan. */\n  criticalFixable: number;\n  /** Fixable High findings at the last rescan. */\n  highFixable: number;\n  /** Totals including unfixable findings, for context. */\n  critical: number;\n  high: number;\n  /** At most {@link SCAN_FLAG_TOP_FINDINGS} findings, Criticals first. */\n  findings: PluginScanFinding[];\n  /** When the rescan that produced this ran (ISO). */\n  scannedAt: string;\n  /** The image this describes. A version rebuilt on a patched base is a\n   *  different artifact, so a summary without its digest cannot be trusted. */\n  imageDigest?: string;\n}\n\n/** Findings a flag / gate message carries. */\nexport const SCAN_FLAG_TOP_FINDINGS = 10;\n\n/** Lookup / resolution warning code for a flagged version. */\nexport const VULN_FLAGGED_WARNING = 'VULN_FLAGGED';\n\n/**\n * `PLUGIN_VULN_MAX_CRITICAL`: the platform floor — a version with MORE fixable\n * Critical findings than this fails its build (`PLUGIN_VULN_GATE`) and is\n * flagged by the rescan. Default `0`; `-1` disables the floor (and the flag).\n */\nexport function pluginVulnMaxCritical(): number {\n  return envInt('PLUGIN_VULN_MAX_CRITICAL', 0, { min: -1 });\n}\n\n/** Whether `fixableCritical` breaks the platform floor (never, when disabled). */\nexport function exceedsVulnFloor(fixableCritical: number | null | undefined, max: number = pluginVulnMaxCritical()): boolean {\n  return max >= 0 && (fixableCritical ?? 0) > max;\n}\n\n/**\n * `PLUGIN_BLOCK_ON_NEW_CRITICAL` (default false): resolution SKIPS flagged\n * versions for ranges and the default (falling back to the newest unflagged\n * one), and an exact pin to a flagged version is refused 409\n * `PLUGIN_VERSION_VULN_BLOCKED`. Off: flagged versions resolve with a\n * `VULN_FLAGGED` warning.\n */\nexport function blockOnNewCritical(): boolean {\n  return envBool('PLUGIN_BLOCK_ON_NEW_CRITICAL', false);\n}\n\n/** `pkg@1.2.3 → 1.2.4` / `pkg@1.2.3 (no fix)`. */\nexport function describeFix(f: Pick<PluginScanFinding, 'packageName' | 'packageVersion' | 'fixedIn'>): string {\n  const at = `${f.packageName}${f.packageVersion ? `@${f.packageVersion}` : ''}`;\n  return f.fixedIn.length > 0 ? `${at} → ${f.fixedIn.join(', ')}` : `${at} (no fix)`;\n}\n\n/** `CVE-1 (openssl@3.0.1 → 3.0.2); CVE-2 (…)` for the first `limit` findings. */\nexport function describeFindings(findings: readonly PluginScanFinding[], limit = 5): string {\n  const shown = findings.slice(0, limit).map((f) => `${f.id} (${describeFix(f)})`).join('; ');\n  const more = findings.length > limit ? `; +${findings.length - limit} more` : '';\n  return `${shown}${more}`;\n}\n\n/** The warning text for a flagged version: `x@v has N fixable Critical findings — rebuild or upgrade`. */\nexport function vulnFlaggedMessage(ref: string, flag: Pick<PluginScanFlag, 'critical'>): string {\n  return `${ref} has ${flag.critical} fixable Critical finding${flag.critical === 1 ? '' : 's'} — rebuild or upgrade`;\n}\n\n/** A `VULN_FLAGGED` lookup warning (the lookup envelope's `warnings[]` entry). */\nexport interface VulnFlaggedWarning {\n  code: typeof VULN_FLAGGED_WARNING;\n  plugin: string;\n  version: string;\n  critical: number;\n  high: number;\n  message: string;\n  /** Top fixable findings with their fixed versions. */\n  findings: PluginScanFinding[];\n}\n\n/** Build the `VULN_FLAGGED` warning for `plugin@version`. */\nexport function vulnFlaggedWarning(plugin: string, version: string, flag: PluginScanFlag): VulnFlaggedWarning {\n  return {\n    code: VULN_FLAGGED_WARNING,\n    plugin,\n    version,\n    critical: flag.critical,\n    high: flag.high,\n    message: vulnFlaggedMessage(`${plugin}@${version}`, flag),\n    findings: flag.findings.slice(0, SCAN_FLAG_TOP_FINDINGS),\n  };\n}\n\n/** The 409 message for an exact pin to a flagged version while blocking. */\nexport function vulnBlockedMessage(plugin: string, version: string, flag: PluginScanFlag): string {\n  const fixes = flag.findings.length > 0 ? ` Fix: ${describeFindings(flag.findings)}.` : '';\n  return `${plugin}@${version} is blocked: a rescan found ${flag.critical} fixable Critical finding${flag.critical === 1 ? '' : 's'} `\n    + `(PLUGIN_BLOCK_ON_NEW_CRITICAL). Rebuild it on patched packages or move to a newer version.${fixes}`;\n}\n\n/** Narrow an unknown `scan_flag` jsonb value. */\nexport function asScanFlag(value: unknown): PluginScanFlag | null {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;\n  const v = value as Record<string, unknown>;\n  if (typeof v.critical !== 'number' || typeof v.high !== 'number') return null;\n  const findings = Array.isArray(v.findings) ? (v.findings as PluginScanFinding[]).filter((f) => f && typeof f.id === 'string') : [];\n  return {\n    critical: v.critical,\n    high: v.high,\n    maxCritical: typeof v.maxCritical === 'number' ? v.maxCritical : 0,\n    findings: findings.map((f) => ({ ...f, fixedIn: Array.isArray(f.fixedIn) ? f.fixedIn : [] })),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-scan.js","sourceRoot":"","sources":["../../src/types/plugin-scan.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Plugin image scan gates (docs/plugin-publishing.md \"Scan gates\"): the shared\n * vocabulary of the build-time gate, the nightly rescan's flag, and the\n * resolution warning / block — used by the plugin service (which stores and\n * enforces them), the resolver in pipeline-data (which skips or warns), and the\n * dashboard (which shows them).\n *\n * A finding is FIXABLE when grype reports a fixed version for it\n * (`vulnerability.fix.state == \"fixed\"` with at least one version): the gates\n * count fixable Critical findings only, because an unfixable one can't be\n * acted on by rebuilding or upgrading.\n */\n\nimport { SYSTEM_ORG_ID } from '../middleware/system-org.js';\nimport { envBool, envInt } from '../utils/env.js';\n\n/** One Critical/High finding as the flag and the gate messages carry it. */\nexport interface PluginScanFinding {\n  /** The vulnerability id (CVE-…, GHSA-…). */\n  id: string;\n  severity: 'critical' | 'high';\n  packageName: string;\n  packageVersion: string;\n  /** Versions that fix it; empty = no fix available (not fixable). */\n  fixedIn: string[];\n}\n\n/**\n * `scan_flag` on a version the nightly rescan flagged: its fixable\n * Critical/High counts at that rescan and the top fixable findings. Set while\n * fixable Criticals exceed `PLUGIN_VULN_MAX_CRITICAL`, cleared when a rescan\n * finds them resolved.\n */\nexport interface PluginScanFlag {\n  /** Fixable Critical findings. */\n  critical: number;\n  /** Fixable High findings. */\n  high: number;\n  /** The floor it was compared against (`PLUGIN_VULN_MAX_CRITICAL`). */\n  maxCritical: number;\n  /** At most {@link SCAN_FLAG_TOP_FINDINGS} fixable findings, Criticals first. */\n  findings: PluginScanFinding[];\n}\n\n/**\n * `scan_summary` on every in-use version: the LAST rescan's findings, written\n * whether or not the gate tripped.\n *\n * Distinct from {@link PluginScanFlag}, which exists only while a version is over\n * the floor. A version carrying nothing but High findings is never flagged — so a\n * report whose job is to show Critical AND High exposure had no source to read.\n * What a report SHOWS and what a build REFUSES are different questions, and\n * conflating them meant the answer to the first was \"nothing\".\n */\nexport interface PluginScanSummary {\n  /** Fixable Critical findings at the last rescan. */\n  criticalFixable: number;\n  /** Fixable High findings at the last rescan. */\n  highFixable: number;\n  /** Totals including unfixable findings, for context. */\n  critical: number;\n  high: number;\n  /** At most {@link SCAN_FLAG_TOP_FINDINGS} findings, Criticals first. */\n  findings: PluginScanFinding[];\n  /** When the rescan that produced this ran (ISO). */\n  scannedAt: string;\n  /** The image this describes. A version rebuilt on a patched base is a\n   *  different artifact, so a summary without its digest cannot be trusted. */\n  imageDigest?: string;\n}\n\n/** Findings a flag / gate message carries. */\nexport const SCAN_FLAG_TOP_FINDINGS = 10;\n\n/** Lookup / resolution warning code for a flagged version. */\nexport const VULN_FLAGGED_WARNING = 'VULN_FLAGGED';\n\n/**\n * `PLUGIN_VULN_MAX_CRITICAL`: the platform floor — a version with MORE fixable\n * Critical findings than this fails its build (`PLUGIN_VULN_GATE`) and is\n * flagged by the rescan. Default `0`; `-1` disables the floor (and the flag).\n */\nexport function pluginVulnMaxCritical(): number {\n  return envInt('PLUGIN_VULN_MAX_CRITICAL', 0, { min: -1 });\n}\n\n/**\n * A scoped, EXPIRING exemption from the vulnerability floor for one plugin.\n *\n * `PLUGIN_VULN_MAX_CRITICAL` is the only other lever and it is far too blunt:\n * raising it above 0 exempts every plugin from every Critical. Some images\n * genuinely cannot reach zero — a browser-bundling test runner (artillery ships\n * Chromium through its own @playwright/browser-chromium dependency, playwright\n * downloads Firefox) is at upstream's latest and still carries fixable findings,\n * because browsers ship CVE fixes weekly while pinned builds lag by design.\n * Without a narrow exemption the only options are \"block the plugin forever\" or\n * \"disable the floor for everything\".\n *\n * Three properties make this an exemption rather than a hole, and all three are\n * enforced below rather than documented and hoped for:\n *\n *   SCOPED    to one plugin, to named packages, AND to the system org. A new\n *             Critical in any other package still fails the gate, so a waiver\n *             cannot grow silently into \"this plugin is exempt\". The org bound\n *             matters because plugin names are unique per (name, version,\n *             orgId) and NOT globally: without it, any tenant could inherit an\n *             exemption by naming their plugin `artillery`.\n *   EXPIRING  every entry carries a date and stops applying after it. A waiver\n *             nobody revisits becomes permanent; this one lapses on its own and\n *             the plugin starts failing again, which is the intended prompt.\n *   VISIBLE   what was waived is returned to the caller, so it reaches the\n *             metric, the audit record and the build message instead of\n *             vanishing from the count.\n *\n * Format — entries `;`-separated, fields `:`-separated, packages `,`-separated:\n *\n *   PLUGIN_VULN_WAIVERS=artillery:2026-12-31:chromium,chrome;playwright:2026-12-31:firefox\n *\n * A malformed entry is DROPPED, never treated as a wildcard: the failure mode\n * of a typo must be \"the gate still blocks\", not \"everything is waived\".\n */\nexport interface VulnWaiver {\n  /** Plugin name the waiver applies to (exact match). */\n  plugin: string;\n  /**\n   * Plugin version the waiver is limited to, or null for every version.\n   *\n   * A waiver is a judgement about a SPECIFIC image — \"this release of artillery\n   * bundles a Chromium we cannot patch\". Left unpinned it silently carries to\n   * every future version, including ones whose findings nobody has looked at,\n   * which is how a narrow exemption becomes a standing one.\n   */\n  version: string | null;\n  /** Inclusive expiry (UTC date). After it the entry has no effect. */\n  expires: Date;\n  /** Package names whose findings are exempt. Never empty — see parseVulnWaivers. */\n  packages: string[];\n}\n\n/** A dropped entry and why, so the operator can be told instead of guessing. */\nexport interface VulnWaiverProblem {\n  entry: string;\n  reason: string;\n}\n\n/** Parsed waivers plus the entries that were rejected. */\nexport interface VulnWaiverParse {\n  waivers: VulnWaiver[];\n  problems: VulnWaiverProblem[];\n}\n\n/**\n * Parse `PLUGIN_VULN_WAIVERS`, REPORTING what was dropped.\n *\n * Dropping a malformed entry is the safe direction — a typo must not become a\n * wildcard — but silently dropping it is a usability trap: the operator sets a\n * waiver, the gate keeps blocking, and nothing anywhere says why. Callers that\n * can surface it (service boot) use this; `parseVulnWaivers` is the shorthand\n * for the ones that cannot.\n *\n * Entry grammar: `<plugin>[@<version>]:<YYYY-MM-DD>:<pkg>[,<pkg>…]`\n */\nexport function parseVulnWaiversVerbose(raw: string | undefined = process.env.PLUGIN_VULN_WAIVERS): VulnWaiverParse {\n  const waivers: VulnWaiver[] = [];\n  const problems: VulnWaiverProblem[] = [];\n  if (!raw?.trim()) return { waivers, problems };\n  const reject = (entry: string, reason: string) => { problems.push({ entry: entry.trim(), reason }); };\n\n  for (const entry of raw.split(';')) {\n    if (!entry.trim()) continue;\n    const [target, expires, packages] = entry.split(':').map((f) => f?.trim() ?? '');\n    // Every field is REQUIRED. An entry missing its package list would\n    // otherwise read as \"waive this plugin entirely\", which is the one thing\n    // this must not be able to express.\n    if (!target || !expires || !packages) {\n      reject(entry, 'expected <plugin>[@<version>]:<YYYY-MM-DD>:<package>[,<package>…]');\n      continue;\n    }\n    const at = target.indexOf('@');\n    const plugin = at === -1 ? target : target.slice(0, at).trim();\n    const version = at === -1 ? null : target.slice(at + 1).trim();\n    if (!plugin) { reject(entry, 'no plugin name'); continue; }\n    if (at !== -1 && !version) { reject(entry, \"'@' with no version — omit it to cover every version\"); continue; }\n    if (!/^\\d{4}-\\d{2}-\\d{2}$/.test(expires)) { reject(entry, `expiry '${expires}' is not YYYY-MM-DD`); continue; }\n    const when = new Date(`${expires}T23:59:59.999Z`);\n    if (Number.isNaN(when.getTime())) { reject(entry, `expiry '${expires}' is not a real date`); continue; }\n    const names = packages.split(',').map((n) => n.trim()).filter(Boolean);\n    if (names.length === 0) { reject(entry, 'no package names'); continue; }\n    waivers.push({ plugin, version, expires: when, packages: names });\n  }\n  return { waivers, problems };\n}\n\n/** Parse `PLUGIN_VULN_WAIVERS`. Malformed or incomplete entries are dropped. */\nexport function parseVulnWaivers(raw: string | undefined = process.env.PLUGIN_VULN_WAIVERS): VulnWaiver[] {\n  return parseVulnWaiversVerbose(raw).waivers;\n}\n\n/** What a waiver removed from the count, and what still counts. */\nexport interface WaiverOutcome {\n  /** Findings the floor still counts. */\n  counted: PluginScanFinding[];\n  /** Findings an unexpired waiver exempted (empty when none applied). */\n  waived: PluginScanFinding[];\n}\n\n/**\n * Split findings into what still counts and what an unexpired waiver exempts.\n *\n * Matching is on the package name a waiver names, case-insensitively, and only\n * for findings that are FIXABLE — an unfixable finding never counted toward the\n * floor, so \"waiving\" it would overstate what the waiver does.\n */\nexport function applyVulnWaivers(\n  pluginName: string,\n  findings: readonly PluginScanFinding[],\n  waivers: readonly VulnWaiver[] = parseVulnWaivers(),\n  now: Date = new Date(),\n  orgId?: string,\n  pluginVersion?: string,\n): WaiverOutcome {\n  // SYSTEM ORG ONLY. Plugin names are unique per (name, version, orgId), NOT\n  // globally — any tenant can create a plugin called `artillery`. Matching on\n  // the name alone would hand every one of them the operator's exemption, so a\n  // tenant could inherit a waiver simply by choosing the name, and ship an\n  // image whose Criticals the gate then waved through. The waivers exist for the\n  // Official catalog the operator curates, which lives in the system org; a\n  // caller that cannot say which org this build belongs to gets no waiver.\n  if (orgId === undefined || orgId.toLowerCase() !== SYSTEM_ORG_ID) return { counted: [...findings], waived: [] };\n  const active = waivers.filter((w) => w.plugin === pluginName\n    && w.expires.getTime() >= now.getTime()\n    // A version-pinned waiver covers that version only. An unpinned one covers\n    // every version, which is why the pin is worth writing.\n    && (w.version === null || w.version === pluginVersion));\n  if (active.length === 0) return { counted: [...findings], waived: [] };\n  const exempt = new Set(active.flatMap((w) => w.packages.map((n) => n.toLowerCase())));\n  const counted: PluginScanFinding[] = [];\n  const waived: PluginScanFinding[] = [];\n  for (const f of findings) {\n    if (f.fixedIn.length > 0 && exempt.has(f.packageName.toLowerCase())) waived.push(f);\n    else counted.push(f);\n  }\n  return { counted, waived };\n}\n\n/** Whether `fixableCritical` breaks the platform floor (never, when disabled). */\nexport function exceedsVulnFloor(fixableCritical: number | null | undefined, max: number = pluginVulnMaxCritical()): boolean {\n  return max >= 0 && (fixableCritical ?? 0) > max;\n}\n\n/**\n * `PLUGIN_BLOCK_ON_NEW_CRITICAL` (default false): resolution SKIPS flagged\n * versions for ranges and the default (falling back to the newest unflagged\n * one), and an exact pin to a flagged version is refused 409\n * `PLUGIN_VERSION_VULN_BLOCKED`. Off: flagged versions resolve with a\n * `VULN_FLAGGED` warning.\n */\nexport function blockOnNewCritical(): boolean {\n  return envBool('PLUGIN_BLOCK_ON_NEW_CRITICAL', false);\n}\n\n/** `pkg@1.2.3 → 1.2.4` / `pkg@1.2.3 (no fix)`. */\nexport function describeFix(f: Pick<PluginScanFinding, 'packageName' | 'packageVersion' | 'fixedIn'>): string {\n  const at = `${f.packageName}${f.packageVersion ? `@${f.packageVersion}` : ''}`;\n  return f.fixedIn.length > 0 ? `${at} → ${f.fixedIn.join(', ')}` : `${at} (no fix)`;\n}\n\n/** `CVE-1 (openssl@3.0.1 → 3.0.2); CVE-2 (…)` for the first `limit` findings. */\nexport function describeFindings(findings: readonly PluginScanFinding[], limit = 5): string {\n  const shown = findings.slice(0, limit).map((f) => `${f.id} (${describeFix(f)})`).join('; ');\n  const more = findings.length > limit ? `; +${findings.length - limit} more` : '';\n  return `${shown}${more}`;\n}\n\n/** The warning text for a flagged version: `x@v has N fixable Critical findings — rebuild or upgrade`. */\nexport function vulnFlaggedMessage(ref: string, flag: Pick<PluginScanFlag, 'critical'>): string {\n  return `${ref} has ${flag.critical} fixable Critical finding${flag.critical === 1 ? '' : 's'} — rebuild or upgrade`;\n}\n\n/** A `VULN_FLAGGED` lookup warning (the lookup envelope's `warnings[]` entry). */\nexport interface VulnFlaggedWarning {\n  code: typeof VULN_FLAGGED_WARNING;\n  plugin: string;\n  version: string;\n  critical: number;\n  high: number;\n  message: string;\n  /** Top fixable findings with their fixed versions. */\n  findings: PluginScanFinding[];\n}\n\n/** Build the `VULN_FLAGGED` warning for `plugin@version`. */\nexport function vulnFlaggedWarning(plugin: string, version: string, flag: PluginScanFlag): VulnFlaggedWarning {\n  return {\n    code: VULN_FLAGGED_WARNING,\n    plugin,\n    version,\n    critical: flag.critical,\n    high: flag.high,\n    message: vulnFlaggedMessage(`${plugin}@${version}`, flag),\n    findings: flag.findings.slice(0, SCAN_FLAG_TOP_FINDINGS),\n  };\n}\n\n/** The 409 message for an exact pin to a flagged version while blocking. */\nexport function vulnBlockedMessage(plugin: string, version: string, flag: PluginScanFlag): string {\n  const fixes = flag.findings.length > 0 ? ` Fix: ${describeFindings(flag.findings)}.` : '';\n  return `${plugin}@${version} is blocked: a rescan found ${flag.critical} fixable Critical finding${flag.critical === 1 ? '' : 's'} `\n    + `(PLUGIN_BLOCK_ON_NEW_CRITICAL). Rebuild it on patched packages or move to a newer version.${fixes}`;\n}\n\n/** Narrow an unknown `scan_flag` jsonb value. */\nexport function asScanFlag(value: unknown): PluginScanFlag | null {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;\n  const v = value as Record<string, unknown>;\n  if (typeof v.critical !== 'number' || typeof v.high !== 'number') return null;\n  const findings = Array.isArray(v.findings) ? (v.findings as PluginScanFinding[]).filter((f) => f && typeof f.id === 'string') : [];\n  return {\n    critical: v.critical,\n    high: v.high,\n    maxCritical: typeof v.maxCritical === 'number' ? v.maxCritical : 0,\n    findings: findings.map((f) => ({ ...f, fixedIn: Array.isArray(f.fixedIn) ? f.fixedIn : [] })),\n  };\n}\n"]}

package/lib/types/remote-audit-actions.d.ts

@@ -17,7 +17,7 @@
  * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep
  * this list free of any platform-only action.
  */
-export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.scan.skipped', 'plugin.delete', 'plugin.restore', 'plugin.purge', 'plugin.update', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'plugin.build.retry', 'plugin.dlq.replay', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline.restore', 'pipeline.purge', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline_template.restore', 'pipeline_template.purge', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.rule.restore', 'compliance.rule.purge', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.policy.restore', 'compliance.policy.purge', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.create', 'compliance.scan.cancel', 'compliance.notification-preference.update', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'registry.image.sign', 'message.announcement.create', 'message.delete', 'message.restore', 'message.purge', 'billing.subscription.create', 'billing.subscription.update', 'billing.subscription.reactivate', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'reporting.settings.update', 'reporting.deployment.outcome', 'reporting.retention.sync', 'reporting.report.definition.create', 'reporting.report.definition.update', 'reporting.report.definition.delete', 'reporting.report.ownership.transfer', 'reporting.report.published', 'reporting.report.republished', 'reporting.report.link.created', 'reporting.report.link.revoked', 'reporting.report.recipient.added', 'reporting.report.recipient.removed', 'reporting.report.policy.update', 'reporting.report.paused', 'reporting.report.resumed', 'authz.denied', 'ask.query', 'ask.agent.turn', 'publisher.create', 'publisher.update', 'publisher.terms.accept', 'publisher.verify.request', 'publisher.verify.approve', 'publisher.verify.reject', 'publisher.tier.change', 'publisher.suspend', 'publisher.unsuspend', 'publisher.transfer.request', 'publisher.transfer.accept', 'publisher.transfer.decline', 'publisher.transfer.approve', 'publisher.transfer.reject', 'publisher.profile-change.approve', 'publisher.profile-change.reject', 'plugin.request.submit', 'plugin.request.withdraw', 'plugin.request.approve', 'plugin.request.second-approve', 'plugin.request.reject', 'plugin.request.auto-approve', 'plugin.listing.publish', 'plugin.listing.unlist', 'plugin.listing.update', 'plugin.listing.state.change', 'plugin.listing.pause', 'plugin.listing.unpause', 'plugin.version.pause', 'plugin.version.yank', 'plugin.version.unyank', 'plugin.version.deprecate', 'plugin.collection.update', 'ecosystem.auto-approval-rule.create', 'ecosystem.auto-approval-rule.update', 'ecosystem.auto-approval-rule.delete', 'ecosystem.reserved-name.update', 'ecosystem.sla.update', 'registry.image.publish', 'registry.image.resign', 'registry.image.yank', 'registry.image.gc', 'plugin.install.request', 'plugin.install.approve', 'plugin.install.deny', 'plugin.install.create', 'plugin.install.upgrade', 'plugin.install.change-request', 'plugin.install.change-approve', 'plugin.install.change-reject', 'plugin.install.remove', 'org.plugin-install-policy.update', 'plugin.review.create', 'plugin.review.update', 'plugin.review.delete', 'plugin.review.report', 'plugin.review.hold', 'plugin.review.release', 'plugin.review.remove', 'plugin.review.anonymize', 'plugin.review.reply.create', 'plugin.review.reply.update', 'plugin.review.reply.delete', 'plugin.submission.create', 'plugin.submission.verify', 'plugin.submission.gate-fail', 'plugin.submission.approve', 'plugin.submission.reject', 'plugin.submission.claim', 'plugin.submission.expire', 'plugin.advisory.create', 'plugin.advisory.update', 'plugin.advisory.publish', 'plugin.advisory.withdraw', 'plugin.security_notifications.update', 'plugin.security_notifications.external_email.verify', 'plugin.security_notifications.test'];
+export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.scan.skipped', 'plugin.vuln.waived', 'plugin.delete', 'plugin.restore', 'plugin.purge', 'plugin.update', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'plugin.build.retry', 'plugin.dlq.replay', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline.restore', 'pipeline.purge', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline_template.restore', 'pipeline_template.purge', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.rule.restore', 'compliance.rule.purge', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.policy.restore', 'compliance.policy.purge', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.create', 'compliance.scan.cancel', 'compliance.notification-preference.update', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'registry.image.sign', 'message.announcement.create', 'message.delete', 'message.restore', 'message.purge', 'billing.subscription.create', 'billing.subscription.update', 'billing.subscription.reactivate', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'reporting.settings.update', 'reporting.deployment.outcome', 'reporting.retention.sync', 'reporting.report.definition.create', 'reporting.report.definition.update', 'reporting.report.definition.delete', 'reporting.report.ownership.transfer', 'reporting.report.published', 'reporting.report.republished', 'reporting.report.link.created', 'reporting.report.link.revoked', 'reporting.report.recipient.added', 'reporting.report.recipient.removed', 'reporting.report.policy.update', 'reporting.report.paused', 'reporting.report.resumed', 'authz.denied', 'ask.query', 'ask.agent.turn', 'publisher.create', 'publisher.update', 'publisher.terms.accept', 'publisher.verify.request', 'publisher.verify.approve', 'publisher.verify.reject', 'publisher.tier.change', 'publisher.suspend', 'publisher.unsuspend', 'publisher.transfer.request', 'publisher.transfer.accept', 'publisher.transfer.decline', 'publisher.transfer.approve', 'publisher.transfer.reject', 'publisher.profile-change.approve', 'publisher.profile-change.reject', 'plugin.request.submit', 'plugin.request.withdraw', 'plugin.request.approve', 'plugin.request.second-approve', 'plugin.request.reject', 'plugin.request.auto-approve', 'plugin.listing.publish', 'plugin.listing.unlist', 'plugin.listing.update', 'plugin.listing.state.change', 'plugin.listing.pause', 'plugin.listing.unpause', 'plugin.version.pause', 'plugin.version.yank', 'plugin.version.unyank', 'plugin.version.deprecate', 'plugin.collection.update', 'ecosystem.auto-approval-rule.create', 'ecosystem.auto-approval-rule.update', 'ecosystem.auto-approval-rule.delete', 'ecosystem.reserved-name.update', 'ecosystem.sla.update', 'registry.image.publish', 'registry.image.resign', 'registry.image.yank', 'registry.image.gc', 'plugin.install.request', 'plugin.install.approve', 'plugin.install.deny', 'plugin.install.create', 'plugin.install.upgrade', 'plugin.install.change-request', 'plugin.install.change-approve', 'plugin.install.change-reject', 'plugin.install.remove', 'org.plugin-install-policy.update', 'plugin.review.create', 'plugin.review.update', 'plugin.review.delete', 'plugin.review.report', 'plugin.review.hold', 'plugin.review.release', 'plugin.review.remove', 'plugin.review.anonymize', 'plugin.review.reply.create', 'plugin.review.reply.update', 'plugin.review.reply.delete', 'plugin.submission.create', 'plugin.submission.verify', 'plugin.submission.gate-fail', 'plugin.submission.approve', 'plugin.submission.reject', 'plugin.submission.claim', 'plugin.submission.expire', 'plugin.advisory.create', 'plugin.advisory.update', 'plugin.advisory.publish', 'plugin.advisory.withdraw', 'plugin.security_notifications.update', 'plugin.security_notifications.external_email.verify', 'plugin.security_notifications.test'];
 export type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];
 /** Whether `value` is an action a remote service may emit (the ingest allow-list). */
 export declare function isRemoteAuditAction(value: string): value is RemoteAuditAction;

package/lib/types/remote-audit-actions.js

@@ -27,6 +27,13 @@ export const REMOTE_AUDIT_ACTIONS = [
     // the operator escape hatch `PLUGIN_ALLOW_UNSCANNED` is on (without it the
     // build fails `IMAGE_SCAN_UNAVAILABLE`). `details` carry name/version/digest.
     'plugin.scan.skipped',
+    // Fixable Critical findings were EXEMPTED from the platform floor by a
+    // `PLUGIN_VULN_WAIVERS` entry, so a build that would otherwise have failed
+    // PLUGIN_VULN_GATE was allowed through. The other half of plugin.scan.skipped:
+    // both are operator escape hatches that change a gate's verdict, and a metric
+    // and a log line are not a durable record of one. `details` carry
+    // name/version/digest, how many findings were waived and which packages.
+    'plugin.vuln.waived',
     // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /
     // publishing surface that builds already audit's counterpart: registry delete,
     // source upload, and deploy-to-cluster. `targetId` is the plugin id.
@@ -336,4 +343,4 @@ export const REMOTE_AUDIT_ACTIONS = [
 export function isRemoteAuditAction(value) {
     return REMOTE_AUDIT_ACTIONS.includes(value);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-actions.js","sourceRoot":"","sources":["../../src/types/remote-audit-actions.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The remote (non-platform) audit ACTION VOCABULARY.\n *\n * Kept apart from the client that ships the events (`services/remote-audit-client.ts`)\n * because it is an allow-list, not machinery: it is the thing a reviewer reads\n * end to end when deciding whether a service may emit a given action, and it is\n * what platform's ingest validates against.\n */\n\n\n/**\n * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to\n * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`\n * is derived from it, so the type and the runtime allow-list can never drift.\n *\n * SECURITY: platform's ingest validates `action` against this subset (via\n * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a\n * `service:*` token must not be able to forge platform-authority events\n * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep\n * this list free of any platform-only action.\n */\nexport const REMOTE_AUDIT_ACTIONS = [\n  'plugin.build.completed',\n  'plugin.build.failed',\n  'plugin.build.timeout',\n  // A version persisted UNSCANNED because the build-time scan could not run and\n  // the operator escape hatch `PLUGIN_ALLOW_UNSCANNED` is on (without it the\n  // build fails `IMAGE_SCAN_UNAVAILABLE`). `details` carry name/version/digest.\n  'plugin.scan.skipped',\n  // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /\n  // publishing surface that builds already audit's counterpart: registry delete,\n  // source upload, and deploy-to-cluster. `targetId` is the plugin id.\n  'plugin.delete',\n  'plugin.restore',\n  // Manual purge: permanent hard-delete of a soft-deleted plugin tombstone on\n  // demand (finalizes what the retention sweep would otherwise do later).\n  'plugin.purge',\n  'plugin.update',\n  'plugin.upload',\n  'plugin.deploy',\n  // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all\n  // dead-lettered build jobs, cross-org, sysadmin). `details` carries counts.\n  'plugin.bulk.update',\n  'plugin.bulk.delete',\n  'plugin.dlq.purge',\n  // Build re-runs from the queue-triage surface: re-enqueue a FAILED build\n  // (`plugin.build.retry`) or a dead-lettered one (`plugin.dlq.replay`). Both\n  // re-run an image build + plugin persist on the caller's authority, so they\n  // are audited mutations; `affectedOrgId` carries the job's owning org.\n  'plugin.build.retry',\n  'plugin.dlq.replay',\n  // Pipeline mutations — emitted by api/pipeline's route handlers\n  // (create/update/delete + CodePipeline execution trigger/cancel) and\n  // posted to platform's `POST /audit/events` ingest.\n  'pipeline.create',\n  'pipeline.update',\n  'pipeline.delete',\n  'pipeline.restore',\n  // Manual purge: permanent hard-delete of a soft-deleted pipeline /\n  // pipeline_template tombstone on demand (finalizes what the retention sweep\n  // would otherwise do later). `targetId` is the purged id.\n  'pipeline.purge',\n  'pipeline_template.create',\n  'pipeline_template.update',\n  'pipeline_template.delete',\n  'pipeline_template.restore',\n  'pipeline_template.purge',\n  'pipeline.execution.start',\n  'pipeline.execution.cancel',\n  // CodePipeline ARN-registry config (api/pipeline registry route) — registering /\n  // deregistering the external CodePipeline that backs a pipeline (deploy-affecting).\n  'pipeline.registry.register',\n  'pipeline.registry.deregister',\n  // Quota administration (api/quota) — a superadmin resetting an org's usage\n  // counter or editing its tier limits. `affectedOrgId` is the org changed;\n  // `details` carries the quotaType + old/new value.\n  'quota.reset',\n  'quota.limit.update',\n  // A superadmin deleting an org's entire quota document.\n  'quota.delete',\n  // Compliance administration (api/compliance) — the enforcement-posture surface.\n  // Approving/revoking an exemption, toggling/authoring/deleting a rule,\n  // authoring/deleting a policy, managing scan schedules, applying a template,\n  // or cancelling a running scan. `targetId` is the rule/policy/exemption/scan id.\n  'compliance.exemption.approve',\n  'compliance.exemption.revoke',\n  'compliance.rule.toggle',\n  'compliance.rule.create',\n  'compliance.rule.update',\n  'compliance.rule.delete',\n  'compliance.rule.restore',\n  // Manual on-demand hard-delete (PURGE) of a soft-deleted rule/policy tombstone —\n  // the caller-initiated counterpart to the retention sweep's auto-purge. Destroys\n  // the tombstone permanently, so it carries the durable, tamper-evident trail.\n  'compliance.rule.purge',\n  'compliance.policy.create',\n  'compliance.policy.update',\n  'compliance.policy.delete',\n  'compliance.policy.restore',\n  'compliance.policy.purge',\n  'compliance.scan-schedule.create',\n  'compliance.scan-schedule.update',\n  'compliance.scan-schedule.delete',\n  'compliance.template.apply',\n  // Launching an org-wide re-evaluation (the counterpart to `.cancel`) — it\n  // persists a scan and can block entities that passed before.\n  'compliance.scan.create',\n  'compliance.scan.cancel',\n  // Per-org compliance notification settings: recipients + the outbound webhook\n  // URL/secret. Bearer-equivalent config that redirects violation notices, so a\n  // change carries the durable trail (never the secret itself).\n  'compliance.notification-preference.update',\n  // Image-registry destructive ops (api/image-registry) — garbage-collection\n  // sweeps and explicit image/tag deletes.\n  'registry.gc',\n  'registry.image.delete',\n  // Cross-repo tag/image copy (api/image-registry POST /api/images/copy). A\n  // cross-tenant copy moves data across customer boundaries, so it needs the\n  // durable, tamper-evident trail — not just the Loki operator line.\n  'registry.image.copy',\n  // A plugin image signed + SBOM-attested by the platform's plugin-signing key\n  // (api/image-registry POST /internal/plugin-signatures, called by the plugin\n  // build worker). The key is what synth trusts, so every use is on the trail.\n  'registry.image.sign',\n  // Messaging (api/message) — admin BROADCAST announcements + destructive\n  // deletes. 1:1 user messages are intentionally NOT audited (noise + they would\n  // pull private content into the trail). `details` carry metadata only\n  // (subject/type/scope), NEVER message body content.\n  'message.announcement.create',\n  'message.delete',\n  'message.restore',\n  // Manual on-demand PURGE (permanent hard-delete) of an already-soft-deleted\n  // message tombstone — the destructive finalizer the retention sweep would\n  // otherwise perform at the purge deadline. `details` carry metadata only.\n  'message.purge',\n  // Billing (api/billing) — subscription + entitlement mutations, mirrored to the\n  // central audit trail (these also write to the service-local billing_events\n  // collection). `details` carry plan/tier/addon ids only — never card/payment\n  // secrets or an AWS account id.\n  // Subscription lifecycle a CUSTOMER drives (the admin counterpart is\n  // `billing.tier.override`): self-serve create (direct or Marketplace claim),\n  // plan/interval change, cancel-at-period-end, undo-cancel, cascade delete.\n  'billing.subscription.create',\n  'billing.subscription.update',\n  'billing.subscription.reactivate',\n  'billing.subscription.cancel',\n  'billing.subscription.delete',\n  'billing.tier.override',\n  // Operator-only reseed of the invoice ledger from the payment provider's\n  // history (POST /billing/admin/backfill) — mutates finance data fleet-wide.\n  'billing.addon.add',\n  'billing.addon.remove',\n  // System-initiated removal of a tier-included add-on on a plan upgrade (the\n  // account's new tier now bundles the feature) — distinct from a user-initiated\n  // `remove` so finance can tell an auto-prune from a customer action.\n  'billing.addon.prune',\n  // Discounts (docs/billing-discounts.md) — mint/issue/apply/remove/revoke of a\n  // price coupon or usage credit. `details` carry the discount id + kind/value\n  // only, never the opaque token or signing key.\n  'billing.discount.generate',\n  'billing.discount.issue',\n  'billing.discount.apply',\n  'billing.discount.remove',\n  'billing.discount.revoke',\n  // Promotions (docs/billing-discounts.md#promotions) — rule-driven auto-grant\n  // campaigns. `details` carry the promotion id + cents/event only.\n  'billing.promotion.create',\n  'billing.promotion.update',\n  'billing.promotion.revoke',\n  'billing.promotion.grant',\n  'billing.promotion.activate',\n  // Usage-credit realization — a customer/compliance-visible record of credit\n  // movement: `consumed` (Marketplace metered drawdown), `exhausted` (balance hit\n  // zero), and a combo ending. `details` carry cents/ids only, no payment secrets.\n  'billing.credit.consumed',\n  'billing.credit.exhausted',\n  'billing.combo.expired',\n  // Reporting (api/reporting) — the three reporting mutations whose effect\n  // outlives a request log: the per-org correlation-window config write, a\n  // post-deploy outcome marker (it moves the org's DORA CFR/MTTR), and the\n  // inbound billing→reporting retention-entitlement sync (a retention cut is a\n  // data-destroying change applied by the next sweep). `details` carry the\n  // settings/outcome values only.\n  'reporting.settings.update',\n  'reporting.deployment.outcome',\n  'reporting.retention.sync',\n  // Stakeholder reports — the add-on's authoring and PUBLISHING surface. Publishing\n  // is the moment internal delivery numbers leave the platform, so the whole\n  // outward path is auditable: which report, which period's frozen snapshot,\n  // which version, and who let it out. `link.created` / `link.revoked` cover the\n  // URLs that let someone without an account read it; `recipient.added` /\n  // `recipient.removed` cover who is on the distribution list, which is the other\n  // way data reaches a person. `ownership.transfer` is a privilege move: a\n  // scheduled run is authorized as its OWNER, so handing a definition over hands\n  // over whose access the numbers are computed with.\n  //\n  // Deliberately NOT audited: reading a shared report. The access is logged and\n  // counted per link, but it is an UNAUTHENTICATED, externally-triggered event —\n  // anyone holding a URL could otherwise write unbounded rows into the org's audit\n  // trail, which turns a read into a way to bury the entries that matter.\n  'reporting.report.definition.create',\n  'reporting.report.definition.update',\n  'reporting.report.definition.delete',\n  'reporting.report.ownership.transfer',\n  'reporting.report.published',\n  'reporting.report.republished',\n  'reporting.report.link.created',\n  'reporting.report.link.revoked',\n  'reporting.report.recipient.added',\n  'reporting.report.recipient.removed',\n  'reporting.report.policy.update',\n  // A definition STOPPED producing reports without anyone asking it to: the owner\n  // was deactivated or removed, or lost the permission a run is authorized with.\n  // Recorded because the effect is silent — a manager finds out by not receiving\n  // the report — so the trail has to say which reports stopped and why.\n  'reporting.report.paused',\n  // …and started again. Its own action rather than a detail on the pause, because the\n  // question a reviewer asks is \"was this account's reporting off between these two\n  // dates\", and answering it from a single action's details means reading every row.\n  'reporting.report.resumed',\n  // Denied authorization attempt — emitted best-effort by the shared\n  // `requirePermission` / `requireSystemAdmin` gate when a state-changing\n  // (non-GET) request is rejected, so probing/escalation attempts are visible\n  // rather than invisible. `details` carries the required permission + path;\n  // `outcome` is 'failure'.\n  'authz.denied',\n  // \"Ask\" assistant activity — visibility into what the assistant did on a user's\n  // behalf. `ask.query` is a read-only how-to turn; `ask.agent.turn` is a tool-calling\n  // turn. `details` carry SAFE METADATA ONLY (tools used, proposal kinds, query\n  // length, outcome), never the raw query text.\n  'ask.query',\n  'ask.agent.turn',\n  // Plugin ecosystem (docs/runbooks/ecosystem-moderation.md). Governance actions\n  // are recorded with `orgId` = the system org; `affectedOrgId` is the\n  // publisher's org (listing/version/review/advisory/publisher moderation) or\n  // the installing org (installs + policy). Anonymous submissions use the\n  // `ANONYMOUS_ACTOR_ID` actor with `details.submissionId`. `details` carry ids,\n  // versions, digests, tier, state and reason codes only — never review bodies,\n  // README content, secrets or emails.\n  // Publishers.\n  'publisher.create',\n  'publisher.update',\n  'publisher.terms.accept',\n  'publisher.verify.request',\n  'publisher.verify.approve',\n  'publisher.verify.reject',\n  'publisher.tier.change',\n  'publisher.suspend',\n  'publisher.unsuspend',\n  'publisher.transfer.request',\n  'publisher.transfer.accept',\n  'publisher.transfer.decline',\n  'publisher.transfer.approve',\n  'publisher.transfer.reject',\n  'publisher.profile-change.approve',\n  'publisher.profile-change.reject',\n  // Publish requests (tenant → system org). `details.kind` names the request.\n  'plugin.request.submit',\n  'plugin.request.withdraw',\n  'plugin.request.approve',\n  'plugin.request.second-approve',\n  'plugin.request.reject',\n  'plugin.request.auto-approve',\n  // Listings and versions (system org, except the tenant pause).\n  'plugin.listing.publish',\n  'plugin.listing.unlist',\n  'plugin.listing.update',\n  'plugin.listing.state.change',\n  'plugin.listing.pause',\n  'plugin.listing.unpause',\n  'plugin.version.pause',\n  'plugin.version.yank',\n  'plugin.version.unyank',\n  'plugin.version.deprecate',\n  'plugin.collection.update',\n  // Ecosystem configuration (system org).\n  'ecosystem.auto-approval-rule.create',\n  'ecosystem.auto-approval-rule.update',\n  'ecosystem.auto-approval-rule.delete',\n  'ecosystem.reserved-name.update',\n  'ecosystem.sla.update',\n  // Public registry namespace (`public/*`): copy + sign + attest on publish,\n  // the tier-change/suspension re-sign job, tag removal on yank/takedown, and\n  // the retention sweep.\n  'registry.image.publish',\n  'registry.image.resign',\n  'registry.image.yank',\n  'registry.image.gc',\n  // Installs and the installing org's consumption policy (org-local).\n  'plugin.install.request',\n  'plugin.install.approve',\n  'plugin.install.deny',\n  'plugin.install.create',\n  'plugin.install.upgrade',\n  // A member's request to change an install past what they may do alone, and its decision.\n  'plugin.install.change-request',\n  'plugin.install.change-approve',\n  'plugin.install.change-reject',\n  'plugin.install.remove',\n  'org.plugin-install-policy.update',\n  // Reviews and replies.\n  'plugin.review.create',\n  'plugin.review.update',\n  'plugin.review.delete',\n  'plugin.review.report',\n  'plugin.review.hold',\n  'plugin.review.release',\n  'plugin.review.remove',\n  'plugin.review.anonymize',\n  'plugin.review.reply.create',\n  'plugin.review.reply.update',\n  'plugin.review.reply.delete',\n  // Anonymous submissions.\n  'plugin.submission.create',\n  'plugin.submission.verify',\n  'plugin.submission.gate-fail',\n  'plugin.submission.approve',\n  'plugin.submission.reject',\n  'plugin.submission.claim',\n  'plugin.submission.expire',\n  // Security advisories (publish/withdraw are system-org only; update = a\n  // moderator editing a draft before it is published).\n  'plugin.advisory.create',\n  'plugin.advisory.update',\n  'plugin.advisory.publish',\n  'plugin.advisory.withdraw',\n  // Per-org plugin security notifications (plugin scan gates): the settings\n  // (recipients, digest, webhook, external address — changed field names and\n  // the webhook host only, never the secret or the address), an external\n  // address confirmed through its emailed single-use link, and a test send.\n  'plugin.security_notifications.update',\n  'plugin.security_notifications.external_email.verify',\n  'plugin.security_notifications.test',\n] as const;\n\nexport type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];\n\n/** Whether `value` is an action a remote service may emit (the ingest allow-list). */\nexport function isRemoteAuditAction(value: string): value is RemoteAuditAction {\n  return (REMOTE_AUDIT_ACTIONS as readonly string[]).includes(value);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-actions.js","sourceRoot":"","sources":["../../src/types/remote-audit-actions.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The remote (non-platform) audit ACTION VOCABULARY.\n *\n * Kept apart from the client that ships the events (`services/remote-audit-client.ts`)\n * because it is an allow-list, not machinery: it is the thing a reviewer reads\n * end to end when deciding whether a service may emit a given action, and it is\n * what platform's ingest validates against.\n */\n\n\n/**\n * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to\n * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`\n * is derived from it, so the type and the runtime allow-list can never drift.\n *\n * SECURITY: platform's ingest validates `action` against this subset (via\n * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a\n * `service:*` token must not be able to forge platform-authority events\n * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep\n * this list free of any platform-only action.\n */\nexport const REMOTE_AUDIT_ACTIONS = [\n  'plugin.build.completed',\n  'plugin.build.failed',\n  'plugin.build.timeout',\n  // A version persisted UNSCANNED because the build-time scan could not run and\n  // the operator escape hatch `PLUGIN_ALLOW_UNSCANNED` is on (without it the\n  // build fails `IMAGE_SCAN_UNAVAILABLE`). `details` carry name/version/digest.\n  'plugin.scan.skipped',\n  // Fixable Critical findings were EXEMPTED from the platform floor by a\n  // `PLUGIN_VULN_WAIVERS` entry, so a build that would otherwise have failed\n  // PLUGIN_VULN_GATE was allowed through. The other half of plugin.scan.skipped:\n  // both are operator escape hatches that change a gate's verdict, and a metric\n  // and a log line are not a durable record of one. `details` carry\n  // name/version/digest, how many findings were waived and which packages.\n  'plugin.vuln.waived',\n  // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /\n  // publishing surface that builds already audit's counterpart: registry delete,\n  // source upload, and deploy-to-cluster. `targetId` is the plugin id.\n  'plugin.delete',\n  'plugin.restore',\n  // Manual purge: permanent hard-delete of a soft-deleted plugin tombstone on\n  // demand (finalizes what the retention sweep would otherwise do later).\n  'plugin.purge',\n  'plugin.update',\n  'plugin.upload',\n  'plugin.deploy',\n  // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all\n  // dead-lettered build jobs, cross-org, sysadmin). `details` carries counts.\n  'plugin.bulk.update',\n  'plugin.bulk.delete',\n  'plugin.dlq.purge',\n  // Build re-runs from the queue-triage surface: re-enqueue a FAILED build\n  // (`plugin.build.retry`) or a dead-lettered one (`plugin.dlq.replay`). Both\n  // re-run an image build + plugin persist on the caller's authority, so they\n  // are audited mutations; `affectedOrgId` carries the job's owning org.\n  'plugin.build.retry',\n  'plugin.dlq.replay',\n  // Pipeline mutations — emitted by api/pipeline's route handlers\n  // (create/update/delete + CodePipeline execution trigger/cancel) and\n  // posted to platform's `POST /audit/events` ingest.\n  'pipeline.create',\n  'pipeline.update',\n  'pipeline.delete',\n  'pipeline.restore',\n  // Manual purge: permanent hard-delete of a soft-deleted pipeline /\n  // pipeline_template tombstone on demand (finalizes what the retention sweep\n  // would otherwise do later). `targetId` is the purged id.\n  'pipeline.purge',\n  'pipeline_template.create',\n  'pipeline_template.update',\n  'pipeline_template.delete',\n  'pipeline_template.restore',\n  'pipeline_template.purge',\n  'pipeline.execution.start',\n  'pipeline.execution.cancel',\n  // CodePipeline ARN-registry config (api/pipeline registry route) — registering /\n  // deregistering the external CodePipeline that backs a pipeline (deploy-affecting).\n  'pipeline.registry.register',\n  'pipeline.registry.deregister',\n  // Quota administration (api/quota) — a superadmin resetting an org's usage\n  // counter or editing its tier limits. `affectedOrgId` is the org changed;\n  // `details` carries the quotaType + old/new value.\n  'quota.reset',\n  'quota.limit.update',\n  // A superadmin deleting an org's entire quota document.\n  'quota.delete',\n  // Compliance administration (api/compliance) — the enforcement-posture surface.\n  // Approving/revoking an exemption, toggling/authoring/deleting a rule,\n  // authoring/deleting a policy, managing scan schedules, applying a template,\n  // or cancelling a running scan. `targetId` is the rule/policy/exemption/scan id.\n  'compliance.exemption.approve',\n  'compliance.exemption.revoke',\n  'compliance.rule.toggle',\n  'compliance.rule.create',\n  'compliance.rule.update',\n  'compliance.rule.delete',\n  'compliance.rule.restore',\n  // Manual on-demand hard-delete (PURGE) of a soft-deleted rule/policy tombstone —\n  // the caller-initiated counterpart to the retention sweep's auto-purge. Destroys\n  // the tombstone permanently, so it carries the durable, tamper-evident trail.\n  'compliance.rule.purge',\n  'compliance.policy.create',\n  'compliance.policy.update',\n  'compliance.policy.delete',\n  'compliance.policy.restore',\n  'compliance.policy.purge',\n  'compliance.scan-schedule.create',\n  'compliance.scan-schedule.update',\n  'compliance.scan-schedule.delete',\n  'compliance.template.apply',\n  // Launching an org-wide re-evaluation (the counterpart to `.cancel`) — it\n  // persists a scan and can block entities that passed before.\n  'compliance.scan.create',\n  'compliance.scan.cancel',\n  // Per-org compliance notification settings: recipients + the outbound webhook\n  // URL/secret. Bearer-equivalent config that redirects violation notices, so a\n  // change carries the durable trail (never the secret itself).\n  'compliance.notification-preference.update',\n  // Image-registry destructive ops (api/image-registry) — garbage-collection\n  // sweeps and explicit image/tag deletes.\n  'registry.gc',\n  'registry.image.delete',\n  // Cross-repo tag/image copy (api/image-registry POST /api/images/copy). A\n  // cross-tenant copy moves data across customer boundaries, so it needs the\n  // durable, tamper-evident trail — not just the Loki operator line.\n  'registry.image.copy',\n  // A plugin image signed + SBOM-attested by the platform's plugin-signing key\n  // (api/image-registry POST /internal/plugin-signatures, called by the plugin\n  // build worker). The key is what synth trusts, so every use is on the trail.\n  'registry.image.sign',\n  // Messaging (api/message) — admin BROADCAST announcements + destructive\n  // deletes. 1:1 user messages are intentionally NOT audited (noise + they would\n  // pull private content into the trail). `details` carry metadata only\n  // (subject/type/scope), NEVER message body content.\n  'message.announcement.create',\n  'message.delete',\n  'message.restore',\n  // Manual on-demand PURGE (permanent hard-delete) of an already-soft-deleted\n  // message tombstone — the destructive finalizer the retention sweep would\n  // otherwise perform at the purge deadline. `details` carry metadata only.\n  'message.purge',\n  // Billing (api/billing) — subscription + entitlement mutations, mirrored to the\n  // central audit trail (these also write to the service-local billing_events\n  // collection). `details` carry plan/tier/addon ids only — never card/payment\n  // secrets or an AWS account id.\n  // Subscription lifecycle a CUSTOMER drives (the admin counterpart is\n  // `billing.tier.override`): self-serve create (direct or Marketplace claim),\n  // plan/interval change, cancel-at-period-end, undo-cancel, cascade delete.\n  'billing.subscription.create',\n  'billing.subscription.update',\n  'billing.subscription.reactivate',\n  'billing.subscription.cancel',\n  'billing.subscription.delete',\n  'billing.tier.override',\n  // Operator-only reseed of the invoice ledger from the payment provider's\n  // history (POST /billing/admin/backfill) — mutates finance data fleet-wide.\n  'billing.addon.add',\n  'billing.addon.remove',\n  // System-initiated removal of a tier-included add-on on a plan upgrade (the\n  // account's new tier now bundles the feature) — distinct from a user-initiated\n  // `remove` so finance can tell an auto-prune from a customer action.\n  'billing.addon.prune',\n  // Discounts (docs/billing-discounts.md) — mint/issue/apply/remove/revoke of a\n  // price coupon or usage credit. `details` carry the discount id + kind/value\n  // only, never the opaque token or signing key.\n  'billing.discount.generate',\n  'billing.discount.issue',\n  'billing.discount.apply',\n  'billing.discount.remove',\n  'billing.discount.revoke',\n  // Promotions (docs/billing-discounts.md#promotions) — rule-driven auto-grant\n  // campaigns. `details` carry the promotion id + cents/event only.\n  'billing.promotion.create',\n  'billing.promotion.update',\n  'billing.promotion.revoke',\n  'billing.promotion.grant',\n  'billing.promotion.activate',\n  // Usage-credit realization — a customer/compliance-visible record of credit\n  // movement: `consumed` (Marketplace metered drawdown), `exhausted` (balance hit\n  // zero), and a combo ending. `details` carry cents/ids only, no payment secrets.\n  'billing.credit.consumed',\n  'billing.credit.exhausted',\n  'billing.combo.expired',\n  // Reporting (api/reporting) — the three reporting mutations whose effect\n  // outlives a request log: the per-org correlation-window config write, a\n  // post-deploy outcome marker (it moves the org's DORA CFR/MTTR), and the\n  // inbound billing→reporting retention-entitlement sync (a retention cut is a\n  // data-destroying change applied by the next sweep). `details` carry the\n  // settings/outcome values only.\n  'reporting.settings.update',\n  'reporting.deployment.outcome',\n  'reporting.retention.sync',\n  // Stakeholder reports — the add-on's authoring and PUBLISHING surface. Publishing\n  // is the moment internal delivery numbers leave the platform, so the whole\n  // outward path is auditable: which report, which period's frozen snapshot,\n  // which version, and who let it out. `link.created` / `link.revoked` cover the\n  // URLs that let someone without an account read it; `recipient.added` /\n  // `recipient.removed` cover who is on the distribution list, which is the other\n  // way data reaches a person. `ownership.transfer` is a privilege move: a\n  // scheduled run is authorized as its OWNER, so handing a definition over hands\n  // over whose access the numbers are computed with.\n  //\n  // Deliberately NOT audited: reading a shared report. The access is logged and\n  // counted per link, but it is an UNAUTHENTICATED, externally-triggered event —\n  // anyone holding a URL could otherwise write unbounded rows into the org's audit\n  // trail, which turns a read into a way to bury the entries that matter.\n  'reporting.report.definition.create',\n  'reporting.report.definition.update',\n  'reporting.report.definition.delete',\n  'reporting.report.ownership.transfer',\n  'reporting.report.published',\n  'reporting.report.republished',\n  'reporting.report.link.created',\n  'reporting.report.link.revoked',\n  'reporting.report.recipient.added',\n  'reporting.report.recipient.removed',\n  'reporting.report.policy.update',\n  // A definition STOPPED producing reports without anyone asking it to: the owner\n  // was deactivated or removed, or lost the permission a run is authorized with.\n  // Recorded because the effect is silent — a manager finds out by not receiving\n  // the report — so the trail has to say which reports stopped and why.\n  'reporting.report.paused',\n  // …and started again. Its own action rather than a detail on the pause, because the\n  // question a reviewer asks is \"was this account's reporting off between these two\n  // dates\", and answering it from a single action's details means reading every row.\n  'reporting.report.resumed',\n  // Denied authorization attempt — emitted best-effort by the shared\n  // `requirePermission` / `requireSystemAdmin` gate when a state-changing\n  // (non-GET) request is rejected, so probing/escalation attempts are visible\n  // rather than invisible. `details` carries the required permission + path;\n  // `outcome` is 'failure'.\n  'authz.denied',\n  // \"Ask\" assistant activity — visibility into what the assistant did on a user's\n  // behalf. `ask.query` is a read-only how-to turn; `ask.agent.turn` is a tool-calling\n  // turn. `details` carry SAFE METADATA ONLY (tools used, proposal kinds, query\n  // length, outcome), never the raw query text.\n  'ask.query',\n  'ask.agent.turn',\n  // Plugin ecosystem (docs/runbooks/ecosystem-moderation.md). Governance actions\n  // are recorded with `orgId` = the system org; `affectedOrgId` is the\n  // publisher's org (listing/version/review/advisory/publisher moderation) or\n  // the installing org (installs + policy). Anonymous submissions use the\n  // `ANONYMOUS_ACTOR_ID` actor with `details.submissionId`. `details` carry ids,\n  // versions, digests, tier, state and reason codes only — never review bodies,\n  // README content, secrets or emails.\n  // Publishers.\n  'publisher.create',\n  'publisher.update',\n  'publisher.terms.accept',\n  'publisher.verify.request',\n  'publisher.verify.approve',\n  'publisher.verify.reject',\n  'publisher.tier.change',\n  'publisher.suspend',\n  'publisher.unsuspend',\n  'publisher.transfer.request',\n  'publisher.transfer.accept',\n  'publisher.transfer.decline',\n  'publisher.transfer.approve',\n  'publisher.transfer.reject',\n  'publisher.profile-change.approve',\n  'publisher.profile-change.reject',\n  // Publish requests (tenant → system org). `details.kind` names the request.\n  'plugin.request.submit',\n  'plugin.request.withdraw',\n  'plugin.request.approve',\n  'plugin.request.second-approve',\n  'plugin.request.reject',\n  'plugin.request.auto-approve',\n  // Listings and versions (system org, except the tenant pause).\n  'plugin.listing.publish',\n  'plugin.listing.unlist',\n  'plugin.listing.update',\n  'plugin.listing.state.change',\n  'plugin.listing.pause',\n  'plugin.listing.unpause',\n  'plugin.version.pause',\n  'plugin.version.yank',\n  'plugin.version.unyank',\n  'plugin.version.deprecate',\n  'plugin.collection.update',\n  // Ecosystem configuration (system org).\n  'ecosystem.auto-approval-rule.create',\n  'ecosystem.auto-approval-rule.update',\n  'ecosystem.auto-approval-rule.delete',\n  'ecosystem.reserved-name.update',\n  'ecosystem.sla.update',\n  // Public registry namespace (`public/*`): copy + sign + attest on publish,\n  // the tier-change/suspension re-sign job, tag removal on yank/takedown, and\n  // the retention sweep.\n  'registry.image.publish',\n  'registry.image.resign',\n  'registry.image.yank',\n  'registry.image.gc',\n  // Installs and the installing org's consumption policy (org-local).\n  'plugin.install.request',\n  'plugin.install.approve',\n  'plugin.install.deny',\n  'plugin.install.create',\n  'plugin.install.upgrade',\n  // A member's request to change an install past what they may do alone, and its decision.\n  'plugin.install.change-request',\n  'plugin.install.change-approve',\n  'plugin.install.change-reject',\n  'plugin.install.remove',\n  'org.plugin-install-policy.update',\n  // Reviews and replies.\n  'plugin.review.create',\n  'plugin.review.update',\n  'plugin.review.delete',\n  'plugin.review.report',\n  'plugin.review.hold',\n  'plugin.review.release',\n  'plugin.review.remove',\n  'plugin.review.anonymize',\n  'plugin.review.reply.create',\n  'plugin.review.reply.update',\n  'plugin.review.reply.delete',\n  // Anonymous submissions.\n  'plugin.submission.create',\n  'plugin.submission.verify',\n  'plugin.submission.gate-fail',\n  'plugin.submission.approve',\n  'plugin.submission.reject',\n  'plugin.submission.claim',\n  'plugin.submission.expire',\n  // Security advisories (publish/withdraw are system-org only; update = a\n  // moderator editing a draft before it is published).\n  'plugin.advisory.create',\n  'plugin.advisory.update',\n  'plugin.advisory.publish',\n  'plugin.advisory.withdraw',\n  // Per-org plugin security notifications (plugin scan gates): the settings\n  // (recipients, digest, webhook, external address — changed field names and\n  // the webhook host only, never the secret or the address), an external\n  // address confirmed through its emailed single-use link, and a test send.\n  'plugin.security_notifications.update',\n  'plugin.security_notifications.external_email.verify',\n  'plugin.security_notifications.test',\n] as const;\n\nexport type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];\n\n/** Whether `value` is an action a remote service may emit (the ingest allow-list). */\nexport function isRemoteAuditAction(value: string): value is RemoteAuditAction {\n  return (REMOTE_AUDIT_ACTIONS as readonly string[]).includes(value);\n}\n"]}

package/lib/validation/plugin-base-images.d.ts

@@ -4,7 +4,7 @@
  * from. Listed here because neither the CLI nor the plugin service ships the
  * repo; a pipeline-manager test fails when the list drifts from the tree.
  */
-/** One `pipeline-<eco>-base` image a plugin can start `FROM`. */
+/** One `plugin-<eco>-base` image a plugin can start `FROM`. */
 export interface PluginBaseImage {
     /** `--base` value. */
     key: string;

package/lib/validation/plugin-base-images.js

@@ -1,17 +1,17 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export const PLUGIN_BASE_IMAGES = [
-    { key: 'plugin', image: 'pipeline-plugin-base:24.04', dir: '_plugin-base', provides: 'git, curl, jq, unzip, fetch-verified, run-logged (the root base)', smokeTest: 'bash --version && jq --version' },
-    { key: 'aws-cli', image: 'pipeline-aws-cli-base:1.0', dir: '_aws-cli-base', provides: 'AWS CLI v2', smokeTest: 'aws --version' },
-    { key: 'cpp', image: 'pipeline-cpp-base:1.0', dir: '_cpp-base', provides: 'C/C++ toolchain, CMake, Conan, Meson', smokeTest: 'cc --version && cmake --version' },
-    { key: 'dotnet', image: 'pipeline-dotnet-base:1.0', dir: '_dotnet-base', provides: 'one pinned .NET SDK', smokeTest: 'dotnet --version' },
-    { key: 'go', image: 'pipeline-go-base:1.0', dir: '_go-base', provides: 'one pinned Go', smokeTest: 'go version' },
-    { key: 'jvm', image: 'pipeline-jvm-base:1.0', dir: '_jvm-base', provides: 'Corretto JDK, Maven, Gradle, Kotlin', smokeTest: 'java -version && mvn --version' },
-    { key: 'node', image: 'pipeline-node-base:1.0', dir: '_node-base', provides: 'one pinned Node.js + npm', smokeTest: 'node --version && npm --version' },
-    { key: 'php', image: 'pipeline-php-base:1.0', dir: '_php-base', provides: 'one pinned PHP + Composer', smokeTest: 'php --version && composer --version' },
-    { key: 'python', image: 'pipeline-python-base:1.0', dir: '_python-base', provides: 'one pinned CPython + pip', smokeTest: 'python3 --version && pip3 --version' },
-    { key: 'ruby', image: 'pipeline-ruby-base:1.0', dir: '_ruby-base', provides: 'one pinned Ruby + Bundler', smokeTest: 'ruby --version && bundle --version' },
-    { key: 'rust', image: 'pipeline-rust-base:1.0', dir: '_rust-base', provides: 'one pinned Rust toolchain + clippy/rustfmt', smokeTest: 'cargo --version && rustc --version' },
-    { key: 'trivy', image: 'pipeline-trivy-base:1.0', dir: '_trivy-base', provides: 'trivy (two pinned versions)', smokeTest: 'trivy --version' },
+    { key: 'plugin', image: 'plugin-base:24.04', dir: '_plugin-base', provides: 'git, curl, jq, unzip, fetch-verified, run-logged (the root base)', smokeTest: 'bash --version && jq --version' },
+    { key: 'aws-cli', image: 'plugin-aws-cli-base:1.0', dir: '_aws-cli-base', provides: 'AWS CLI v2', smokeTest: 'aws --version' },
+    { key: 'cpp', image: 'plugin-cpp-base:1.0', dir: '_cpp-base', provides: 'C/C++ toolchain, CMake, Conan, Meson', smokeTest: 'cc --version && cmake --version' },
+    { key: 'dotnet', image: 'plugin-dotnet-base:1.0', dir: '_dotnet-base', provides: 'one pinned .NET SDK', smokeTest: 'dotnet --version' },
+    { key: 'go', image: 'plugin-go-base:1.0', dir: '_go-base', provides: 'one pinned Go', smokeTest: 'go version' },
+    { key: 'jvm', image: 'plugin-jvm-base:1.0', dir: '_jvm-base', provides: 'Corretto JDK, Maven, Gradle, Kotlin', smokeTest: 'java -version && mvn --version' },
+    { key: 'node', image: 'plugin-node-base:1.0', dir: '_node-base', provides: 'one pinned Node.js + npm', smokeTest: 'node --version && npm --version' },
+    { key: 'php', image: 'plugin-php-base:1.0', dir: '_php-base', provides: 'one pinned PHP + Composer', smokeTest: 'php --version && composer --version' },
+    { key: 'python', image: 'plugin-python-base:1.0', dir: '_python-base', provides: 'one pinned CPython + pip', smokeTest: 'python3 --version && pip3 --version' },
+    { key: 'ruby', image: 'plugin-ruby-base:1.0', dir: '_ruby-base', provides: 'one pinned Ruby + Bundler', smokeTest: 'ruby --version && bundle --version' },
+    { key: 'rust', image: 'plugin-rust-base:1.0', dir: '_rust-base', provides: 'one pinned Rust toolchain + clippy/rustfmt', smokeTest: 'cargo --version && rustc --version' },
+    { key: 'trivy', image: 'plugin-trivy-base:1.0', dir: '_trivy-base', provides: 'trivy (two pinned versions)', smokeTest: 'trivy --version' },
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -105,7 +105,7 @@
       ]
     }
   },
-  "version": "5.0.8",
+  "version": "5.0.9",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },