@pipeline-builder/pipeline-manager 4.4.6 → 4.4.8

package/dist/utils/plugin-resolver.js

@@ -1,7 +1,8 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { ErrorCode, errorMessage } from '@pipeline-builder/api-core';
-import { pluginArtifactAlias, pluginLookupFilter, unwrapLookup } from '@pipeline-builder/pipeline-core';
+import { collectPluginSteps, exactPinNotFoundMessage, lookupNotFoundState, pluginArtifactAlias, pluginLookupFilter, summarizeLookupWarnings, unwrapLookup, } from '@pipeline-builder/pipeline-core';
+import pico from 'picocolors';
 import { ApiClient } from './api-client.js';
 import { printWarning } from './output-utils.js';
 /**
@@ -61,17 +62,20 @@ function collectPluginRefs(props) {
 /**
  * Lookup refusals that must STOP the synth rather than fall back to
  * deploy-time resolution: an image whose signature doesn't verify, a listing
- * the org can't use (not installed, blocked by its policy, yanked or
- * suspended), and — with `PLUGIN_BLOCK_ON_NEW_CRITICAL` on — a pin to a
- * version the nightly rescan flagged. Falling back would quietly turn each into
- * an unresolved step that fails at run time instead of now.
+ * the org can't use (not installed, blocked by its allow/deny policy, yanked
+ * or suspended), and an org plugin that was deleted. Falling back would
+ * quietly turn each into an unresolved step that fails at run time instead of
+ * now. Vulnerability state is NEVER one of these: it arrives as graded
+ * warnings beside a resolved plugin.
  */
 const FATAL_LOOKUP_CODES = [
     ErrorCode.IMAGE_VERIFICATION_FAILED,
     ErrorCode.PLUGIN_NOT_INSTALLED,
     ErrorCode.PLUGIN_BLOCKED_BY_POLICY,
     ErrorCode.PLUGIN_UNAVAILABLE,
-    ErrorCode.PLUGIN_VERSION_VULN_BLOCKED,
+    // The org's own plugin was deleted: the lookup refuses it rather than fall
+    // through to a same-name listing. (Plugin service code; matched as a string.)
+    'PLUGIN_DELETED',
 ];
 /** The error code of a plugin service answer, when it is one of {@link FATAL_LOOKUP_CODES}. */
 function fatalLookupCode(err) {
@@ -79,6 +83,68 @@ function fatalLookupCode(err) {
     const code = data && typeof data === 'object' ? data.code : undefined;
     return typeof code === 'string' && FATAL_LOOKUP_CODES.includes(code) ? code : null;
 }
+/** Whether the plugin service answered "no such plugin/version" (404 NOT_FOUND). */
+function isNotFound(err) {
+    const response = err?.response;
+    const code = response?.data && typeof response.data === 'object' ? response.data.code : undefined;
+    return response?.status === 404 || code === ErrorCode.NOT_FOUND;
+}
+/**
+ * The version a reference PINS — one exact `x.y.z[-pre]`, not a range or
+ * `latest`. A pin names a version that must exist: if it doesn't (never
+ * published, or refused by the build's vulnerability gate, which saves
+ * nothing), there is no outage to ride out and nothing for the deploy-time
+ * lookup to find either.
+ */
+function exactVersionPin(ref) {
+    const version = ref.filter?.version;
+    return typeof version === 'string' && /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(version) ? version : null;
+}
+/**
+ * Every fatal refusal of one pre-resolution pass. Carries the structured list
+ * as well as the human message, so the synth can emit a machine-readable
+ * failure line (`PB_SYNTH_FAILURE`) the execution events pick up.
+ */
+export class PluginResolutionError extends Error {
+    refusals;
+    constructor(refusals) {
+        super(refusals.length === 1
+            ? refusals[0].message
+            : `${refusals.length} plugins can't be used:\n${refusals.map((r) => `  - ${r.message}`).join('\n')}`);
+        this.refusals = refusals;
+        this.name = 'PluginResolutionError';
+    }
+}
+/**
+ * Why an exact pin was not found, phrased from the 404's `details.state`
+ * (`deleted` / `inactive` / `yanked` / `missing`). Without a state the answer
+ * cannot tell the cases apart, so the message names the two likeliest.
+ * Shared with the deploy-time Lambda's CloudFormation reason (pipeline-core).
+ */
+function pinNotFoundMessage(label, pin, err) {
+    return exactPinNotFoundMessage(label, pin, lookupNotFoundState(err));
+}
+const SEVERITY_STYLE = {
+    info: pico.cyan,
+    warning: pico.yellow,
+    error: pico.red,
+    critical: (t) => pico.bold(pico.red(t)),
+};
+/** Print one lookup warning, prefixed and coloured by its severity. */
+export function printLookupWarning(label, warning) {
+    const tag = SEVERITY_STYLE[warning.severity](`[${warning.severity.toUpperCase()}]`);
+    printWarning(`${tag} Plugin "${label}": ${warning.message}`);
+}
+/** Print the one-line severity summary of a synth's lookup warnings (nothing when none). */
+export function printLookupWarningSummary(warnings) {
+    const line = summarizeLookupWarnings(warnings);
+    if (!line)
+        return;
+    const worst = warnings.some((w) => w.severity === 'critical') ? 'critical'
+        : warnings.some((w) => w.severity === 'error') ? 'error'
+            : warnings.some((w) => w.severity === 'warning') ? 'warning' : 'info';
+    printWarning(SEVERITY_STYLE[worst](line));
+}
 /** The plugin service's own refusal message, when the answer carries one. */
 function serviceMessage(err) {
     const data = err?.response?.data;
@@ -95,16 +161,40 @@ function serviceMessage(err) {
  *
  * Failures are non-fatal: a missing plugin or unreachable API logs a warning
  * and falls through to the deploy-time custom resource path so partial
- * platform outages don't block synth/deploy. The exception is an image that
- * fails signature verification — that aborts the synth.
+ * platform outages don't block synth/deploy. The exceptions abort the synth:
+ * the {@link FATAL_LOOKUP_CODES} refusals, and an exact version pin that does
+ * not exist.
+ *
+ * Every reference is looked up before anything is thrown, and ALL fatal
+ * refusals are reported together. Stopping at the first meant a pipeline with
+ * three refused plugins took three synth attempts to learn about all three.
+ *
+ * Every lookup warning is printed, graded by severity, and appended to
+ * `warningSink` when given (the synth prints a one-line summary at its end).
+ * A warning never fails the synth — vulnerability state is reported, not
+ * enforced.
+ *
+ * When the props carry a `pipelineId`, each lookup also sends
+ * `context: { pipelineId, stepKeys }` — the label (`pluginStepLabel`: `synth` or
+ * `<stage>/<alias ?? name>`) of EVERY step the de-duplicated reference serves —
+ * so the plugin service can record the warnings it returns against each of
+ * those pipeline steps, not only print them into this synth's log.
  *
  * Keyed by `alias || name` to match `PluginLookup.plugin()`.
  */
-export async function resolvePluginsForProps(client, props) {
+export async function resolvePluginsForProps(client, props, warningSink) {
     const refs = collectPluginRefs(props);
     if (refs.length === 0)
         return {};
+    const pipelineId = typeof props.pipelineId === 'string' && props.pipelineId.length > 0 ? props.pipelineId : undefined;
+    // One lookup per alias may serve several steps: the labels of each, by alias.
+    const stepKeys = new Map();
+    for (const step of collectPluginSteps(props)) {
+        const key = cacheKey(step);
+        stepKeys.set(key, [...(stepKeys.get(key) ?? []), step.label]);
+    }
     const resolved = {};
+    const fatal = [];
     await Promise.all(refs.map(async (ref) => {
         const key = cacheKey(ref);
         const label = ref.publisher ? `${ref.publisher}/${ref.name}` : ref.name;
@@ -117,15 +207,24 @@ export async function resolvePluginsForProps(client, props) {
         // the ref's plugin name; an explicit filter `name` still takes precedence.
         // Shared with the pipeline service's contract check (same filter, same plugin).
         const filter = pluginLookupFilter(ref);
+        const pin = exactVersionPin(ref);
+        const refuse = (code, message) => { fatal.push({ plugin: label, code, message }); };
         try {
-            const res = await client.post('/api/plugins/lookup', { filter });
+            const res = await client.post('/api/plugins/lookup', {
+                filter,
+                ...(pipelineId && stepKeys.has(key) ? { context: { pipelineId, stepKeys: stepKeys.get(key) } } : {}),
+            });
             const { plugin, warnings } = unwrapLookup(res);
             for (const warning of warnings) {
-                printWarning(`Plugin "${label}": ${warning}`);
+                printLookupWarning(label, warning);
+                warningSink?.push(warning);
             }
             if (plugin) {
                 resolved[key] = plugin;
             }
+            else if (pin) {
+                refuse('PLUGIN_VERSION_NOT_FOUND', pinNotFoundMessage(label, pin));
+            }
             else {
                 printWarning(`Plugin "${label}" lookup returned no record — falling back to deploy-time resolution`);
             }
@@ -134,20 +233,25 @@ export async function resolvePluginsForProps(client, props) {
             // A plugin whose image signature doesn't verify, or a listing the org
             // can't use, is NOT an outage to ride out: falling back would quietly
             // turn it into an unresolved step. Stop.
-            const fatal = fatalLookupCode(err);
-            if (fatal === ErrorCode.IMAGE_VERIFICATION_FAILED) {
-                throw new Error(`Plugin "${label}" image failed signature verification: ${errorMessage(err)}`);
+            const code = fatalLookupCode(err);
+            if (code === ErrorCode.IMAGE_VERIFICATION_FAILED) {
+                refuse(code, `Plugin "${label}" image failed signature verification: ${errorMessage(err)}`);
+                return;
+            }
+            if (code) {
+                refuse(code, `Plugin "${label}" can't be used (${code}): ${serviceMessage(err) ?? errorMessage(err)}`);
+                return;
+            }
+            if (pin && isNotFound(err)) {
+                refuse('PLUGIN_VERSION_NOT_FOUND', pinNotFoundMessage(label, pin, err));
+                return;
             }
-            // The block-mode refusal already names the version, the CVEs and the fix:
-            // print it as the platform wrote it.
-            if (fatal === ErrorCode.PLUGIN_VERSION_VULN_BLOCKED)
-                throw new Error(serviceMessage(err) ?? errorMessage(err));
-            if (fatal)
-                throw new Error(`Plugin "${label}" can't be used (${fatal}): ${errorMessage(err)}`);
             const msg = errorMessage(err);
             printWarning(`Plugin "${label}" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);
         }
     }));
+    if (fatal.length > 0)
+        throw new PluginResolutionError(fatal);
     return resolved;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-resolver.js","sourceRoot":"","sources":["../../src/utils/plugin-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode, errorMessage } from '@pipeline-builder/api-core';\nimport { pluginArtifactAlias, pluginLookupFilter, unwrapLookup } from '@pipeline-builder/pipeline-core';\nimport { ApiClient } from './api-client.js';\nimport { printWarning } from './output-utils.js';\n\n/** Minimal plugin reference shape — matches PluginOptions from pipeline-core. */\ninterface PluginRef {\n  name: string;\n  /** Publisher handle of an installed listing. */\n  publisher?: string;\n  alias?: string;\n  filter?: Record<string, unknown>;\n}\n\n/**\n * Cache key matching `PluginLookup.normalize()`: the explicit alias when set,\n * otherwise `[<publisher>-]<name>-alias` — pipeline-core's\n * `pluginArtifactAlias`, the one rule every consumer of this map uses.\n */\nfunction cacheKey(ref: PluginRef): string {\n  return pluginArtifactAlias(ref);\n}\n\n/**\n * Walk the pipeline props tree to collect every plugin reference. Plugins\n * appear at `synth.plugin` and at `stages[].steps[].plugin`. Entries are\n * de-duplicated by `cacheKey()` — the same key `PluginLookup.plugin()` uses,\n * so the resolved-plugins map lookups match downstream.\n */\nfunction collectPluginRefs(props: Record<string, unknown>): PluginRef[] {\n  const refs: PluginRef[] = [];\n  const seen = new Map<string, string>();\n\n  const push = (raw: unknown): void => {\n    if (!raw || typeof raw !== 'object') return;\n    const r = raw as PluginRef;\n    if (!r.name) return;\n    const key = cacheKey(r);\n    // The name the lookup will TARGET — an explicit `filter.name` wins (see\n    // below), so two refs that resolve to the same plugin are not a collision.\n    const name = (r.filter?.name as string | undefined) ?? r.name;\n    const target = r.publisher ? `${r.publisher}/${name}` : name;\n    const holder = seen.get(key);\n    if (holder !== undefined) {\n      // One alias can only ever mean one plugin. Deduplicating on the alias\n      // alone kept the FIRST plugin and silently dropped the second, so a step\n      // declaring `{ name: 'maven-build', alias: 'build' }` after another\n      // declaring `{ name: 'nodejs-build', alias: 'build' }` ran nodejs-build's\n      // image and commands — no error, just the wrong build.\n      if (holder !== target) {\n        throw new Error(\n          `Plugin alias \"${key}\" is used for two different plugins (\"${holder}\" and \"${target}\"). `\n          + 'Give each plugin its own alias.',\n        );\n      }\n      return;\n    }\n    seen.set(key, target);\n    refs.push(r);\n  };\n\n  const synth = props.synth as { plugin?: unknown } | undefined;\n  push(synth?.plugin);\n\n  const stages = props.stages as Array<{ steps?: Array<{ plugin?: unknown }> }> | undefined;\n  for (const stage of stages ?? []) {\n    for (const step of stage.steps ?? []) {\n      push(step.plugin);\n    }\n  }\n\n  return refs;\n}\n\n/**\n * Lookup refusals that must STOP the synth rather than fall back to\n * deploy-time resolution: an image whose signature doesn't verify, a listing\n * the org can't use (not installed, blocked by its policy, yanked or\n * suspended), and — with `PLUGIN_BLOCK_ON_NEW_CRITICAL` on — a pin to a\n * version the nightly rescan flagged. Falling back would quietly turn each into\n * an unresolved step that fails at run time instead of now.\n */\nconst FATAL_LOOKUP_CODES: readonly string[] = [\n  ErrorCode.IMAGE_VERIFICATION_FAILED,\n  ErrorCode.PLUGIN_NOT_INSTALLED,\n  ErrorCode.PLUGIN_BLOCKED_BY_POLICY,\n  ErrorCode.PLUGIN_UNAVAILABLE,\n  ErrorCode.PLUGIN_VERSION_VULN_BLOCKED,\n];\n\n/** The error code of a plugin service answer, when it is one of {@link FATAL_LOOKUP_CODES}. */\nfunction fatalLookupCode(err: unknown): string | null {\n  const data = (err as { response?: { data?: unknown } } | undefined)?.response?.data;\n  const code = data && typeof data === 'object' ? (data as { code?: unknown }).code : undefined;\n  return typeof code === 'string' && FATAL_LOOKUP_CODES.includes(code) ? code : null;\n}\n\n/** The plugin service's own refusal message, when the answer carries one. */\nfunction serviceMessage(err: unknown): string | null {\n  const data = (err as { response?: { data?: unknown } } | undefined)?.response?.data;\n  const message = data && typeof data === 'object' ? (data as { message?: unknown }).message : undefined;\n  return typeof message === 'string' && message.length > 0 ? message : null;\n}\n\n/**\n * Pre-resolve plugins by calling the same `POST /api/plugins/lookup` endpoint\n * the deploy-time custom resource Lambda uses. Returning the full Plugin\n * record at synth time is what allows the resulting CFN template to ship\n * with real CodeBuild image URIs (`<host>/<ns>/<name>:<version>`) rather than\n * the `aws/codebuild/standard:7.0` fallback that the synth-time token path\n * forces.\n *\n * Failures are non-fatal: a missing plugin or unreachable API logs a warning\n * and falls through to the deploy-time custom resource path so partial\n * platform outages don't block synth/deploy. The exception is an image that\n * fails signature verification — that aborts the synth.\n *\n * Keyed by `alias || name` to match `PluginLookup.plugin()`.\n */\nexport async function resolvePluginsForProps(\n  client: ApiClient,\n  props: Record<string, unknown>,\n): Promise<Record<string, unknown>> {\n  const refs = collectPluginRefs(props);\n  if (refs.length === 0) return {};\n\n  const resolved: Record<string, unknown> = {};\n\n  await Promise.all(refs.map(async (ref) => {\n    const key = cacheKey(ref);\n    const label = ref.publisher ? `${ref.publisher}/${ref.name}` : ref.name;\n    // The plugin NAME lives on the ref (a sibling of `filter`), NOT inside the\n    // filter object — but the lookup matches on the filter. A filter without\n    // `name` (e.g. `{version, visibility, isActive, isDefault}`) matches ANY\n    // plugin with those attributes, and the endpoint returns an arbitrary one\n    // (seen: `dockerfile-multi-provider`). That made the synth and every step\n    // resolve to the WRONG plugin. So when the filter omits `name`, fall back to\n    // the ref's plugin name; an explicit filter `name` still takes precedence.\n    // Shared with the pipeline service's contract check (same filter, same plugin).\n    const filter = pluginLookupFilter(ref);\n    try {\n      const res = await client.post<unknown>('/api/plugins/lookup', { filter });\n      const { plugin, warnings } = unwrapLookup(res);\n      for (const warning of warnings) {\n        printWarning(`Plugin \"${label}\": ${warning}`);\n      }\n      if (plugin) {\n        resolved[key] = plugin;\n      } else {\n        printWarning(`Plugin \"${label}\" lookup returned no record — falling back to deploy-time resolution`);\n      }\n    } catch (err) {\n      // A plugin whose image signature doesn't verify, or a listing the org\n      // can't use, is NOT an outage to ride out: falling back would quietly\n      // turn it into an unresolved step. Stop.\n      const fatal = fatalLookupCode(err);\n      if (fatal === ErrorCode.IMAGE_VERIFICATION_FAILED) {\n        throw new Error(`Plugin \"${label}\" image failed signature verification: ${errorMessage(err)}`);\n      }\n      // The block-mode refusal already names the version, the CVEs and the fix:\n      // print it as the platform wrote it.\n      if (fatal === ErrorCode.PLUGIN_VERSION_VULN_BLOCKED) throw new Error(serviceMessage(err) ?? errorMessage(err));\n      if (fatal) throw new Error(`Plugin \"${label}\" can't be used (${fatal}): ${errorMessage(err)}`);\n      const msg = errorMessage(err);\n      printWarning(`Plugin \"${label}\" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);\n    }\n  }));\n\n  return resolved;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-resolver.js","sourceRoot":"","sources":["../../src/utils/plugin-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode, errorMessage } from '@pipeline-builder/api-core';\nimport {\n  collectPluginSteps, exactPinNotFoundMessage, lookupNotFoundState, type LookupWarning, type LookupWarningSeverity,\n  pluginArtifactAlias, pluginLookupFilter, summarizeLookupWarnings, unwrapLookup,\n} from '@pipeline-builder/pipeline-core';\nimport pico from 'picocolors';\nimport { ApiClient } from './api-client.js';\nimport { printWarning } from './output-utils.js';\n\n/** Minimal plugin reference shape — matches PluginOptions from pipeline-core. */\ninterface PluginRef {\n  name: string;\n  /** Publisher handle of an installed listing. */\n  publisher?: string;\n  alias?: string;\n  filter?: Record<string, unknown>;\n}\n\n/**\n * Cache key matching `PluginLookup.normalize()`: the explicit alias when set,\n * otherwise `[<publisher>-]<name>-alias` — pipeline-core's\n * `pluginArtifactAlias`, the one rule every consumer of this map uses.\n */\nfunction cacheKey(ref: PluginRef): string {\n  return pluginArtifactAlias(ref);\n}\n\n/**\n * Walk the pipeline props tree to collect every plugin reference. Plugins\n * appear at `synth.plugin` and at `stages[].steps[].plugin`. Entries are\n * de-duplicated by `cacheKey()` — the same key `PluginLookup.plugin()` uses,\n * so the resolved-plugins map lookups match downstream.\n */\nfunction collectPluginRefs(props: Record<string, unknown>): PluginRef[] {\n  const refs: PluginRef[] = [];\n  const seen = new Map<string, string>();\n\n  const push = (raw: unknown): void => {\n    if (!raw || typeof raw !== 'object') return;\n    const r = raw as PluginRef;\n    if (!r.name) return;\n    const key = cacheKey(r);\n    // The name the lookup will TARGET — an explicit `filter.name` wins (see\n    // below), so two refs that resolve to the same plugin are not a collision.\n    const name = (r.filter?.name as string | undefined) ?? r.name;\n    const target = r.publisher ? `${r.publisher}/${name}` : name;\n    const holder = seen.get(key);\n    if (holder !== undefined) {\n      // One alias can only ever mean one plugin. Deduplicating on the alias\n      // alone kept the FIRST plugin and silently dropped the second, so a step\n      // declaring `{ name: 'maven-build', alias: 'build' }` after another\n      // declaring `{ name: 'nodejs-build', alias: 'build' }` ran nodejs-build's\n      // image and commands — no error, just the wrong build.\n      if (holder !== target) {\n        throw new Error(\n          `Plugin alias \"${key}\" is used for two different plugins (\"${holder}\" and \"${target}\"). `\n          + 'Give each plugin its own alias.',\n        );\n      }\n      return;\n    }\n    seen.set(key, target);\n    refs.push(r);\n  };\n\n  const synth = props.synth as { plugin?: unknown } | undefined;\n  push(synth?.plugin);\n\n  const stages = props.stages as Array<{ steps?: Array<{ plugin?: unknown }> }> | undefined;\n  for (const stage of stages ?? []) {\n    for (const step of stage.steps ?? []) {\n      push(step.plugin);\n    }\n  }\n\n  return refs;\n}\n\n/**\n * Lookup refusals that must STOP the synth rather than fall back to\n * deploy-time resolution: an image whose signature doesn't verify, a listing\n * the org can't use (not installed, blocked by its allow/deny policy, yanked\n * or suspended), and an org plugin that was deleted. Falling back would\n * quietly turn each into an unresolved step that fails at run time instead of\n * now. Vulnerability state is NEVER one of these: it arrives as graded\n * warnings beside a resolved plugin.\n */\nconst FATAL_LOOKUP_CODES: readonly string[] = [\n  ErrorCode.IMAGE_VERIFICATION_FAILED,\n  ErrorCode.PLUGIN_NOT_INSTALLED,\n  ErrorCode.PLUGIN_BLOCKED_BY_POLICY,\n  ErrorCode.PLUGIN_UNAVAILABLE,\n  // The org's own plugin was deleted: the lookup refuses it rather than fall\n  // through to a same-name listing. (Plugin service code; matched as a string.)\n  'PLUGIN_DELETED',\n];\n\n/** The error code of a plugin service answer, when it is one of {@link FATAL_LOOKUP_CODES}. */\nfunction fatalLookupCode(err: unknown): string | null {\n  const data = (err as { response?: { data?: unknown } } | undefined)?.response?.data;\n  const code = data && typeof data === 'object' ? (data as { code?: unknown }).code : undefined;\n  return typeof code === 'string' && FATAL_LOOKUP_CODES.includes(code) ? code : null;\n}\n\n/** Whether the plugin service answered \"no such plugin/version\" (404 NOT_FOUND). */\nfunction isNotFound(err: unknown): boolean {\n  const response = (err as { response?: { status?: unknown; data?: unknown } } | undefined)?.response;\n  const code = response?.data && typeof response.data === 'object' ? (response.data as { code?: unknown }).code : undefined;\n  return response?.status === 404 || code === ErrorCode.NOT_FOUND;\n}\n\n/**\n * The version a reference PINS — one exact `x.y.z[-pre]`, not a range or\n * `latest`. A pin names a version that must exist: if it doesn't (never\n * published, or refused by the build's vulnerability gate, which saves\n * nothing), there is no outage to ride out and nothing for the deploy-time\n * lookup to find either.\n */\nfunction exactVersionPin(ref: PluginRef): string | null {\n  const version = ref.filter?.version;\n  return typeof version === 'string' && /^\\d+\\.\\d+\\.\\d+(-[0-9A-Za-z.-]+)?$/.test(version) ? version : null;\n}\n\n/** One plugin the synth could not use, as {@link PluginResolutionError} reports it. */\nexport interface PluginRefusal {\n  /** `[<publisher>/]<name>` of the reference. */\n  readonly plugin: string;\n  /** The plugin service's error code, or a local one (`PLUGIN_VERSION_NOT_FOUND`). */\n  readonly code: string;\n  readonly message: string;\n}\n\n/**\n * Every fatal refusal of one pre-resolution pass. Carries the structured list\n * as well as the human message, so the synth can emit a machine-readable\n * failure line (`PB_SYNTH_FAILURE`) the execution events pick up.\n */\nexport class PluginResolutionError extends Error {\n  constructor(readonly refusals: readonly PluginRefusal[]) {\n    super(refusals.length === 1\n      ? refusals[0]!.message\n      : `${refusals.length} plugins can't be used:\\n${refusals.map((r) => `  - ${r.message}`).join('\\n')}`);\n    this.name = 'PluginResolutionError';\n  }\n}\n\n/**\n * Why an exact pin was not found, phrased from the 404's `details.state`\n * (`deleted` / `inactive` / `yanked` / `missing`). Without a state the answer\n * cannot tell the cases apart, so the message names the two likeliest.\n * Shared with the deploy-time Lambda's CloudFormation reason (pipeline-core).\n */\nfunction pinNotFoundMessage(label: string, pin: string, err?: unknown): string {\n  return exactPinNotFoundMessage(label, pin, lookupNotFoundState(err));\n}\n\nconst SEVERITY_STYLE: Record<LookupWarningSeverity, (s: string) => string> = {\n  info: pico.cyan,\n  warning: pico.yellow,\n  error: pico.red,\n  critical: (t) => pico.bold(pico.red(t)),\n};\n\n/** Print one lookup warning, prefixed and coloured by its severity. */\nexport function printLookupWarning(label: string, warning: LookupWarning): void {\n  const tag = SEVERITY_STYLE[warning.severity](`[${warning.severity.toUpperCase()}]`);\n  printWarning(`${tag} Plugin \"${label}\": ${warning.message}`);\n}\n\n/** Print the one-line severity summary of a synth's lookup warnings (nothing when none). */\nexport function printLookupWarningSummary(warnings: readonly LookupWarning[]): void {\n  const line = summarizeLookupWarnings(warnings);\n  if (!line) return;\n  const worst = warnings.some((w) => w.severity === 'critical') ? 'critical'\n    : warnings.some((w) => w.severity === 'error') ? 'error'\n      : warnings.some((w) => w.severity === 'warning') ? 'warning' : 'info';\n  printWarning(SEVERITY_STYLE[worst](line));\n}\n\n/** The plugin service's own refusal message, when the answer carries one. */\nfunction serviceMessage(err: unknown): string | null {\n  const data = (err as { response?: { data?: unknown } } | undefined)?.response?.data;\n  const message = data && typeof data === 'object' ? (data as { message?: unknown }).message : undefined;\n  return typeof message === 'string' && message.length > 0 ? message : null;\n}\n\n/**\n * Pre-resolve plugins by calling the same `POST /api/plugins/lookup` endpoint\n * the deploy-time custom resource Lambda uses. Returning the full Plugin\n * record at synth time is what allows the resulting CFN template to ship\n * with real CodeBuild image URIs (`<host>/<ns>/<name>:<version>`) rather than\n * the `aws/codebuild/standard:7.0` fallback that the synth-time token path\n * forces.\n *\n * Failures are non-fatal: a missing plugin or unreachable API logs a warning\n * and falls through to the deploy-time custom resource path so partial\n * platform outages don't block synth/deploy. The exceptions abort the synth:\n * the {@link FATAL_LOOKUP_CODES} refusals, and an exact version pin that does\n * not exist.\n *\n * Every reference is looked up before anything is thrown, and ALL fatal\n * refusals are reported together. Stopping at the first meant a pipeline with\n * three refused plugins took three synth attempts to learn about all three.\n *\n * Every lookup warning is printed, graded by severity, and appended to\n * `warningSink` when given (the synth prints a one-line summary at its end).\n * A warning never fails the synth — vulnerability state is reported, not\n * enforced.\n *\n * When the props carry a `pipelineId`, each lookup also sends\n * `context: { pipelineId, stepKeys }` — the label (`pluginStepLabel`: `synth` or\n * `<stage>/<alias ?? name>`) of EVERY step the de-duplicated reference serves —\n * so the plugin service can record the warnings it returns against each of\n * those pipeline steps, not only print them into this synth's log.\n *\n * Keyed by `alias || name` to match `PluginLookup.plugin()`.\n */\nexport async function resolvePluginsForProps(\n  client: ApiClient,\n  props: Record<string, unknown>,\n  warningSink?: LookupWarning[],\n): Promise<Record<string, unknown>> {\n  const refs = collectPluginRefs(props);\n  if (refs.length === 0) return {};\n\n  const pipelineId = typeof props.pipelineId === 'string' && props.pipelineId.length > 0 ? props.pipelineId : undefined;\n  // One lookup per alias may serve several steps: the labels of each, by alias.\n  const stepKeys = new Map<string, string[]>();\n  for (const step of collectPluginSteps(props)) {\n    const key = cacheKey(step);\n    stepKeys.set(key, [...(stepKeys.get(key) ?? []), step.label]);\n  }\n  const resolved: Record<string, unknown> = {};\n  const fatal: PluginRefusal[] = [];\n\n  await Promise.all(refs.map(async (ref) => {\n    const key = cacheKey(ref);\n    const label = ref.publisher ? `${ref.publisher}/${ref.name}` : ref.name;\n    // The plugin NAME lives on the ref (a sibling of `filter`), NOT inside the\n    // filter object — but the lookup matches on the filter. A filter without\n    // `name` (e.g. `{version, visibility, isActive, isDefault}`) matches ANY\n    // plugin with those attributes, and the endpoint returns an arbitrary one\n    // (seen: `dockerfile-multi-provider`). That made the synth and every step\n    // resolve to the WRONG plugin. So when the filter omits `name`, fall back to\n    // the ref's plugin name; an explicit filter `name` still takes precedence.\n    // Shared with the pipeline service's contract check (same filter, same plugin).\n    const filter = pluginLookupFilter(ref);\n    const pin = exactVersionPin(ref);\n    const refuse = (code: string, message: string): void => { fatal.push({ plugin: label, code, message }); };\n    try {\n      const res = await client.post<unknown>('/api/plugins/lookup', {\n        filter,\n        ...(pipelineId && stepKeys.has(key) ? { context: { pipelineId, stepKeys: stepKeys.get(key) } } : {}),\n      });\n      const { plugin, warnings } = unwrapLookup(res);\n      for (const warning of warnings) {\n        printLookupWarning(label, warning);\n        warningSink?.push(warning);\n      }\n      if (plugin) {\n        resolved[key] = plugin;\n      } else if (pin) {\n        refuse('PLUGIN_VERSION_NOT_FOUND', pinNotFoundMessage(label, pin));\n      } else {\n        printWarning(`Plugin \"${label}\" lookup returned no record — falling back to deploy-time resolution`);\n      }\n    } catch (err) {\n      // A plugin whose image signature doesn't verify, or a listing the org\n      // can't use, is NOT an outage to ride out: falling back would quietly\n      // turn it into an unresolved step. Stop.\n      const code = fatalLookupCode(err);\n      if (code === ErrorCode.IMAGE_VERIFICATION_FAILED) {\n        refuse(code, `Plugin \"${label}\" image failed signature verification: ${errorMessage(err)}`);\n        return;\n      }\n      if (code) {\n        refuse(code, `Plugin \"${label}\" can't be used (${code}): ${serviceMessage(err) ?? errorMessage(err)}`);\n        return;\n      }\n      if (pin && isNotFound(err)) {\n        refuse('PLUGIN_VERSION_NOT_FOUND', pinNotFoundMessage(label, pin, err));\n        return;\n      }\n      const msg = errorMessage(err);\n      printWarning(`Plugin \"${label}\" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);\n    }\n  }));\n\n  if (fatal.length > 0) throw new PluginResolutionError(fatal);\n  return resolved;\n}\n"]}

package/dist/utils/registration-client.d.ts

@@ -0,0 +1,28 @@
+import { ApiClient } from './api-client.js';
+/** The command that provisions the registration key, named in every skip warning. */
+export declare const REGISTRATION_KEY_COMMAND = "pipeline-manager infra store-token --scope pipeline_registry:write --schedule";
+/**
+ * The client a pipeline-registry write (`POST /pipelines/registry`) is made with.
+ *
+ * - **A person's credential** (`auth login`, or a `PLATFORM_TOKEN` they set):
+ *   the same client. People hold `pipeline_registry:write` beside
+ *   `pipelines:write` through the Member and Admin Roles.
+ * - **The stored machine credential** (`--store-tokens`): NOT that client. The
+ *   `platform` key holds the Pipeline Automation Role — pipeline and plugin reads
+ *   only — so the registration goes out on the separate `pipeline-register` key,
+ *   read from the secret named by `PIPELINE_REGISTRATION_SECRET_NAME` (the synth
+ *   CodeBuild project carries it) or derived from the pipeline's org.
+ *
+ * There is no fallback to the platform key. When the registration key is absent
+ * or unreadable this returns `undefined` after a loud warning naming the
+ * `store-token` command that provisions it, and the caller skips registering —
+ * a stale step manifest is reported, a broken synth is not acceptable.
+ */
+export declare function resolveRegistrationClient(opts: {
+    client: ApiClient;
+    storeTokens?: boolean;
+    orgId?: string;
+    region?: string;
+    profile?: string;
+}): Promise<ApiClient | undefined>;
+//# sourceMappingURL=registration-client.d.ts.map

package/dist/utils/registration-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration-client.d.ts","sourceRoot":"","sources":["../../src/utils/registration-client.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAK5C,qFAAqF;AACrF,eAAO,MAAM,wBAAwB,kFAA8F,CAAC;AAEpI;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,MAAM,EAAE,SAAS,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CA6BjC"}

package/dist/utils/registration-client.js

@@ -0,0 +1,57 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { errorMessage } from '@pipeline-builder/api-core';
+import { PIPELINE_REGISTRATION_CAPABILITY, PIPELINE_REGISTRATION_SECRET_ENV, PIPELINE_REGISTRATION_SECRET_LEAF } from '@pipeline-builder/pipeline-core';
+import { ApiClient } from './api-client.js';
+import { getSecretValue } from './aws-secrets.js';
+import { printInfo, printWarning } from './output-utils.js';
+import { secretNameForOrg } from './platform-secret.js';
+/** The command that provisions the registration key, named in every skip warning. */
+export const REGISTRATION_KEY_COMMAND = `pipeline-manager infra store-token --scope ${PIPELINE_REGISTRATION_CAPABILITY} --schedule`;
+/**
+ * The client a pipeline-registry write (`POST /pipelines/registry`) is made with.
+ *
+ * - **A person's credential** (`auth login`, or a `PLATFORM_TOKEN` they set):
+ *   the same client. People hold `pipeline_registry:write` beside
+ *   `pipelines:write` through the Member and Admin Roles.
+ * - **The stored machine credential** (`--store-tokens`): NOT that client. The
+ *   `platform` key holds the Pipeline Automation Role — pipeline and plugin reads
+ *   only — so the registration goes out on the separate `pipeline-register` key,
+ *   read from the secret named by `PIPELINE_REGISTRATION_SECRET_NAME` (the synth
+ *   CodeBuild project carries it) or derived from the pipeline's org.
+ *
+ * There is no fallback to the platform key. When the registration key is absent
+ * or unreadable this returns `undefined` after a loud warning naming the
+ * `store-token` command that provisions it, and the caller skips registering —
+ * a stale step manifest is reported, a broken synth is not acceptable.
+ */
+export async function resolveRegistrationClient(opts) {
+    if (!opts.storeTokens)
+        return opts.client;
+    const secretName = process.env[PIPELINE_REGISTRATION_SECRET_ENV]
+        || (opts.orgId ? secretNameForOrg(opts.orgId, PIPELINE_REGISTRATION_SECRET_LEAF) : undefined);
+    if (!secretName) {
+        printWarning(`SKIPPING pipeline registration: no ${PIPELINE_REGISTRATION_SECRET_ENV} and no orgId to derive the registration key's secret from. `
+            + `The stored platform key cannot register pipelines. Provision the registration key with: ${REGISTRATION_KEY_COMMAND}`);
+        return undefined;
+    }
+    let key;
+    try {
+        const secret = JSON.parse(await getSecretValue(secretName, { region: opts.region, profile: opts.profile }));
+        key = secret.password;
+    }
+    catch (err) {
+        printWarning(`SKIPPING pipeline registration: could not read the registration key from ${secretName} (${errorMessage(err)}). `
+            + 'The stored platform key cannot register pipelines, so the platform\'s step manifest for this pipeline is now stale. '
+            + `Provision the registration key with: ${REGISTRATION_KEY_COMMAND}`);
+        return undefined;
+    }
+    if (!key) {
+        printWarning(`SKIPPING pipeline registration: ${secretName} holds no key (password field). Re-provision it with: ${REGISTRATION_KEY_COMMAND}`);
+        return undefined;
+    }
+    printInfo('Registering with the pipeline-registration key', { secret: secretName });
+    const config = opts.client.getConfig();
+    return new ApiClient({ ...config, auth: { ...config.auth, token: key } });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/request-context.d.ts

@@ -0,0 +1,11 @@
+/** The header the platform's quota attribution reads the pipeline from. */
+export declare const PIPELINE_ID_HEADER = "X-Pipeline-Id";
+/** Name the pipeline this invocation's platform calls are made for (unset with `undefined`). */
+export declare function setPipelineId(id: string | undefined): void;
+/** Adopt the command's execution id as this invocation's request id. */
+export declare function setInvocationId(id: string): void;
+/** This invocation's request id — the command's execution id, else a per-process uuid. */
+export declare function getInvocationId(): string;
+/** The correlation headers for this invocation (values sanitized, unknown ids omitted). */
+export declare function requestCorrelationHeaders(env?: NodeJS.ProcessEnv): Record<string, string>;
+//# sourceMappingURL=request-context.d.ts.map

package/dist/utils/request-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../src/utils/request-context.ts"],"names":[],"mappings":"AA8BA,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAE1D;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEhD;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,IAAI,MAAM,CAGxC;AAED,2FAA2F;AAC3F,wBAAgB,yBAAyB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYtG"}

package/dist/utils/request-context.js

@@ -0,0 +1,62 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { randomUUID } from 'node:crypto';
+import { correlationHeaders, sanitizeCorrelationValue } from '@pipeline-builder/pipeline-core';
+/**
+ * The audit-correlation headers every platform call from this CLI carries, so
+ * a server-side audit row joins back to the run that caused it.
+ *
+ * - `X-Request-Id` — the command's execution id (the `[EXE-…]` printed in the
+ *   header and the local audit log), or a uuid for this process when no command
+ *   header was printed.
+ * - `X-CodeBuild-Build-Id` — CODEBUILD_BUILD_ID (`<project>:<uuid>`) when running
+ *   inside CodeBuild.
+ * - `X-Pipeline-Execution-Id` — PIPELINE_EXECUTION_ID, which the synth injects into
+ *   every CodeBuild step from `#{codepipeline.PipelineExecutionId}`. Sent only
+ *   when set: CODEBUILD_INITIATOR (`codepipeline/<name>`) names the pipeline, not
+ *   the execution, so nothing is derived from it.
+ * - `X-Pipeline-Id` — the platform pipeline a command works on (synth, deploy,
+ *   plugin verify, security-report), once the command knows it
+ *   ({@link setPipelineId}). The quota service's usage ledger records it, so
+ *   "what spent our calls?" can answer "this pipeline's builds".
+ *
+ * Never an ARN — nothing here can carry an AWS account id.
+ */
+let invocationId;
+let pipelineId;
+/** The header the platform's quota attribution reads the pipeline from. */
+export const PIPELINE_ID_HEADER = 'X-Pipeline-Id';
+/** Name the pipeline this invocation's platform calls are made for (unset with `undefined`). */
+export function setPipelineId(id) {
+    pipelineId = id;
+}
+/** Adopt the command's execution id as this invocation's request id. */
+export function setInvocationId(id) {
+    invocationId = id;
+}
+/** This invocation's request id — the command's execution id, else a per-process uuid. */
+export function getInvocationId() {
+    invocationId ??= randomUUID();
+    return invocationId;
+}
+/** The correlation headers for this invocation (values sanitized, unknown ids omitted). */
+export function requestCorrelationHeaders(env = process.env) {
+    const inCodeBuild = Boolean(env.CODEBUILD_BUILD_ID);
+    const headers = correlationHeaders({
+        requestId: getInvocationId(),
+        codeBuildBuildId: inCodeBuild ? env.CODEBUILD_BUILD_ID : undefined,
+        pipelineExecutionId: inCodeBuild ? env.PIPELINE_EXECUTION_ID : undefined,
+    });
+    // Same sanitizer as the other ids: a value that isn't a plain id is dropped,
+    // never sent mangled.
+    const pipeline = sanitizeCorrelationValue(pipelineId);
+    if (pipeline)
+        headers[PIPELINE_ID_HEADER] = pipeline;
+    return headers;
+}
+/** @internal Test-only: forget the invocation id. */
+export function _resetInvocationIdForTests() {
+    invocationId = undefined;
+    pipelineId = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/service-account.d.ts

@@ -1,3 +1,4 @@
+import type { SeedBundleId } from '@pipeline-builder/api-core';
 import type { ApiClient } from './api-client.js';
 /** What the caller wants provisioned. */
 export interface ProvisionKeyOptions {
@@ -10,11 +11,12 @@ export interface ProvisionKeyOptions {
     /** Human description recorded on a newly created account. */
     description: string;
     /**
-     * Roles to grant a NEWLY created account: `'admin'` for the full-privilege
-     * platform credential (synth/deploy callbacks, plugin lookup, image push),
-     * `'none'` for a scoped credential, which needs no Roles at all.
+     * The built-in Role (by seed bundle) to grant a NEWLY created account —
+     * `pipeline_automation` for the platform credential, `pipeline_registration`
+     * for the registration one. Absent for a scoped credential, which needs no
+     * Role at all.
      */
-    roles: 'admin' | 'none';
+    role?: SeedBundleId;
     /** Narrow capability scope stamped on the KEY (not the account). */
     scope?: string;
     /** Key lifetime in seconds (platform caps this at 365 days). */

package/dist/utils/service-account.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-account.d.ts","sourceRoot":"","sources":["../../src/utils/service-account.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,yCAAyC;AACzC,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,MAAM,EAAE,SAAS,CAAC;IAClB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,gBAAgB,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAiDD,iDAAiD;AACjD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAO9E;AA0DD,qFAAqF;AACrF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf;AAyCD;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CAanG"}
+{"version":3,"file":"service-account.d.ts","sourceRoot":"","sources":["../../src/utils/service-account.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,yCAAyC;AACzC,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,MAAM,EAAE,SAAS,CAAC;IAClB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,gBAAgB,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAiDD,iDAAiD;AACjD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAO9E;AA+DD,qFAAqF;AACrF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf;AAyCD;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CAanG"}