@pipeline-builder/pipeline-core 4.4.11 → 4.4.13

package/lib/core/plugin-lookup-envelope.js

@@ -1,13 +1,67 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+// The dependency-free plugin-catalog subpath only: the plugin-lookup Lambda
+// bundles this module, so it must not pull in the api-core root.
+import { TOOLCHAIN_METADATA_PREFIX, TOOLCHAIN_RESOLVED_VIA } from '@pipeline-builder/api-core/plugin-catalog';
 /** Severities, least to most serious. */
 export const LOOKUP_WARNING_SEVERITIES = ['info', 'warning', 'error', 'critical'];
+/** Every tool field, keyed so a field added to api-core's `PluginToolchainSchema` fails to compile here until listed. */
+const TOOLCHAIN_VERSION_FIELDS = {
+    pipelineManager: true, awsCdk: true, cdkAssets: true, esbuild: true, pnpm: true, node: true,
+};
+const TOOLCHAIN_VERSION_KEYS = Object.keys(TOOLCHAIN_VERSION_FIELDS);
+/** Pick the string tool versions off an object (unknown keys and non-strings ignored). */
+function pickVersions(raw) {
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const out = {};
+    for (const key of TOOLCHAIN_VERSION_KEYS) {
+        const v = raw[key];
+        if (typeof v === 'string' && v.length > 0)
+            out[key] = v;
+    }
+    return out;
+}
+/** The tool versions a plugin row's `metadata` carries as flat `toolchain.<field>` keys. */
+function versionsFromMetadata(metadata) {
+    if (!metadata || typeof metadata !== 'object')
+        return {};
+    const fields = {};
+    for (const [k, v] of Object.entries(metadata)) {
+        if (k.startsWith(TOOLCHAIN_METADATA_PREFIX))
+            fields[k.slice(TOOLCHAIN_METADATA_PREFIX.length)] = v;
+    }
+    return pickVersions(fields);
+}
+/**
+ * Parse a lookup's `toolchain` block. Null unless it carries a release version
+ * and a known `resolvedVia`. Tool versions come from, lowest precedence first:
+ * the plugin row's `metadata` (`toolchain.<field>` keys, where the platform
+ * persists the bootstrap spec's `toolchain`), the record's own `toolchain`,
+ * the block's flat fields, then `toolchain.versions`.
+ */
+export function parseLookupToolchain(raw, plugin) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const { releaseVersion, resolvedVia, versions } = raw;
+    if (typeof releaseVersion !== 'string' || releaseVersion.length === 0)
+        return null;
+    if (!TOOLCHAIN_RESOLVED_VIA.includes(resolvedVia))
+        return null;
+    const rec = plugin && typeof plugin === 'object' ? plugin : undefined;
+    return {
+        releaseVersion,
+        resolvedVia: resolvedVia,
+        versions: { ...versionsFromMetadata(rec?.metadata), ...pickVersions(rec?.toolchain), ...pickVersions(raw), ...pickVersions(versions) },
+    };
+}
 /**
  * Unwrap a `/plugins/lookup` answer. The platform's success envelope is
  * `{ success, statusCode, data: { plugin, warnings } }` (note the double
  * nesting: `data.plugin`); `{ data: Plugin }`, `{ plugin }` and a bare Plugin
  * are tolerated too. Returns the plugin (null when absent or nameless) and the
- * graded warnings (lifecycle, vulnerability, compliance) that ride beside it.
+ * graded warnings (lifecycle, vulnerability, compliance) that ride beside it,
+ * and — for a managed toolchain name — the release it resolved to (`toolchain`).
  *
  * Dependency-free (type-only imports) so the plugin-lookup Lambda can bundle it.
  */
@@ -36,7 +90,8 @@ export function unwrapLookup(body) {
             });
         }
     }
-    return { plugin, warnings };
+    const toolchain = parseLookupToolchain(container.toolchain, plugin);
+    return { plugin, warnings, ...(toolchain && { toolchain }) };
 }
 /**
  * One line summarizing graded warnings, most serious first —
@@ -77,4 +132,4 @@ export function exactPinNotFoundMessage(label, pin, state) {
         default: return `Plugin "${label}" version ${pin} does not exist (never published, or refused by its build's vulnerability scan)`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup-envelope.js","sources":["../../src/core/plugin-lookup-envelope.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Plugin } from '@pipeline-builder/pipeline-data';\n\n/** How serious a lookup warning is (vulnerability state is graded, never refused). */\nexport type LookupWarningSeverity = 'info' | 'warning' | 'error' | 'critical';\n\n/** Severities, least to most serious. */\nexport const LOOKUP_WARNING_SEVERITIES: readonly LookupWarningSeverity[] = ['info', 'warning', 'error', 'critical'];\n\n/** One warning riding beside a resolved plugin. */\nexport interface LookupWarning {\n  readonly code?: string;\n  readonly message: string;\n  /** Absent on the wire → `warning`. */\n  readonly severity: LookupWarningSeverity;\n}\n\n/**\n * Unwrap a `/plugins/lookup` answer. The platform's success envelope is\n * `{ success, statusCode, data: { plugin, warnings } }` (note the double\n * nesting: `data.plugin`); `{ data: Plugin }`, `{ plugin }` and a bare Plugin\n * are tolerated too. Returns the plugin (null when absent or nameless) and the\n * graded warnings (lifecycle, vulnerability, compliance) that ride beside it.\n *\n * Dependency-free (type-only imports) so the plugin-lookup Lambda can bundle it.\n */\nexport function unwrapLookup(body: unknown): { plugin: Plugin | null; warnings: LookupWarning[] } {\n  if (!body || typeof body !== 'object') return { plugin: null, warnings: [] };\n  const inner = (body as { data?: unknown }).data;\n  const container = (inner && typeof inner === 'object' ? inner : body) as { plugin?: unknown; warnings?: unknown };\n  const candidate = container.plugin ?? container;\n  const plugin = candidate && typeof candidate === 'object' && typeof (candidate as { name?: unknown }).name === 'string'\n    && (candidate as { name: string }).name.length > 0\n    ? candidate as Plugin\n    : null;\n  const warnings: LookupWarning[] = [];\n  if (Array.isArray(container.warnings)) {\n    for (const w of container.warnings) {\n      if (!w || typeof w !== 'object') continue;\n      const { code, message, severity } = w as { code?: unknown; message?: unknown; severity?: unknown };\n      if (typeof message !== 'string' || message.length === 0) continue;\n      warnings.push({\n        ...(typeof code === 'string' ? { code } : {}),\n        message,\n        severity: (LOOKUP_WARNING_SEVERITIES as readonly unknown[]).includes(severity) ? severity as LookupWarningSeverity : 'warning',\n      });\n    }\n  }\n  return { plugin, warnings };\n}\n\n/**\n * One line summarizing graded warnings, most serious first —\n * `3 plugin warnings: 1 critical, 2 error`. Null when there are none.\n */\nexport function summarizeLookupWarnings(warnings: readonly Pick<LookupWarning, 'severity'>[]): string | null {\n  if (warnings.length === 0) return null;\n  const parts = [...LOOKUP_WARNING_SEVERITIES].reverse()\n    .map((sev) => [sev, warnings.filter((w) => w.severity === sev).length] as const)\n    .filter(([, n]) => n > 0)\n    .map(([sev, n]) => `${n} ${sev}`);\n  return `${warnings.length} plugin warning${warnings.length === 1 ? '' : 's'}: ${parts.join(', ')}`;\n}\n\n/** Why a lookup found nothing, as the plugin service's 404 `details.state` reports it. */\nexport type LookupNotFoundState = 'deleted' | 'inactive' | 'yanked' | 'missing';\n\nconst NOT_FOUND_STATES: readonly LookupNotFoundState[] = ['deleted', 'inactive', 'yanked', 'missing'];\n\n/**\n * `details.state` of a refused lookup, read off either an axios-style error\n * (`err.response.data`) or the response body itself. Null when absent/unknown.\n */\nexport function lookupNotFoundState(errOrBody: unknown): LookupNotFoundState | null {\n  if (!errOrBody || typeof errOrBody !== 'object') return null;\n  const data = (errOrBody as { response?: { data?: unknown } }).response?.data ?? errOrBody;\n  const details = data && typeof data === 'object' ? (data as { details?: unknown }).details : undefined;\n  const state = details && typeof details === 'object' ? (details as { state?: unknown }).state : undefined;\n  return typeof state === 'string' && (NOT_FOUND_STATES as readonly string[]).includes(state) ? state as LookupNotFoundState : null;\n}\n\n/**\n * The message for an exact version pin that did not resolve. Shared by the\n * CLI's pre-resolution and the deploy-time Lambda's CloudFormation reason.\n */\nexport function exactPinNotFoundMessage(label: string, pin: string, state: LookupNotFoundState | null): string {\n  switch (state) {\n    case 'deleted': return `Plugin \"${label}\" version ${pin} was deleted from your organization`;\n    case 'inactive': return `Plugin \"${label}\" version ${pin} is inactive`;\n    case 'yanked': return `Plugin \"${label}\" version ${pin} was yanked`;\n    case 'missing': return `Plugin \"${label}\" version ${pin} does not exist`;\n    default: return `Plugin \"${label}\" version ${pin} does not exist (never published, or refused by its build's vulnerability scan)`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup-envelope.js","sources":["../../src/core/plugin-lookup-envelope.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,4EAA4E;AAC5E,iEAAiE;AACjE,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAA6B,MAAM,2CAA2C,CAAC;AAOzI,yCAAyC;AACzC,MAAM,CAAC,MAAM,yBAAyB,GAAqC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;AAapH,yHAAyH;AACzH,MAAM,wBAAwB,GAAwC;IACpE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;CAC5F,CAAC;AACF,MAAM,sBAAsB,GAAG,MAAM,CAAC,IAAI,CAAC,wBAAwB,CAA8B,CAAC;AAyBlG,0FAA0F;AAC1F,SAAS,YAAY,CAAC,GAAY;IAChC,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IAC/C,MAAM,GAAG,GAA2B,EAAE,CAAC;IACvC,KAAK,MAAM,GAAG,IAAI,sBAAsB,EAAE,CAAC;QACzC,MAAM,CAAC,GAAI,GAA+B,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1D,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,4FAA4F;AAC5F,SAAS,oBAAoB,CAAC,QAAiB;IAC7C,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IACzD,MAAM,MAAM,GAA4B,EAAE,CAAC;IAC3C,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAmC,CAAC,EAAE,CAAC;QACzE,IAAI,CAAC,CAAC,UAAU,CAAC,yBAAyB,CAAC;YAAE,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,yBAAyB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;IACrG,CAAC;IACD,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAY,EAAE,MAAgB;IACjE,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACjD,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,QAAQ,EAAE,GAAG,GAA8E,CAAC;IACjI,IAAI,OAAO,cAAc,KAAK,QAAQ,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACnF,IAAI,CAAE,sBAA6C,CAAC,QAAQ,CAAC,WAAW,CAAC;QAAE,OAAO,IAAI,CAAC;IACvF,MAAM,GAAG,GAAG,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAqD,CAAC,CAAC,CAAC,SAAS,CAAC;IACrH,OAAO;QACL,cAAc;QACd,WAAW,EAAE,WAAmC;QAChD,QAAQ,EAAE,EAAE,GAAG,oBAAoB,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,GAAG,YAAY,CAAC,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,YAAY,CAAC,GAAG,CAAC,EAAE,GAAG,YAAY,CAAC,QAAQ,CAAC,EAAE;KACvI,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,YAAY,CAAC,IAAa;IACxC,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAC7E,MAAM,KAAK,GAAI,IAA2B,CAAC,IAAI,CAAC;IAChD,MAAM,SAAS,GAAG,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAkE,CAAC;IACvI,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC;IAChD,MAAM,MAAM,GAAG,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,OAAQ,SAAgC,CAAC,IAAI,KAAK,QAAQ;WACjH,SAA8B,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;QAClD,CAAC,CAAC,SAAmB;QACrB,CAAC,CAAC,IAAI,CAAC;IACT,MAAM,QAAQ,GAAoB,EAAE,CAAC;IACrC,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QACtC,KAAK,MAAM,CAAC,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;YACnC,IAAI,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ;gBAAE,SAAS;YAC1C,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,CAA8D,CAAC;YACnG,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;gBAAE,SAAS;YAClE,QAAQ,CAAC,IAAI,CAAC;gBACZ,GAAG,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC7C,OAAO;gBACP,QAAQ,EAAG,yBAAgD,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAiC,CAAC,CAAC,CAAC,SAAS;aAC/H,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,MAAM,SAAS,GAAG,oBAAoB,CAAC,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACpE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,QAAoD;IAC1F,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACvC,MAAM,KAAK,GAAG,CAAC,GAAG,yBAAyB,CAAC,CAAC,OAAO,EAAE;SACnD,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,GAAG,CAAC,CAAC,MAAM,CAAU,CAAC;SAC/E,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;SACxB,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;IACpC,OAAO,GAAG,QAAQ,CAAC,MAAM,kBAAkB,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;AACrG,CAAC;AAKD,MAAM,gBAAgB,GAAmC,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;AAEtG;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,SAAkB;IACpD,IAAI,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC7D,MAAM,IAAI,GAAI,SAA+C,CAAC,QAAQ,EAAE,IAAI,IAAI,SAAS,CAAC;IAC1F,MAAM,OAAO,GAAG,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAE,IAA8B,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IACvG,MAAM,KAAK,GAAG,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAE,OAA+B,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1G,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,gBAAsC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAA4B,CAAC,CAAC,CAAC,IAAI,CAAC;AACpI,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAa,EAAE,GAAW,EAAE,KAAiC;IACnG,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,SAAS,EAAE,OAAO,WAAW,KAAK,aAAa,GAAG,qCAAqC,CAAC;QAC7F,KAAK,UAAU,EAAE,OAAO,WAAW,KAAK,aAAa,GAAG,cAAc,CAAC;QACvE,KAAK,QAAQ,EAAE,OAAO,WAAW,KAAK,aAAa,GAAG,aAAa,CAAC;QACpE,KAAK,SAAS,EAAE,OAAO,WAAW,KAAK,aAAa,GAAG,iBAAiB,CAAC;QACzE,SAAS,OAAO,WAAW,KAAK,aAAa,GAAG,iFAAiF,CAAC;IACpI,CAAC;AACH,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n// The dependency-free plugin-catalog subpath only: the plugin-lookup Lambda\n// bundles this module, so it must not pull in the api-core root.\nimport { TOOLCHAIN_METADATA_PREFIX, TOOLCHAIN_RESOLVED_VIA, type ToolchainResolvedVia } from '@pipeline-builder/api-core/plugin-catalog';\nimport type { PluginToolchain } from '@pipeline-builder/api-core';\nimport type { Plugin } from '@pipeline-builder/pipeline-data';\n\n/** How serious a lookup warning is (vulnerability state is graded, never refused). */\nexport type LookupWarningSeverity = 'info' | 'warning' | 'error' | 'critical';\n\n/** Severities, least to most serious. */\nexport const LOOKUP_WARNING_SEVERITIES: readonly LookupWarningSeverity[] = ['info', 'warning', 'error', 'critical'];\n\n/** One warning riding beside a resolved plugin. */\nexport interface LookupWarning {\n  readonly code?: string;\n  readonly message: string;\n  /** Absent on the wire → `warning`. */\n  readonly severity: LookupWarningSeverity;\n}\n\n/** The exact tool versions a toolchain release carries (the bootstrap spec's `toolchain`), as far as an answer carries them. */\nexport type ToolchainVersions = Partial<Readonly<PluginToolchain>>;\n\n/** Every tool field, keyed so a field added to api-core's `PluginToolchainSchema` fails to compile here until listed. */\nconst TOOLCHAIN_VERSION_FIELDS: Record<keyof PluginToolchain, true> = {\n  pipelineManager: true, awsCdk: true, cdkAssets: true, esbuild: true, pnpm: true, node: true,\n};\nconst TOOLCHAIN_VERSION_KEYS = Object.keys(TOOLCHAIN_VERSION_FIELDS) as (keyof PluginToolchain)[];\n\n/**\n * The release a managed-name lookup (`pipeline-bootstrap`, `cdk-synth`)\n * resolved to: `data.toolchain` of the `/plugins/lookup` answer. `versions`\n * holds the tool versions when the answer (or the plugin record) carries them.\n */\nexport interface LookupToolchain {\n  readonly releaseVersion: string;\n  readonly resolvedVia: ToolchainResolvedVia;\n  readonly versions: ToolchainVersions;\n}\n\n/**\n * The resolved `pipeline-bootstrap` half of a toolchain release: the plugin\n * record the default CodeBuild image is pinned to (by its signed digest) and\n * the release it came from. Produced by `pipeline-manager`'s\n * `resolveBootstrapImage` (or a `--toolchain-file`) and passed to\n * `PipelineBuilder` as `resolvedBootstrap`.\n */\nexport interface ResolvedBootstrap {\n  readonly plugin: Plugin;\n  readonly toolchain: LookupToolchain;\n}\n\n/** Pick the string tool versions off an object (unknown keys and non-strings ignored). */\nfunction pickVersions(raw: unknown): ToolchainVersions {\n  if (!raw || typeof raw !== 'object') return {};\n  const out: Record<string, string> = {};\n  for (const key of TOOLCHAIN_VERSION_KEYS) {\n    const v = (raw as Record<string, unknown>)[key];\n    if (typeof v === 'string' && v.length > 0) out[key] = v;\n  }\n  return out;\n}\n\n/** The tool versions a plugin row's `metadata` carries as flat `toolchain.<field>` keys. */\nfunction versionsFromMetadata(metadata: unknown): ToolchainVersions {\n  if (!metadata || typeof metadata !== 'object') return {};\n  const fields: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(metadata as Record<string, unknown>)) {\n    if (k.startsWith(TOOLCHAIN_METADATA_PREFIX)) fields[k.slice(TOOLCHAIN_METADATA_PREFIX.length)] = v;\n  }\n  return pickVersions(fields);\n}\n\n/**\n * Parse a lookup's `toolchain` block. Null unless it carries a release version\n * and a known `resolvedVia`. Tool versions come from, lowest precedence first:\n * the plugin row's `metadata` (`toolchain.<field>` keys, where the platform\n * persists the bootstrap spec's `toolchain`), the record's own `toolchain`,\n * the block's flat fields, then `toolchain.versions`.\n */\nexport function parseLookupToolchain(raw: unknown, plugin?: unknown): LookupToolchain | null {\n  if (!raw || typeof raw !== 'object') return null;\n  const { releaseVersion, resolvedVia, versions } = raw as { releaseVersion?: unknown; resolvedVia?: unknown; versions?: unknown };\n  if (typeof releaseVersion !== 'string' || releaseVersion.length === 0) return null;\n  if (!(TOOLCHAIN_RESOLVED_VIA as readonly unknown[]).includes(resolvedVia)) return null;\n  const rec = plugin && typeof plugin === 'object' ? plugin as { toolchain?: unknown; metadata?: unknown } : undefined;\n  return {\n    releaseVersion,\n    resolvedVia: resolvedVia as ToolchainResolvedVia,\n    versions: { ...versionsFromMetadata(rec?.metadata), ...pickVersions(rec?.toolchain), ...pickVersions(raw), ...pickVersions(versions) },\n  };\n}\n\n/**\n * Unwrap a `/plugins/lookup` answer. The platform's success envelope is\n * `{ success, statusCode, data: { plugin, warnings } }` (note the double\n * nesting: `data.plugin`); `{ data: Plugin }`, `{ plugin }` and a bare Plugin\n * are tolerated too. Returns the plugin (null when absent or nameless) and the\n * graded warnings (lifecycle, vulnerability, compliance) that ride beside it,\n * and — for a managed toolchain name — the release it resolved to (`toolchain`).\n *\n * Dependency-free (type-only imports) so the plugin-lookup Lambda can bundle it.\n */\nexport function unwrapLookup(body: unknown): { plugin: Plugin | null; warnings: LookupWarning[]; toolchain?: LookupToolchain } {\n  if (!body || typeof body !== 'object') return { plugin: null, warnings: [] };\n  const inner = (body as { data?: unknown }).data;\n  const container = (inner && typeof inner === 'object' ? inner : body) as { plugin?: unknown; warnings?: unknown; toolchain?: unknown };\n  const candidate = container.plugin ?? container;\n  const plugin = candidate && typeof candidate === 'object' && typeof (candidate as { name?: unknown }).name === 'string'\n    && (candidate as { name: string }).name.length > 0\n    ? candidate as Plugin\n    : null;\n  const warnings: LookupWarning[] = [];\n  if (Array.isArray(container.warnings)) {\n    for (const w of container.warnings) {\n      if (!w || typeof w !== 'object') continue;\n      const { code, message, severity } = w as { code?: unknown; message?: unknown; severity?: unknown };\n      if (typeof message !== 'string' || message.length === 0) continue;\n      warnings.push({\n        ...(typeof code === 'string' ? { code } : {}),\n        message,\n        severity: (LOOKUP_WARNING_SEVERITIES as readonly unknown[]).includes(severity) ? severity as LookupWarningSeverity : 'warning',\n      });\n    }\n  }\n  const toolchain = parseLookupToolchain(container.toolchain, plugin);\n  return { plugin, warnings, ...(toolchain && { toolchain }) };\n}\n\n/**\n * One line summarizing graded warnings, most serious first —\n * `3 plugin warnings: 1 critical, 2 error`. Null when there are none.\n */\nexport function summarizeLookupWarnings(warnings: readonly Pick<LookupWarning, 'severity'>[]): string | null {\n  if (warnings.length === 0) return null;\n  const parts = [...LOOKUP_WARNING_SEVERITIES].reverse()\n    .map((sev) => [sev, warnings.filter((w) => w.severity === sev).length] as const)\n    .filter(([, n]) => n > 0)\n    .map(([sev, n]) => `${n} ${sev}`);\n  return `${warnings.length} plugin warning${warnings.length === 1 ? '' : 's'}: ${parts.join(', ')}`;\n}\n\n/** Why a lookup found nothing, as the plugin service's 404 `details.state` reports it. */\nexport type LookupNotFoundState = 'deleted' | 'inactive' | 'yanked' | 'missing';\n\nconst NOT_FOUND_STATES: readonly LookupNotFoundState[] = ['deleted', 'inactive', 'yanked', 'missing'];\n\n/**\n * `details.state` of a refused lookup, read off either an axios-style error\n * (`err.response.data`) or the response body itself. Null when absent/unknown.\n */\nexport function lookupNotFoundState(errOrBody: unknown): LookupNotFoundState | null {\n  if (!errOrBody || typeof errOrBody !== 'object') return null;\n  const data = (errOrBody as { response?: { data?: unknown } }).response?.data ?? errOrBody;\n  const details = data && typeof data === 'object' ? (data as { details?: unknown }).details : undefined;\n  const state = details && typeof details === 'object' ? (details as { state?: unknown }).state : undefined;\n  return typeof state === 'string' && (NOT_FOUND_STATES as readonly string[]).includes(state) ? state as LookupNotFoundState : null;\n}\n\n/**\n * The message for an exact version pin that did not resolve. Shared by the\n * CLI's pre-resolution and the deploy-time Lambda's CloudFormation reason.\n */\nexport function exactPinNotFoundMessage(label: string, pin: string, state: LookupNotFoundState | null): string {\n  switch (state) {\n    case 'deleted': return `Plugin \"${label}\" version ${pin} was deleted from your organization`;\n    case 'inactive': return `Plugin \"${label}\" version ${pin} is inactive`;\n    case 'yanked': return `Plugin \"${label}\" version ${pin} was yanked`;\n    case 'missing': return `Plugin \"${label}\" version ${pin} does not exist`;\n    default: return `Plugin \"${label}\" version ${pin} does not exist (never published, or refused by its build's vulnerability scan)`;\n  }\n}\n"]}

package/lib/core/self-mutation.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Self-mutation runtime (docs/plans/bootstrap-image-versioning.md §3, D10).
+ *
+ * Self-mutation runs on an AWS CURATED image, not the toolchain's bootstrap
+ * image, so a defective toolchain release can always be rolled back: the step
+ * that re-deploys the pipeline does not depend on the release it is replacing.
+ * It needs only Node and the CDK CLI. CDK Pipelines' SelfMutate runs
+ * `npm install -g aws-cdk@<cliVersion>` then `cdk -a <asm> deploy` (no
+ * re-synth), and `cliVersion` is always pinned to the release's `awsCdk`.
+ *
+ * The Node runtime is PINNED through `partialBuildSpec`
+ * `phases.install.runtime-versions.nodejs`, never left to the image default,
+ * and a contract test (test/self-mutation-runtime.test.ts) fails when the major
+ * falls outside the pinned CLI's `engines.node` or the image's published runtimes.
+ *
+ * CDK-free (plain data) so the root entry can export it.
+ */
+/** The curated CodeBuild image self-mutation runs on. */
+export declare const CURATED_SELF_MUTATION_IMAGE = "aws/codebuild/standard:8.0";
+/**
+ * Node.js runtime majors `aws/codebuild/standard:8.0` publishes for
+ * `runtime-versions.nodejs`.
+ *
+ * Source: https://github.com/aws/aws-codebuild-docker-images/blob/master/ubuntu/standard/8.0/runtimes.yml
+ * (`runtimes.nodejs.versions`; read 2026-11-13). Re-check when the image changes.
+ */
+export declare const CURATED_SELF_MUTATION_NODE_RUNTIMES: readonly number[];
+/** The Node.js major self-mutation pins (`runtime-versions.nodejs`). */
+export declare const SELF_MUTATION_NODE_MAJOR = 24;
+/** The `partialBuildSpec` object that pins self-mutation's Node runtime. */
+export declare function selfMutationPartialBuildSpec(): Record<string, unknown>;

package/lib/core/self-mutation.js

@@ -0,0 +1,36 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Self-mutation runtime (docs/plans/bootstrap-image-versioning.md §3, D10).
+ *
+ * Self-mutation runs on an AWS CURATED image, not the toolchain's bootstrap
+ * image, so a defective toolchain release can always be rolled back: the step
+ * that re-deploys the pipeline does not depend on the release it is replacing.
+ * It needs only Node and the CDK CLI. CDK Pipelines' SelfMutate runs
+ * `npm install -g aws-cdk@<cliVersion>` then `cdk -a <asm> deploy` (no
+ * re-synth), and `cliVersion` is always pinned to the release's `awsCdk`.
+ *
+ * The Node runtime is PINNED through `partialBuildSpec`
+ * `phases.install.runtime-versions.nodejs`, never left to the image default,
+ * and a contract test (test/self-mutation-runtime.test.ts) fails when the major
+ * falls outside the pinned CLI's `engines.node` or the image's published runtimes.
+ *
+ * CDK-free (plain data) so the root entry can export it.
+ */
+/** The curated CodeBuild image self-mutation runs on. */
+export const CURATED_SELF_MUTATION_IMAGE = 'aws/codebuild/standard:8.0';
+/**
+ * Node.js runtime majors `aws/codebuild/standard:8.0` publishes for
+ * `runtime-versions.nodejs`.
+ *
+ * Source: https://github.com/aws/aws-codebuild-docker-images/blob/master/ubuntu/standard/8.0/runtimes.yml
+ * (`runtimes.nodejs.versions`; read 2026-11-13). Re-check when the image changes.
+ */
+export const CURATED_SELF_MUTATION_NODE_RUNTIMES = [22, 24, 26];
+/** The Node.js major self-mutation pins (`runtime-versions.nodejs`). */
+export const SELF_MUTATION_NODE_MAJOR = 24;
+/** The `partialBuildSpec` object that pins self-mutation's Node runtime. */
+export function selfMutationPartialBuildSpec() {
+    return { phases: { install: { 'runtime-versions': { nodejs: String(SELF_MUTATION_NODE_MAJOR) } } } };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/step-manifest.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Step manifest: which plugin each CodePipeline action
+ * of a deployed pipeline runs. CDK-free half — the shapes and helpers shared by
+ * the synth (which records it, see `pipeline/step-manifest-recorder.ts`), the
+ * CLI (which ships it with the registry registration) and the pipeline service
+ * (which validates and stores it in `pipeline_step_manifests`).
+ *
+ * Event ingest joins `pipeline_events` on (pipeline_id, stage_name,
+ * action_name), so `stageName`/`actionName` here are read off the BUILT
+ * CodePipeline, never recomputed from our own ids — they are exactly the names
+ * CodePipeline state-change events report.
+ */
+import { BUILD_IMAGE_MANIFEST_ACTION, BUILD_IMAGE_MANIFEST_STAGE, BUILD_IMAGE_STEP_KEY, type ToolchainResolvedVia } from '@pipeline-builder/api-core';
+export { BUILD_IMAGE_MANIFEST_ACTION, BUILD_IMAGE_MANIFEST_STAGE, BUILD_IMAGE_STEP_KEY };
 /**
  * File the synth app writes the manifest to, inside the cloud assembly
  * directory (`cdk deploy --output=<dir>`). The CLI reads it back after a
@@ -35,6 +49,27 @@ export interface StepManifestEntry {
      */
     readonly stepKey?: string;
 }
+/**
+ * The pipeline's BUILD IMAGE: the toolchain release's `pipeline-bootstrap` half
+ * every plugin-less action runs on (docs/plans/bootstrap-image-versioning.md §4).
+ * Not a step — it rides the manifest as a non-step entry under the
+ * `build-image` key and the sentinel (stage, action) the platform stores it
+ * under, so the deploy-reference path (in-use protection) counts the release.
+ * `pluginVersion` IS the release version (both halves share it); the platform
+ * re-reads name/version/digest from the `pluginId` row as for every entry.
+ */
+export interface BuildImageManifestEntry extends StepManifestEntry {
+    readonly kind: 'build-image';
+    readonly stageName: typeof BUILD_IMAGE_MANIFEST_STAGE;
+    readonly actionName: typeof BUILD_IMAGE_MANIFEST_ACTION;
+    readonly stepKey: typeof BUILD_IMAGE_STEP_KEY;
+    readonly releaseVersion: string;
+    readonly imageRepository: string | null;
+    /** How the release was chosen for this pipeline at synth. */
+    readonly resolvedVia: ToolchainResolvedVia;
+}
+/** Whether a manifest entry is the {@link BuildImageManifestEntry}. */
+export declare function isBuildImageEntry(entry: StepManifestEntry): entry is BuildImageManifestEntry;
 /** The plugin fields {@link pluginImageRepository} reads. */
 export interface PluginImageRef {
     readonly orgId: string;

package/lib/core/step-manifest.js

@@ -12,7 +12,8 @@
  * CodePipeline, never recomputed from our own ids — they are exactly the names
  * CodePipeline state-change events report.
  */
-import { SYSTEM_ORG_ID } from '@pipeline-builder/api-core';
+import { BUILD_IMAGE_MANIFEST_ACTION, BUILD_IMAGE_MANIFEST_STAGE, BUILD_IMAGE_STEP_KEY, SYSTEM_ORG_ID, } from '@pipeline-builder/api-core';
+export { BUILD_IMAGE_MANIFEST_ACTION, BUILD_IMAGE_MANIFEST_STAGE, BUILD_IMAGE_STEP_KEY };
 /**
  * File the synth app writes the manifest to, inside the cloud assembly
  * directory (`cdk deploy --output=<dir>`). The CLI reads it back after a
@@ -25,6 +26,11 @@ export const STEP_MANIFEST_FILE = 'pb-step-manifest.json';
  * synth. Never a real `plugins` row, so the step manifest never records it.
  */
 export const PLACEHOLDER_PLUGIN_ID = '00000000-0000-0000-0000-000000000000';
+/** Whether a manifest entry is the {@link BuildImageManifestEntry}. */
+export function isBuildImageEntry(entry) {
+    return entry.kind === 'build-image'
+        || (entry.stageName === BUILD_IMAGE_MANIFEST_STAGE && entry.actionName === BUILD_IMAGE_MANIFEST_ACTION);
+}
 /**
  * Registry repository an org-owned plugin ROW's image lives at
  * (`<namespace>/<name>`, no host, no digest): the system org's under
@@ -44,4 +50,4 @@ export function pluginImageRepository(plugin) {
 }
 /** A plugin image repository lookup may return: `public/<publisher>/<name>`, `org-<id>/<name>` or `system/<name>`. */
 export const PLUGIN_IMAGE_REPOSITORY_RE = /^(?:public\/[a-z0-9]+(?:-[a-z0-9]+)*|org-[a-z0-9][a-z0-9-]*|system)\/[a-z0-9][a-z0-9._-]*$/;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-manifest.js","sources":["../../src/core/step-manifest.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,2BAA2B,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,aAAa,GAC7F,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,CAAC;AAEzF;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,uBAAuB,CAAC;AAE1D;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,sCAAsC,CAAC;AAgD5E,uEAAuE;AACvE,MAAM,UAAU,iBAAiB,CAAC,KAAwB;IACxD,OAAQ,KAA4B,CAAC,IAAI,KAAK,aAAa;WACtD,CAAC,KAAK,CAAC,SAAS,KAAK,0BAA0B,IAAI,KAAK,CAAC,UAAU,KAAK,2BAA2B,CAAC,CAAC;AAC5G,CAAC;AASD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAsB;IAC1D,IAAI,MAAM,CAAC,SAAS,KAAK,eAAe;QAAE,OAAO,IAAI,CAAC;IACtD,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,KAAK,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,MAAM,CAAC,KAAK,EAAE,CAAC;IACpF,OAAO,GAAG,SAAS,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;AACvC,CAAC;AAED,sHAAsH;AACtH,MAAM,CAAC,MAAM,0BAA0B,GAAG,4FAA4F,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Step manifest: which plugin each CodePipeline action\n * of a deployed pipeline runs. CDK-free half — the shapes and helpers shared by\n * the synth (which records it, see `pipeline/step-manifest-recorder.ts`), the\n * CLI (which ships it with the registry registration) and the pipeline service\n * (which validates and stores it in `pipeline_step_manifests`).\n *\n * Event ingest joins `pipeline_events` on (pipeline_id, stage_name,\n * action_name), so `stageName`/`actionName` here are read off the BUILT\n * CodePipeline, never recomputed from our own ids — they are exactly the names\n * CodePipeline state-change events report.\n */\n\nimport {\n  BUILD_IMAGE_MANIFEST_ACTION, BUILD_IMAGE_MANIFEST_STAGE, BUILD_IMAGE_STEP_KEY, SYSTEM_ORG_ID, type ToolchainResolvedVia,\n} from '@pipeline-builder/api-core';\n\nexport { BUILD_IMAGE_MANIFEST_ACTION, BUILD_IMAGE_MANIFEST_STAGE, BUILD_IMAGE_STEP_KEY };\n\n/**\n * File the synth app writes the manifest to, inside the cloud assembly\n * directory (`cdk deploy --output=<dir>`). The CLI reads it back after a\n * successful deploy and forwards it on the registry POST.\n */\nexport const STEP_MANIFEST_FILE = 'pb-step-manifest.json';\n\n/**\n * `id` of every synthesized placeholder plugin (PluginLookup `fallback()` /\n * `bootstrap()`) — a record standing in for a lookup that could not resolve at\n * synth. Never a real `plugins` row, so the step manifest never records it.\n */\nexport const PLACEHOLDER_PLUGIN_ID = '00000000-0000-0000-0000-000000000000';\n\n/**\n * One manifest entry as the synth records it. Carries the resolved plugin\n * record's id so the pipeline service can re-resolve the authoritative\n * name/version/digest/owner itself — the CLI's claim is never trusted for\n * anything that feeds cross-org stats (publisher, verified use).\n */\nexport interface StepManifestEntry {\n  /** CodePipeline stage name, as the built pipeline names it. */\n  readonly stageName: string;\n  /** CodePipeline action name, as the built pipeline names it. */\n  readonly actionName: string;\n  /** `plugins.id` of the resolved plugin record. */\n  readonly pluginId: string;\n  readonly pluginName: string;\n  readonly pluginVersion: string;\n  /** Signed image digest the step is pinned to; null for image-less plugins. */\n  readonly imageDigest: string | null;\n  /**\n   * The step's label (`pluginStepLabel`: `synth` or `<stage>/<alias ?? name>`) —\n   * what the CLI and the lookup Lambda send as lookup `context.stepKeys`, and the\n   * run-time check asks about. Lets the platform join lookup warnings to this\n   * manifest row.\n   */\n  readonly stepKey?: string;\n}\n\n/**\n * The pipeline's BUILD IMAGE: the toolchain release's `pipeline-bootstrap` half\n * every plugin-less action runs on (docs/plans/bootstrap-image-versioning.md §4).\n * Not a step — it rides the manifest as a non-step entry under the\n * `build-image` key and the sentinel (stage, action) the platform stores it\n * under, so the deploy-reference path (in-use protection) counts the release.\n * `pluginVersion` IS the release version (both halves share it); the platform\n * re-reads name/version/digest from the `pluginId` row as for every entry.\n */\nexport interface BuildImageManifestEntry extends StepManifestEntry {\n  readonly kind: 'build-image';\n  readonly stageName: typeof BUILD_IMAGE_MANIFEST_STAGE;\n  readonly actionName: typeof BUILD_IMAGE_MANIFEST_ACTION;\n  readonly stepKey: typeof BUILD_IMAGE_STEP_KEY;\n  readonly releaseVersion: string;\n  readonly imageRepository: string | null;\n  /** How the release was chosen for this pipeline at synth. */\n  readonly resolvedVia: ToolchainResolvedVia;\n}\n\n/** Whether a manifest entry is the {@link BuildImageManifestEntry}. */\nexport function isBuildImageEntry(entry: StepManifestEntry): entry is BuildImageManifestEntry {\n  return (entry as { kind?: unknown }).kind === 'build-image'\n    || (entry.stageName === BUILD_IMAGE_MANIFEST_STAGE && entry.actionName === BUILD_IMAGE_MANIFEST_ACTION);\n}\n\n/** The plugin fields {@link pluginImageRepository} reads. */\nexport interface PluginImageRef {\n  readonly orgId: string;\n  readonly name: string;\n  readonly buildType?: string | null;\n}\n\n/**\n * Registry repository an org-owned plugin ROW's image lives at\n * (`<namespace>/<name>`, no host, no digest): the system org's under\n * `system/`, a tenant's under `org-<orgId>/`. Must match the push side\n * (api/plugin `pluginUri`). Returns null for a `metadata_only` plugin.\n *\n * Only for rows the caller's org resolves as its OWN (or its parent's): the\n * plugin lookup stamps it as the record's `imageRepository`. A listed plugin's\n * repository is its listing version's `public/<publisher>/<name>` copy —\n * synth never derives a repository itself.\n */\nexport function pluginImageRepository(plugin: PluginImageRef): string | null {\n  if (plugin.buildType === 'metadata_only') return null;\n  const namespace = plugin.orgId === SYSTEM_ORG_ID ? 'system' : `org-${plugin.orgId}`;\n  return `${namespace}/${plugin.name}`;\n}\n\n/** A plugin image repository lookup may return: `public/<publisher>/<name>`, `org-<id>/<name>` or `system/<name>`. */\nexport const PLUGIN_IMAGE_REPOSITORY_RE = /^(?:public\\/[a-z0-9]+(?:-[a-z0-9]+)*|org-[a-z0-9][a-z0-9-]*|system)\\/[a-z0-9][a-z0-9._-]*$/;\n"]}