@pipeline-builder/pipeline-data 4.3.3 → 4.3.5

package/lib/api/pipeline-step-resolution.js

@@ -0,0 +1,163 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Per-STEP plugin resolution state of a pipeline, beyond the version-level
+ * reporting tables:
+ *
+ *  - {@link declaredResolution} — the rows `pipeline_plugin_resolution` and the
+ *    declared exposures are written from, given the pipeline's plugin steps and
+ *    a resolver. ONE assembly for both writers: the pipeline service on a save
+ *    (resolving the way its contract check does) and the plugin service when a
+ *    publish, a flag / unflag or a yank changes what a declared range resolves to
+ *    (resolving the way `/plugins/lookup` does). The step list comes from the
+ *    caller (pipeline-core's `collectPluginSteps`, which this package cannot
+ *    import), and the writes stay with the caller, so each can test its own.
+ *  - `pipeline_step_lookups` — what synth was TOLD per step at its last lookup
+ *    ({@link recordStepLookup}), when synth sends the step's context.
+ */
+import { and, eq, sql } from 'drizzle-orm';
+import { schema } from '../database/drizzle-schema.js';
+import { executeRows } from '../database/pg-result.js';
+import { withTenantTx } from '../database/tenancy.js';
+/** `Build/scan` → `['Build', 'scan']`; `synth` → `['synth', 'synth']`. */
+export function stageAndStep(label) {
+    const at = label.indexOf('/');
+    return at === -1 ? [label, label] : [label.slice(0, at), label.slice(at + 1)];
+}
+/** The step label a resolution row stands for (the inverse of {@link stageAndStep}). */
+export function stepLabelOf(stageName, stepName) {
+    return stageName === stepName && stageName === 'synth' ? 'synth' : `${stageName}/${stepName}`;
+}
+/**
+ * The declared resolution rows of a pipeline and the steps its DECLARED
+ * exposures reconcile against. Each step resolves as synth would, plus what an
+ * UNVERSIONED reference resolves to now (the "latest" the version gap is measured
+ * against). A refused reference is recorded with no resolved version and
+ * `withinPolicy: false` rather than dropped: "this step can no longer resolve"
+ * is precisely what the outdated section should show. Each distinct filter is
+ * resolved once.
+ */
+export async function declaredResolution(input) {
+    const memo = new Map();
+    const resolve = (filter) => {
+        const key = JSON.stringify(Object.entries(filter).sort(([a], [b]) => a.localeCompare(b)));
+        let hit = memo.get(key);
+        if (!hit) {
+            hit = input.resolve(filter);
+            memo.set(key, hit);
+        }
+        return hit;
+    };
+    const rows = new Map();
+    const exposureSteps = [];
+    for (const step of input.steps) {
+        const resolution = await resolve(step.lookupFilter);
+        const plugin = resolution && 'plugin' in resolution ? resolution.plugin : null;
+        const latest = await resolve({ name: step.name, ...(step.publisher ? { publisher: step.publisher } : {}), isActive: true });
+        const latestPlugin = latest && 'plugin' in latest ? latest.plugin : null;
+        const [stageName, stepName] = stageAndStep(step.label);
+        rows.set(`${stageName}\u0000${stepName}`, {
+            orgId: input.orgId,
+            pipelineId: input.pipelineId,
+            stageName,
+            stepName,
+            pluginPublisher: plugin?.publisher ?? step.publisher ?? null,
+            pluginName: plugin?.name ?? step.name,
+            declaredVersion: typeof step.filter?.version === 'string' ? step.filter.version : null,
+            resolvedVersion: plugin?.version ?? null,
+            resolvedPluginId: plugin?.id ?? null,
+            resolvedDigest: plugin?.imageDigest ?? null,
+            latestVersion: latestPlugin?.version ?? null,
+            withinPolicy: !(resolution && 'refusal' in resolution),
+            rootOrgId: input.rootOrgId ?? null,
+        });
+        if (plugin) {
+            exposureSteps.push({
+                pluginPublisher: plugin.publisher,
+                pluginName: plugin.name,
+                pluginVersion: plugin.version,
+                imageDigest: plugin.imageDigest ?? null,
+                scan: plugin.scan ?? {},
+            });
+        }
+    }
+    return { rows: [...rows.values()], exposureSteps };
+}
+/**
+ * The LIVE pipelines whose declared steps reference a plugin — a listing (every
+ * org's pipelines naming that publisher) or an org's own plugin (that org's and
+ * its teams' unqualified references) — oldest computation first, at most `limit`.
+ * Must run with a scope that can read every org's rows (elevated).
+ */
+export async function declaredPipelinesForPlugin(target, limit) {
+    const owner = 'publisher' in target
+        ? sql `r.plugin_publisher = ${target.publisher}`
+        : sql `r.plugin_publisher IS NULL AND (lower(r.org_id) = ${target.orgId.toLowerCase()} OR lower(r.root_org_id) = ${target.orgId.toLowerCase()})`;
+    return withTenantTx(async (tx) => {
+        const ids = await executeRows(tx, sql `
+      SELECT r.pipeline_id, MIN(r.computed_at) AS oldest
+        FROM pipeline_plugin_resolution r
+        JOIN pipelines p ON p.id::text = r.pipeline_id AND p.deleted_at IS NULL
+       WHERE r.plugin_name = ${target.pluginName} AND ${owner}
+       GROUP BY r.pipeline_id
+       ORDER BY oldest
+       LIMIT ${limit + 1}
+    `);
+        const truncated = ids.length > limit;
+        const wanted = ids.slice(0, limit).map((r) => r.pipeline_id);
+        if (wanted.length === 0)
+            return { pipelines: [], truncated: false };
+        const pipelines = await executeRows(tx, sql `
+      SELECT p.id::text AS id, p.org_id, p.props FROM pipelines p WHERE p.id::text = ANY(${wanted}) AND p.deleted_at IS NULL
+    `);
+        const steps = await executeRows(tx, sql `
+      SELECT pipeline_id, stage_name, step_name, resolved_version, resolved_digest, root_org_id
+        FROM pipeline_plugin_resolution WHERE pipeline_id = ANY(${wanted})
+    `);
+        return {
+            truncated,
+            pipelines: pipelines.map((p) => {
+                const own = steps.filter((s) => s.pipeline_id === p.id);
+                return {
+                    pipelineId: p.id,
+                    orgId: p.org_id,
+                    rootOrgId: own.find((s) => s.root_org_id)?.root_org_id ?? null,
+                    props: p.props,
+                    current: new Map(own.map((s) => [`${s.stage_name}\u0000${s.step_name}`, { resolvedVersion: s.resolved_version, resolvedDigest: s.resolved_digest }])),
+                };
+            }),
+        };
+    });
+}
+const L = () => schema.pipelineStepLookup;
+/**
+ * Record (replace) one step's last lookup outcome. Runs under the CALLER's
+ * scope, which RLS pins to its own org: a context naming another org's pipeline
+ * is refused by the caller before it gets here.
+ */
+export async function recordStepLookup(r) {
+    const values = {
+        orgId: r.orgId,
+        pipelineId: r.pipelineId,
+        stepKey: r.stepKey,
+        pluginPublisher: r.pluginPublisher ?? null,
+        pluginName: r.pluginName,
+        requestedVersion: r.requestedVersion ?? null,
+        resolvedVersion: r.resolvedVersion ?? null,
+        resolvedPluginId: r.resolvedPluginId ?? null,
+        imageDigest: r.imageDigest ?? null,
+        warnings: r.warnings.slice(0, 50).map((w) => ({ code: w.code, message: w.message.slice(0, 2000), ...(w.severity ? { severity: w.severity } : {}) })),
+        refusal: r.refusal ?? null,
+        lookedUpAt: r.lookedUpAt ?? new Date(),
+    };
+    const { pipelineId: _p, stepKey: _s, ...update } = values;
+    await withTenantTx((tx) => tx.insert(L()).values(values)
+        .onConflictDoUpdate({ target: [L().pipelineId, L().stepKey], set: update }));
+}
+/** A pipeline's recorded step lookups (its org only). */
+export async function pipelineStepLookups(orgId, pipelineId) {
+    return withTenantTx((tx) => tx.select().from(L())
+        .where(and(eq(L().orgId, orgId), eq(L().pipelineId, pipelineId)))
+        .orderBy(L().stepKey));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-step-resolution.js","sourceRoot":"","sources":["../../src/api/pipeline-step-resolution.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-STEP plugin resolution state of a pipeline, beyond the version-level\n * reporting tables:\n *\n *  - {@link declaredResolution} — the rows `pipeline_plugin_resolution` and the\n *    declared exposures are written from, given the pipeline's plugin steps and\n *    a resolver. ONE assembly for both writers: the pipeline service on a save\n *    (resolving the way its contract check does) and the plugin service when a\n *    publish, a flag / unflag or a yank changes what a declared range resolves to\n *    (resolving the way `/plugins/lookup` does). The step list comes from the\n *    caller (pipeline-core's `collectPluginSteps`, which this package cannot\n *    import), and the writes stay with the caller, so each can test its own.\n *  - `pipeline_step_lookups` — what synth was TOLD per step at its last lookup\n *    ({@link recordStepLookup}), when synth sends the step's context.\n */\n\nimport { and, eq, sql } from 'drizzle-orm';\nimport type { ExposureStep, ResolvedStep, ScanState } from './reporting/plugin-exposure.js';\nimport { schema } from '../database/drizzle-schema.js';\nimport { executeRows } from '../database/pg-result.js';\nimport { withTenantTx } from '../database/tenancy.js';\n\n/** One plugin step of a pipeline, as pipeline-core's `collectPluginSteps` + `pluginLookupFilter` describe it. */\nexport interface DeclaredStepInput {\n  /** `synth` or `<stageName>/<alias ?? name>`. */\n  label: string;\n  name: string;\n  publisher?: string;\n  /** The reference's own `filter` (its `version` is the declared spec). */\n  filter?: Record<string, unknown>;\n  /** The lookup filter synth would send for it. */\n  lookupFilter: Record<string, unknown>;\n}\n\n/** What a step's reference resolved to. */\nexport interface DeclaredStepPlugin {\n  id: string;\n  /** The listing's publisher; null for an org row. */\n  publisher: string | null;\n  name: string;\n  version: string;\n  imageDigest?: string | null;\n  scan?: ScanState;\n}\n\n/** A resolver's answer: a plugin, a refusal (the reference can't resolve), or nothing at all. */\nexport type DeclaredStepResolution = { plugin: DeclaredStepPlugin } | { refusal: unknown } | null;\n\n/** `Build/scan` → `['Build', 'scan']`; `synth` → `['synth', 'synth']`. */\nexport function stageAndStep(label: string): [string, string] {\n  const at = label.indexOf('/');\n  return at === -1 ? [label, label] : [label.slice(0, at), label.slice(at + 1)];\n}\n\n/** The step label a resolution row stands for (the inverse of {@link stageAndStep}). */\nexport function stepLabelOf(stageName: string, stepName: string): string {\n  return stageName === stepName && stageName === 'synth' ? 'synth' : `${stageName}/${stepName}`;\n}\n\n/**\n * The declared resolution rows of a pipeline and the steps its DECLARED\n * exposures reconcile against. Each step resolves as synth would, plus what an\n * UNVERSIONED reference resolves to now (the \"latest\" the version gap is measured\n * against). A refused reference is recorded with no resolved version and\n * `withinPolicy: false` rather than dropped: \"this step can no longer resolve\"\n * is precisely what the outdated section should show. Each distinct filter is\n * resolved once.\n */\nexport async function declaredResolution(input: {\n  pipelineId: string;\n  orgId: string;\n  rootOrgId?: string | null;\n  steps: readonly DeclaredStepInput[];\n  resolve: (filter: Record<string, unknown>) => Promise<DeclaredStepResolution>;\n}): Promise<{ rows: ResolvedStep[]; exposureSteps: ExposureStep[] }> {\n  const memo = new Map<string, Promise<DeclaredStepResolution>>();\n  const resolve = (filter: Record<string, unknown>) => {\n    const key = JSON.stringify(Object.entries(filter).sort(([a], [b]) => a.localeCompare(b)));\n    let hit = memo.get(key);\n    if (!hit) {\n      hit = input.resolve(filter);\n      memo.set(key, hit);\n    }\n    return hit;\n  };\n  const rows = new Map<string, ResolvedStep>();\n  const exposureSteps: ExposureStep[] = [];\n  for (const step of input.steps) {\n    const resolution = await resolve(step.lookupFilter);\n    const plugin = resolution && 'plugin' in resolution ? resolution.plugin : null;\n    const latest = await resolve({ name: step.name, ...(step.publisher ? { publisher: step.publisher } : {}), isActive: true });\n    const latestPlugin = latest && 'plugin' in latest ? latest.plugin : null;\n    const [stageName, stepName] = stageAndStep(step.label);\n    rows.set(`${stageName}\\u0000${stepName}`, {\n      orgId: input.orgId,\n      pipelineId: input.pipelineId,\n      stageName,\n      stepName,\n      pluginPublisher: plugin?.publisher ?? step.publisher ?? null,\n      pluginName: plugin?.name ?? step.name,\n      declaredVersion: typeof step.filter?.version === 'string' ? step.filter.version : null,\n      resolvedVersion: plugin?.version ?? null,\n      resolvedPluginId: plugin?.id ?? null,\n      resolvedDigest: plugin?.imageDigest ?? null,\n      latestVersion: latestPlugin?.version ?? null,\n      withinPolicy: !(resolution && 'refusal' in resolution),\n      rootOrgId: input.rootOrgId ?? null,\n    });\n    if (plugin) {\n      exposureSteps.push({\n        pluginPublisher: plugin.publisher,\n        pluginName: plugin.name,\n        pluginVersion: plugin.version,\n        imageDigest: plugin.imageDigest ?? null,\n        scan: plugin.scan ?? {},\n      });\n    }\n  }\n  return { rows: [...rows.values()], exposureSteps };\n}\n\n/** A pipeline whose declared steps reference a plugin, with what re-resolving it needs. */\nexport interface DeclaredPipelineRef {\n  pipelineId: string;\n  orgId: string;\n  rootOrgId: string | null;\n  props: unknown;\n  /** The step rows as last recorded: `stage\\0step` → resolved version + digest. */\n  current: Map<string, { resolvedVersion: string | null; resolvedDigest: string | null }>;\n}\n\n/**\n * The LIVE pipelines whose declared steps reference a plugin — a listing (every\n * org's pipelines naming that publisher) or an org's own plugin (that org's and\n * its teams' unqualified references) — oldest computation first, at most `limit`.\n * Must run with a scope that can read every org's rows (elevated).\n */\nexport async function declaredPipelinesForPlugin(\n  target: { pluginName: string; publisher: string } | { pluginName: string; orgId: string },\n  limit: number,\n): Promise<{ pipelines: DeclaredPipelineRef[]; truncated: boolean }> {\n  const owner = 'publisher' in target\n    ? sql`r.plugin_publisher = ${target.publisher}`\n    : sql`r.plugin_publisher IS NULL AND (lower(r.org_id) = ${target.orgId.toLowerCase()} OR lower(r.root_org_id) = ${target.orgId.toLowerCase()})`;\n  return withTenantTx(async (tx) => {\n    const ids = await executeRows<{ pipeline_id: string }>(tx, sql`\n      SELECT r.pipeline_id, MIN(r.computed_at) AS oldest\n        FROM pipeline_plugin_resolution r\n        JOIN pipelines p ON p.id::text = r.pipeline_id AND p.deleted_at IS NULL\n       WHERE r.plugin_name = ${target.pluginName} AND ${owner}\n       GROUP BY r.pipeline_id\n       ORDER BY oldest\n       LIMIT ${limit + 1}\n    `);\n    const truncated = ids.length > limit;\n    const wanted = ids.slice(0, limit).map((r) => r.pipeline_id);\n    if (wanted.length === 0) return { pipelines: [], truncated: false };\n    const pipelines = await executeRows<{ id: string; org_id: string; props: unknown }>(tx, sql`\n      SELECT p.id::text AS id, p.org_id, p.props FROM pipelines p WHERE p.id::text = ANY(${wanted}) AND p.deleted_at IS NULL\n    `);\n    const steps = await executeRows<{ pipeline_id: string; stage_name: string; step_name: string; resolved_version: string | null; resolved_digest: string | null; root_org_id: string | null }>(tx, sql`\n      SELECT pipeline_id, stage_name, step_name, resolved_version, resolved_digest, root_org_id\n        FROM pipeline_plugin_resolution WHERE pipeline_id = ANY(${wanted})\n    `);\n    return {\n      truncated,\n      pipelines: pipelines.map((p) => {\n        const own = steps.filter((s) => s.pipeline_id === p.id);\n        return {\n          pipelineId: p.id,\n          orgId: p.org_id,\n          rootOrgId: own.find((s) => s.root_org_id)?.root_org_id ?? null,\n          props: p.props,\n          current: new Map(own.map((s) => [`${s.stage_name}\\u0000${s.step_name}`, { resolvedVersion: s.resolved_version, resolvedDigest: s.resolved_digest }])),\n        };\n      }),\n    };\n  });\n}\n\n/** One step's lookup outcome, as `/plugins/lookup` records it. */\nexport interface StepLookupRecord {\n  orgId: string;\n  pipelineId: string;\n  stepKey: string;\n  pluginPublisher?: string | null;\n  pluginName: string;\n  requestedVersion?: string | null;\n  resolvedVersion?: string | null;\n  resolvedPluginId?: string | null;\n  imageDigest?: string | null;\n  warnings: Array<{ code: string; message: string; severity?: string }>;\n  refusal?: { code: string; reason: string; message: string } | null;\n  lookedUpAt?: Date;\n}\n\nconst L = () => schema.pipelineStepLookup;\n\n/**\n * Record (replace) one step's last lookup outcome. Runs under the CALLER's\n * scope, which RLS pins to its own org: a context naming another org's pipeline\n * is refused by the caller before it gets here.\n */\nexport async function recordStepLookup(r: StepLookupRecord): Promise<void> {\n  const values = {\n    orgId: r.orgId,\n    pipelineId: r.pipelineId,\n    stepKey: r.stepKey,\n    pluginPublisher: r.pluginPublisher ?? null,\n    pluginName: r.pluginName,\n    requestedVersion: r.requestedVersion ?? null,\n    resolvedVersion: r.resolvedVersion ?? null,\n    resolvedPluginId: r.resolvedPluginId ?? null,\n    imageDigest: r.imageDigest ?? null,\n    warnings: r.warnings.slice(0, 50).map((w) => ({ code: w.code, message: w.message.slice(0, 2000), ...(w.severity ? { severity: w.severity } : {}) })),\n    refusal: r.refusal ?? null,\n    lookedUpAt: r.lookedUpAt ?? new Date(),\n  };\n  const { pipelineId: _p, stepKey: _s, ...update } = values;\n  await withTenantTx((tx) => tx.insert(L()).values(values)\n    .onConflictDoUpdate({ target: [L().pipelineId, L().stepKey], set: update }));\n}\n\n/** A pipeline's recorded step lookups (its org only). */\nexport async function pipelineStepLookups(orgId: string, pipelineId: string): Promise<Array<typeof schema.pipelineStepLookup.$inferSelect>> {\n  return withTenantTx((tx) => tx.select().from(L())\n    .where(and(eq(L().orgId, orgId), eq(L().pipelineId, pipelineId)))\n    .orderBy(L().stepKey)) as Promise<Array<typeof schema.pipelineStepLookup.$inferSelect>>;\n}\n"]}

package/lib/api/plugin-consumption-policy.d.ts

@@ -1,7 +1,7 @@
 /**
  * An org's plugin CONSUMPTION POLICY: which publisher tiers it trusts, which
- * listings it blocks, which advisory severities block a resolution, and which
- * tiers may receive secrets. Applied at every resolution (see
+ * listings it blocks, which advisory severities block a resolution, which
+ * tiers may receive secrets, and how loud a version's fixable High findings are. Applied at every resolution (see
  * ./plugin-resolution.ts) and edited through the org's policy row.
  *
  * Pure functions over the stored row — no I/O — so the same rules run in the
@@ -18,6 +18,12 @@ export interface ConsumptionPolicy {
     /** What to do when a name overrides a listing or the parent org's plugin. */
     shadowing: ShadowingMode;
     blockedListings: BlockedListingRef[];
+    /**
+     * Fixable High findings above this many make a version's warning a `warning`
+     * rather than `info` (lookup, save, runtime check). Vulnerability state never
+     * refuses a pipeline; this only sets how loud it is. null = never louder than info.
+     */
+    warnFixableHigh: number | null;
 }
 /** The defaults (and the column defaults of `plugin_install_policies`). */
 export declare const DEFAULT_CONSUMPTION_POLICY: Readonly<ConsumptionPolicy>;

package/lib/api/plugin-consumption-policy.js

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
  * An org's plugin CONSUMPTION POLICY: which publisher tiers it trusts, which
- * listings it blocks, which advisory severities block a resolution, and which
- * tiers may receive secrets. Applied at every resolution (see
+ * listings it blocks, which advisory severities block a resolution, which
+ * tiers may receive secrets, and how loud a version's fixable High findings are. Applied at every resolution (see
  * ./plugin-resolution.ts) and edited through the org's policy row.
  *
  * Pure functions over the stored row — no I/O — so the same rules run in the
@@ -22,6 +22,7 @@ export const DEFAULT_CONSUMPTION_POLICY = Object.freeze({
     // deployment that already relies on it. `deny` is the opt-in.
     shadowing: 'warn',
     blockedListings: [],
+    warnFixableHigh: 0,
 });
 /** At most this many blocked listings per policy. */
 export const MAX_BLOCKED_LISTINGS = 500;
@@ -47,8 +48,17 @@ export function policyOf(row) {
         shadowing: row?.shadowing ?? d.shadowing,
         officialInstalls: row?.officialInstalls ?? d.officialInstalls,
         blockedListings: uniqueListings(row?.blockedListings ?? d.blockedListings),
+        warnFixableHigh: row === null || row === undefined || row.warnFixableHigh === undefined ? d.warnFixableHigh : row.warnFixableHigh,
     };
 }
+/** The stricter of two optional thresholds: the lower number, or whichever is set. */
+function stricterFloor(a, b) {
+    if (a === null)
+        return b;
+    if (b === null)
+        return a;
+    return Math.min(a, b);
+}
 /**
  * A team's policy under its root org's: each field takes the STRICTER of
  * the two, so a team can narrow what its root allows but never widen it.
@@ -69,6 +79,7 @@ export function mergeConsumptionPolicies(root, team) {
         // setting — the team is the party doing the shadowing.
         shadowing: SHADOW_ORDER.indexOf(root.shadowing) >= SHADOW_ORDER.indexOf(team.shadowing) ? root.shadowing : team.shadowing,
         blockedListings: uniqueListings([...root.blockedListings, ...team.blockedListings]),
+        warnFixableHigh: stricterFloor(root.warnFixableHigh, team.warnFixableHigh),
     };
 }
 /**
@@ -121,6 +132,12 @@ export function applyPolicyUpdate(base, input) {
             return 'officialInstalls must be implicit or explicit';
         next.officialInstalls = b.officialInstalls;
     }
+    if (b.warnFixableHigh !== undefined) {
+        if (b.warnFixableHigh !== null && !(Number.isInteger(b.warnFixableHigh) && b.warnFixableHigh >= 0)) {
+            return 'warnFixableHigh must be a non-negative integer or null';
+        }
+        next.warnFixableHigh = b.warnFixableHigh;
+    }
     if (b.blockedListings !== undefined) {
         if (!Array.isArray(b.blockedListings))
             return 'blockedListings must be an array';
@@ -141,4 +158,4 @@ export function applyPolicyUpdate(base, input) {
     }
     return next;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-consumption-policy.js","sourceRoot":"","sources":["../../src/api/plugin-consumption-policy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * An org's plugin CONSUMPTION POLICY: which publisher tiers it trusts, which\n * listings it blocks, which advisory severities block a resolution, and which\n * tiers may receive secrets. Applied at every resolution (see\n * ./plugin-resolution.ts) and edited through the org's policy row.\n *\n * Pure functions over the stored row — no I/O — so the same rules run in the\n * resolver, in the policy-update route, and in tests.\n */\n\nimport {\n  type BlockedListingRef,\n  type BlockOnAdvisory,\n  type OfficialInstalls,\n  type ShadowingMode,\n  type PluginInstallPolicy,\n  type PublisherTier,\n  PUBLISHER_TIERS,\n} from '../database/drizzle-schema.js';\n\n\n/** An org's consumption policy, as the resolver applies it. */\nexport interface ConsumptionPolicy {\n  allowedTiers: PublisherTier[];\n  requireApprovalTiers: PublisherTier[];\n  secretsAllowedTiers: PublisherTier[];\n  blockOnAdvisory: BlockOnAdvisory;\n  officialInstalls: OfficialInstalls;\n  /** What to do when a name overrides a listing or the parent org's plugin. */\n  shadowing: ShadowingMode;\n  blockedListings: BlockedListingRef[];\n}\n\n/** The defaults (and the column defaults of `plugin_install_policies`). */\nexport const DEFAULT_CONSUMPTION_POLICY: Readonly<ConsumptionPolicy> = Object.freeze<ConsumptionPolicy>({\n  allowedTiers: ['official', 'verified'],\n  requireApprovalTiers: ['community', 'unverified'],\n  secretsAllowedTiers: ['official', 'verified'],\n  blockOnAdvisory: 'critical',\n  officialInstalls: 'implicit',\n  // `warn`, not `deny`: shadowing is legitimate (an org overriding an Official\n  // plugin on purpose), so the default makes it visible without breaking a\n  // deployment that already relies on it. `deny` is the opt-in.\n  shadowing: 'warn',\n  blockedListings: [],\n});\n\n/** At most this many blocked listings per policy. */\nexport const MAX_BLOCKED_LISTINGS = 500;\n\nconst BLOCK_ORDER: readonly BlockOnAdvisory[] = ['never', 'critical', 'high'];\n/** Increasing strictness, so the merge can take the greater of two. */\nconst SHADOW_ORDER: readonly ShadowingMode[] = ['allow', 'warn', 'deny'];\n\nconst sortTiers = (tiers: Iterable<PublisherTier>): PublisherTier[] =>\n  PUBLISHER_TIERS.filter((t) => new Set(tiers).has(t));\n\nconst listingKey = (r: BlockedListingRef): string => `${r.publisher}/${r.name}`;\n\nfunction uniqueListings(refs: readonly BlockedListingRef[]): BlockedListingRef[] {\n  const seen = new Map<string, BlockedListingRef>();\n  for (const r of refs) seen.set(listingKey(r), { publisher: r.publisher, name: r.name });\n  return [...seen.values()].sort((a, b) => listingKey(a).localeCompare(listingKey(b)));\n}\n\n/** A stored policy row (or none) as a {@link ConsumptionPolicy}. */\nexport function policyOf(row: Partial<PluginInstallPolicy> | null | undefined): ConsumptionPolicy {\n  const d = DEFAULT_CONSUMPTION_POLICY;\n  return {\n    allowedTiers: sortTiers(row?.allowedTiers ?? d.allowedTiers),\n    requireApprovalTiers: sortTiers(row?.requireApprovalTiers ?? d.requireApprovalTiers),\n    secretsAllowedTiers: sortTiers(row?.secretsAllowedTiers ?? d.secretsAllowedTiers),\n    blockOnAdvisory: row?.blockOnAdvisory ?? d.blockOnAdvisory,\n    shadowing: row?.shadowing ?? d.shadowing,\n    officialInstalls: row?.officialInstalls ?? d.officialInstalls,\n    blockedListings: uniqueListings(row?.blockedListings ?? d.blockedListings),\n  };\n}\n\n/**\n * A team's policy under its root org's: each field takes the STRICTER of\n * the two, so a team can narrow what its root allows but never widen it.\n */\nexport function mergeConsumptionPolicies(root: ConsumptionPolicy, team: ConsumptionPolicy): ConsumptionPolicy {\n  const intersect = (a: PublisherTier[], b: PublisherTier[]) => sortTiers(a.filter((t) => b.includes(t)));\n  const union = (a: PublisherTier[], b: PublisherTier[]) => sortTiers([...a, ...b]);\n  const stricterBlock = BLOCK_ORDER.indexOf(root.blockOnAdvisory) >= BLOCK_ORDER.indexOf(team.blockOnAdvisory)\n    ? root.blockOnAdvisory : team.blockOnAdvisory;\n  return {\n    allowedTiers: intersect(root.allowedTiers, team.allowedTiers),\n    requireApprovalTiers: union(root.requireApprovalTiers, team.requireApprovalTiers),\n    secretsAllowedTiers: intersect(root.secretsAllowedTiers, team.secretsAllowedTiers),\n    blockOnAdvisory: stricterBlock,\n    officialInstalls: root.officialInstalls === 'explicit' || team.officialInstalls === 'explicit' ? 'explicit' : 'implicit',\n    // Stricter of the two wins, like every other field here: a team must not be\n    // able to loosen a root that chose `deny`, which is the whole point of the\n    // setting — the team is the party doing the shadowing.\n    shadowing: SHADOW_ORDER.indexOf(root.shadowing) >= SHADOW_ORDER.indexOf(team.shadowing) ? root.shadowing : team.shadowing,\n    blockedListings: uniqueListings([...root.blockedListings, ...team.blockedListings]),\n  };\n}\n\n/**\n * The policy an org's resolution runs under. A root org: its own row (or the\n * defaults). A team (`rootOrgId` set): its root's policy, merged with the\n * team's own row when it has one.\n */\nexport function effectiveConsumptionPolicy(\n  rows: ReadonlyArray<Partial<PluginInstallPolicy> & { orgId?: string }>,\n  orgId: string,\n  rootOrgId?: string,\n): ConsumptionPolicy {\n  const own = rows.find((r) => r.orgId === orgId) ?? null;\n  if (!rootOrgId || rootOrgId === orgId) return policyOf(own);\n  const root = policyOf(rows.find((r) => r.orgId === rootOrgId) ?? null);\n  return own ? mergeConsumptionPolicies(root, policyOf(own)) : root;\n}\n\nconst HANDLE_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\nconst NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;\n\nfunction tierList(v: unknown, field: string): PublisherTier[] | string {\n  if (!Array.isArray(v)) return `${field} must be an array of tiers`;\n  const bad = v.filter((t) => !(PUBLISHER_TIERS as readonly unknown[]).includes(t));\n  if (bad.length) return `${field} has unknown tiers: ${bad.map(String).join(', ')}`;\n  return sortTiers(v as PublisherTier[]);\n}\n\n/**\n * Validate a (partial) policy update over `base`. Returns the full new policy,\n * or an error message. `blockedListings` entries are `{ publisher, name }` or\n * `\"publisher/name\"`.\n */\nexport function applyPolicyUpdate(base: ConsumptionPolicy, input: unknown): ConsumptionPolicy | string {\n  if (!input || typeof input !== 'object' || Array.isArray(input)) return 'body must be an object';\n  const b = input as Record<string, unknown>;\n  const next: ConsumptionPolicy = { ...base };\n  for (const field of ['allowedTiers', 'requireApprovalTiers', 'secretsAllowedTiers'] as const) {\n    if (b[field] === undefined) continue;\n    const tiers = tierList(b[field], field);\n    if (typeof tiers === 'string') return tiers;\n    next[field] = tiers;\n  }\n  if (b.blockOnAdvisory !== undefined) {\n    if (!BLOCK_ORDER.includes(b.blockOnAdvisory as BlockOnAdvisory)) return 'blockOnAdvisory must be critical, high or never';\n    next.blockOnAdvisory = b.blockOnAdvisory as BlockOnAdvisory;\n  }\n  if (b.officialInstalls !== undefined) {\n    if (b.officialInstalls !== 'implicit' && b.officialInstalls !== 'explicit') return 'officialInstalls must be implicit or explicit';\n    next.officialInstalls = b.officialInstalls;\n  }\n  if (b.blockedListings !== undefined) {\n    if (!Array.isArray(b.blockedListings)) return 'blockedListings must be an array';\n    if (b.blockedListings.length > MAX_BLOCKED_LISTINGS) return `at most ${MAX_BLOCKED_LISTINGS} blocked listings`;\n    const refs: BlockedListingRef[] = [];\n    for (const raw of b.blockedListings) {\n      const ref = typeof raw === 'string'\n        ? (() => { const [publisher, name, extra] = raw.split('/'); return extra === undefined ? { publisher, name } : null; })()\n        : raw && typeof raw === 'object' ? { publisher: (raw as BlockedListingRef).publisher, name: (raw as BlockedListingRef).name } : null;\n      if (!ref || typeof ref.publisher !== 'string' || typeof ref.name !== 'string'\n        || !HANDLE_RE.test(ref.publisher) || !NAME_RE.test(ref.name)) {\n        return 'each blocked listing must be { publisher, name } (or \"publisher/name\")';\n      }\n      refs.push({ publisher: ref.publisher, name: ref.name });\n    }\n    next.blockedListings = uniqueListings(refs);\n  }\n  return next;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-consumption-policy.js","sourceRoot":"","sources":["../../src/api/plugin-consumption-policy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * An org's plugin CONSUMPTION POLICY: which publisher tiers it trusts, which\n * listings it blocks, which advisory severities block a resolution, which\n * tiers may receive secrets, and how loud a version's fixable High findings are. Applied at every resolution (see\n * ./plugin-resolution.ts) and edited through the org's policy row.\n *\n * Pure functions over the stored row — no I/O — so the same rules run in the\n * resolver, in the policy-update route, and in tests.\n */\n\nimport {\n  type BlockedListingRef,\n  type BlockOnAdvisory,\n  type OfficialInstalls,\n  type ShadowingMode,\n  type PluginInstallPolicy,\n  type PublisherTier,\n  PUBLISHER_TIERS,\n} from '../database/drizzle-schema.js';\n\n\n/** An org's consumption policy, as the resolver applies it. */\nexport interface ConsumptionPolicy {\n  allowedTiers: PublisherTier[];\n  requireApprovalTiers: PublisherTier[];\n  secretsAllowedTiers: PublisherTier[];\n  blockOnAdvisory: BlockOnAdvisory;\n  officialInstalls: OfficialInstalls;\n  /** What to do when a name overrides a listing or the parent org's plugin. */\n  shadowing: ShadowingMode;\n  blockedListings: BlockedListingRef[];\n  /**\n   * Fixable High findings above this many make a version's warning a `warning`\n   * rather than `info` (lookup, save, runtime check). Vulnerability state never\n   * refuses a pipeline; this only sets how loud it is. null = never louder than info.\n   */\n  warnFixableHigh: number | null;\n}\n\n/** The defaults (and the column defaults of `plugin_install_policies`). */\nexport const DEFAULT_CONSUMPTION_POLICY: Readonly<ConsumptionPolicy> = Object.freeze<ConsumptionPolicy>({\n  allowedTiers: ['official', 'verified'],\n  requireApprovalTiers: ['community', 'unverified'],\n  secretsAllowedTiers: ['official', 'verified'],\n  blockOnAdvisory: 'critical',\n  officialInstalls: 'implicit',\n  // `warn`, not `deny`: shadowing is legitimate (an org overriding an Official\n  // plugin on purpose), so the default makes it visible without breaking a\n  // deployment that already relies on it. `deny` is the opt-in.\n  shadowing: 'warn',\n  blockedListings: [],\n  warnFixableHigh: 0,\n});\n\n/** At most this many blocked listings per policy. */\nexport const MAX_BLOCKED_LISTINGS = 500;\n\nconst BLOCK_ORDER: readonly BlockOnAdvisory[] = ['never', 'critical', 'high'];\n/** Increasing strictness, so the merge can take the greater of two. */\nconst SHADOW_ORDER: readonly ShadowingMode[] = ['allow', 'warn', 'deny'];\n\nconst sortTiers = (tiers: Iterable<PublisherTier>): PublisherTier[] =>\n  PUBLISHER_TIERS.filter((t) => new Set(tiers).has(t));\n\nconst listingKey = (r: BlockedListingRef): string => `${r.publisher}/${r.name}`;\n\nfunction uniqueListings(refs: readonly BlockedListingRef[]): BlockedListingRef[] {\n  const seen = new Map<string, BlockedListingRef>();\n  for (const r of refs) seen.set(listingKey(r), { publisher: r.publisher, name: r.name });\n  return [...seen.values()].sort((a, b) => listingKey(a).localeCompare(listingKey(b)));\n}\n\n/** A stored policy row (or none) as a {@link ConsumptionPolicy}. */\nexport function policyOf(row: Partial<PluginInstallPolicy> | null | undefined): ConsumptionPolicy {\n  const d = DEFAULT_CONSUMPTION_POLICY;\n  return {\n    allowedTiers: sortTiers(row?.allowedTiers ?? d.allowedTiers),\n    requireApprovalTiers: sortTiers(row?.requireApprovalTiers ?? d.requireApprovalTiers),\n    secretsAllowedTiers: sortTiers(row?.secretsAllowedTiers ?? d.secretsAllowedTiers),\n    blockOnAdvisory: row?.blockOnAdvisory ?? d.blockOnAdvisory,\n    shadowing: row?.shadowing ?? d.shadowing,\n    officialInstalls: row?.officialInstalls ?? d.officialInstalls,\n    blockedListings: uniqueListings(row?.blockedListings ?? d.blockedListings),\n    warnFixableHigh: row === null || row === undefined || row.warnFixableHigh === undefined ? d.warnFixableHigh : row.warnFixableHigh,\n  };\n}\n\n/** The stricter of two optional thresholds: the lower number, or whichever is set. */\nfunction stricterFloor(a: number | null, b: number | null): number | null {\n  if (a === null) return b;\n  if (b === null) return a;\n  return Math.min(a, b);\n}\n\n/**\n * A team's policy under its root org's: each field takes the STRICTER of\n * the two, so a team can narrow what its root allows but never widen it.\n */\nexport function mergeConsumptionPolicies(root: ConsumptionPolicy, team: ConsumptionPolicy): ConsumptionPolicy {\n  const intersect = (a: PublisherTier[], b: PublisherTier[]) => sortTiers(a.filter((t) => b.includes(t)));\n  const union = (a: PublisherTier[], b: PublisherTier[]) => sortTiers([...a, ...b]);\n  const stricterBlock = BLOCK_ORDER.indexOf(root.blockOnAdvisory) >= BLOCK_ORDER.indexOf(team.blockOnAdvisory)\n    ? root.blockOnAdvisory : team.blockOnAdvisory;\n  return {\n    allowedTiers: intersect(root.allowedTiers, team.allowedTiers),\n    requireApprovalTiers: union(root.requireApprovalTiers, team.requireApprovalTiers),\n    secretsAllowedTiers: intersect(root.secretsAllowedTiers, team.secretsAllowedTiers),\n    blockOnAdvisory: stricterBlock,\n    officialInstalls: root.officialInstalls === 'explicit' || team.officialInstalls === 'explicit' ? 'explicit' : 'implicit',\n    // Stricter of the two wins, like every other field here: a team must not be\n    // able to loosen a root that chose `deny`, which is the whole point of the\n    // setting — the team is the party doing the shadowing.\n    shadowing: SHADOW_ORDER.indexOf(root.shadowing) >= SHADOW_ORDER.indexOf(team.shadowing) ? root.shadowing : team.shadowing,\n    blockedListings: uniqueListings([...root.blockedListings, ...team.blockedListings]),\n    warnFixableHigh: stricterFloor(root.warnFixableHigh, team.warnFixableHigh),\n  };\n}\n\n/**\n * The policy an org's resolution runs under. A root org: its own row (or the\n * defaults). A team (`rootOrgId` set): its root's policy, merged with the\n * team's own row when it has one.\n */\nexport function effectiveConsumptionPolicy(\n  rows: ReadonlyArray<Partial<PluginInstallPolicy> & { orgId?: string }>,\n  orgId: string,\n  rootOrgId?: string,\n): ConsumptionPolicy {\n  const own = rows.find((r) => r.orgId === orgId) ?? null;\n  if (!rootOrgId || rootOrgId === orgId) return policyOf(own);\n  const root = policyOf(rows.find((r) => r.orgId === rootOrgId) ?? null);\n  return own ? mergeConsumptionPolicies(root, policyOf(own)) : root;\n}\n\nconst HANDLE_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\nconst NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;\n\nfunction tierList(v: unknown, field: string): PublisherTier[] | string {\n  if (!Array.isArray(v)) return `${field} must be an array of tiers`;\n  const bad = v.filter((t) => !(PUBLISHER_TIERS as readonly unknown[]).includes(t));\n  if (bad.length) return `${field} has unknown tiers: ${bad.map(String).join(', ')}`;\n  return sortTiers(v as PublisherTier[]);\n}\n\n/**\n * Validate a (partial) policy update over `base`. Returns the full new policy,\n * or an error message. `blockedListings` entries are `{ publisher, name }` or\n * `\"publisher/name\"`.\n */\nexport function applyPolicyUpdate(base: ConsumptionPolicy, input: unknown): ConsumptionPolicy | string {\n  if (!input || typeof input !== 'object' || Array.isArray(input)) return 'body must be an object';\n  const b = input as Record<string, unknown>;\n  const next: ConsumptionPolicy = { ...base };\n  for (const field of ['allowedTiers', 'requireApprovalTiers', 'secretsAllowedTiers'] as const) {\n    if (b[field] === undefined) continue;\n    const tiers = tierList(b[field], field);\n    if (typeof tiers === 'string') return tiers;\n    next[field] = tiers;\n  }\n  if (b.blockOnAdvisory !== undefined) {\n    if (!BLOCK_ORDER.includes(b.blockOnAdvisory as BlockOnAdvisory)) return 'blockOnAdvisory must be critical, high or never';\n    next.blockOnAdvisory = b.blockOnAdvisory as BlockOnAdvisory;\n  }\n  if (b.officialInstalls !== undefined) {\n    if (b.officialInstalls !== 'implicit' && b.officialInstalls !== 'explicit') return 'officialInstalls must be implicit or explicit';\n    next.officialInstalls = b.officialInstalls;\n  }\n  if (b.warnFixableHigh !== undefined) {\n    if (b.warnFixableHigh !== null && !(Number.isInteger(b.warnFixableHigh) && (b.warnFixableHigh as number) >= 0)) {\n      return 'warnFixableHigh must be a non-negative integer or null';\n    }\n    next.warnFixableHigh = b.warnFixableHigh as number | null;\n  }\n  if (b.blockedListings !== undefined) {\n    if (!Array.isArray(b.blockedListings)) return 'blockedListings must be an array';\n    if (b.blockedListings.length > MAX_BLOCKED_LISTINGS) return `at most ${MAX_BLOCKED_LISTINGS} blocked listings`;\n    const refs: BlockedListingRef[] = [];\n    for (const raw of b.blockedListings) {\n      const ref = typeof raw === 'string'\n        ? (() => { const [publisher, name, extra] = raw.split('/'); return extra === undefined ? { publisher, name } : null; })()\n        : raw && typeof raw === 'object' ? { publisher: (raw as BlockedListingRef).publisher, name: (raw as BlockedListingRef).name } : null;\n      if (!ref || typeof ref.publisher !== 'string' || typeof ref.name !== 'string'\n        || !HANDLE_RE.test(ref.publisher) || !NAME_RE.test(ref.name)) {\n        return 'each blocked listing must be { publisher, name } (or \"publisher/name\")';\n      }\n      refs.push({ publisher: ref.publisher, name: ref.name });\n    }\n    next.blockedListings = uniqueListings(refs);\n  }\n  return next;\n}\n"]}

package/lib/api/plugin-resolution.d.ts

@@ -25,11 +25,12 @@
  *    version spec. Yanked versions never resolve for a listing; a paused
  *    version is skipped unless the install already resolved to it or the
  *    reference pins it exactly; advisory-blocked versions are skipped.
- *  - Scan flags: a version the nightly rescan FLAGGED (fixable Criticals
- *    over `PLUGIN_VULN_MAX_CRITICAL`) resolves with a `VULN_FLAGGED` warning —
- *    or, with `PLUGIN_BLOCK_ON_NEW_CRITICAL` on, is skipped like an
- *    advisory-blocked one, and an exact pin to it is refused
- *    `PLUGIN_VERSION_VULN_BLOCKED`.
+ *  - Scan flags: a version the nightly rescan FLAGGED (gated Criticals over
+ *    `PLUGIN_VULN_MAX_FINDINGS`) resolves like any other, with a `VULN_FLAGGED`
+ *    warning (severity `error`, `critical` with a KEV finding). Vulnerability
+ *    state NEVER skips or refuses a version — it is graded, and the pipeline's
+ *    owners are told. When the reference's pin keeps it OFF a newer unflagged
+ *    version the install allows, `VULN_UPGRADE_AVAILABLE` (info) names it.
  */
 import { type VulnFlaggedWarning } from '@pipeline-builder/api-core';
 import type { CrudTx } from './crud-service.js';
@@ -37,16 +38,31 @@ import { type ConsumptionPolicy } from './plugin-consumption-policy.js';
 import { type PluginAdvisory, type PluginInstall, type PluginInstallPolicy, type PluginListing, type PluginListingVersion, type Publisher } from '../database/drizzle-schema.js';
 /** Why a reference can't resolve; `code` is an api-core `ErrorCode` name. */
 export interface ResolutionRefusal {
-    code: 'NOT_FOUND' | 'PLUGIN_NOT_INSTALLED' | 'PLUGIN_BLOCKED_BY_POLICY' | 'PLUGIN_UNAVAILABLE' | 'PLUGIN_VERSION_VULN_BLOCKED';
+    code: 'NOT_FOUND' | 'PLUGIN_NOT_INSTALLED' | 'PLUGIN_BLOCKED_BY_POLICY' | 'PLUGIN_UNAVAILABLE';
     reason: string;
     message: string;
     details?: Record<string, unknown>;
 }
+/**
+ * `VULN_UPGRADE_AVAILABLE` (severity `info`): the resolved version is FLAGGED,
+ * and a newer UNFLAGGED version exists that the install allows but the
+ * reference's own pin excludes — so the pipeline keeps running the vulnerable
+ * release until someone moves the pin. `suggestedVersion` is the way out.
+ */
+export interface VulnUpgradeAvailableWarning {
+    code: 'VULN_UPGRADE_AVAILABLE';
+    severity: 'info';
+    message: string;
+    resolved: string;
+    suggestedVersion: string;
+}
 /** A non-fatal note a resolution carries (synth prints its `message`). */
 export type ResolutionWarning = {
     code: 'PLUGIN_ADVISORY' | 'PLUGIN_DEPRECATED' | 'PLUGIN_SECRETS_WITHHELD' | 'LISTING_UNMAINTAINED';
     message: string;
-} | VulnFlaggedWarning;
+} | VulnFlaggedWarning | VulnUpgradeAvailableWarning;
+/** The `VULN_UPGRADE_AVAILABLE` warning for `ref` resolving to `resolved` with `suggested` outside the pin. */
+export declare function vulnUpgradeAvailableWarning(ref: string, resolved: string, suggested: string): VulnUpgradeAvailableWarning;
 /** Why the org's policy (or the listing's state) keeps a listing out, or null. */
 export interface ListingBlock {
     reason: 'tier' | 'blocked_listing' | 'suspended';
@@ -84,8 +100,6 @@ export interface VersionChoiceInput<V extends PluginListingVersion = PluginListi
     requested?: string;
     advisories: readonly PluginAdvisory[];
     policy: ConsumptionPolicy;
-    /** Skip / refuse rescan-flagged versions (default: `PLUGIN_BLOCK_ON_NEW_CRITICAL`). */
-    blockFlagged?: boolean;
 }
 /**
  * Pick the listed version a reference resolves to (see the module doc), or
@@ -93,6 +107,7 @@ export interface VersionChoiceInput<V extends PluginListingVersion = PluginListi
  */
 export declare function selectListingVersion<V extends PluginListingVersion>(input: VersionChoiceInput<V>): {
     version: V;
+    suggestedVersion: string | null;
 } | {
     refusal: ResolutionRefusal;
 };
@@ -146,6 +161,8 @@ export interface ListingReference {
 /** A reference that resolved to a listed version. */
 export interface ListingResolved {
     ok: true;
+    /** For a FLAGGED version: the newest unflagged one above it the install allows (null otherwise). */
+    suggestedVersion: string | null;
     publisher: Publisher;
     listing: PluginListing;
     version: PluginListingVersion;