@pipeline-builder/pipeline-core 4.1.14 → 4.1.16

package/lib/core/plugin-contract.d.ts

@@ -0,0 +1,126 @@
+import type { MetaDataType } from './pipeline-types.js';
+/** Declared coercion type of a contract key. */
+export type ContractValueType = 'string' | 'number' | 'bool' | 'json';
+/** The contract fields of a plugin record (as `plugins` stores them). */
+export interface PluginContract {
+    readonly requiredMetadata?: readonly string[] | null;
+    readonly requiredVars?: readonly string[] | null;
+    readonly metadataTypes?: Readonly<Record<string, ContractValueType>> | null;
+    readonly varsTypes?: Readonly<Record<string, ContractValueType>> | null;
+}
+/** What `{{ pipeline.metadata.* }}` and `{{ pipeline.vars.* }}` resolve against. */
+export interface ContractScope {
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly vars: Readonly<Record<string, unknown>>;
+}
+/** One unmet contract key. */
+export interface ContractIssue {
+    readonly kind: 'metadata' | 'vars';
+    readonly key: string;
+    readonly problem: 'missing' | 'type';
+    /** The declared type, for a `type` problem. */
+    readonly expected?: ContractValueType;
+    readonly message: string;
+}
+/** The pipeline-props fields the contract scope is built from (BuilderProps subset). */
+export interface ContractScopeProps {
+    readonly global?: unknown;
+    readonly defaults?: unknown;
+    readonly synth?: unknown;
+    readonly vars?: unknown;
+}
+/**
+ * `pipeline.metadata` as synth builds it: `global` ← `defaults.metadata` ←
+ * `synth.metadata` (last wins). The single definition — `PipelineConfiguration`
+ * uses it too, so the API check and the synth scope cannot drift.
+ */
+export declare function pipelineScopeMetadata(props: ContractScopeProps): MetaDataType;
+/** The contract scope of a pipeline's props (see {@link pipelineScopeMetadata}). */
+export declare function pipelineContractScope(props: ContractScopeProps): ContractScope;
+/**
+ * The contract scope inside a synth template scope (`{ pipeline: { metadata,
+ * vars, … } }`, see `PipelineConfiguration.getPipelineScope`).
+ */
+export declare function contractScopeFromTemplateScope(templateScope: Readonly<Record<string, unknown>>): ContractScope;
+/**
+ * Does `value` satisfy the declared `type` once interpolated? Mirrors the
+ * evaluator's `resolveOne` (objects never interpolate) and `applyCoercion`.
+ */
+export declare function isContractValueOfType(value: unknown, type: ContractValueType): boolean;
+/**
+ * Check one plugin's contract against the pipeline's scope. Returns every
+ * issue (missing keys first, then ill-typed ones, metadata before vars);
+ * empty when the contract is met. Declared types are checked for every
+ * SUPPLIED key, required or not (an optional key with a `| default:` is still
+ * coerced when it is supplied).
+ */
+export declare function checkPluginContract(contract: PluginContract, scope: ContractScope): ContractIssue[];
+/**
+ * Synth-time guard: throw when `plugin` (resolved for `step`) has unmet
+ * contract keys. The API refuses such a pipeline at create/update; this
+ * catches one that reached synth another way.
+ */
+export declare function assertPluginContract(plugin: PluginContract & {
+    readonly name: string;
+    readonly version?: string;
+}, scope: ContractScope, step: string): void;
+/** A plugin reference in pipeline props, with where it sits. */
+export interface PluginStepRef {
+    /** JSON path of the step: `synth` or `stages[i].steps[j]`. */
+    readonly path: string;
+    /** Human label: `synth` or `<stageName>/<alias ?? name>`. */
+    readonly label: string;
+    readonly name: string;
+    /** Publisher handle of an installed listing. */
+    readonly publisher?: string;
+    readonly alias?: string;
+    readonly filter?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Every plugin reference in a pipeline's props: `synth.plugin`, then each
+ * `stages[].steps[].plugin` in order. One entry per STEP (not de-duplicated) —
+ * the contract result is reported per step.
+ */
+export declare function collectPluginSteps(props: unknown): PluginStepRef[];
+/**
+ * The lookup filter synth sends for a reference (pipeline-manager
+ * `resolvePluginsForProps`, the deploy-time custom resource, the pipeline
+ * service's contract check): the ref's name — and its `publisher`, which
+ * routes the lookup to that publisher's installed listing — overlaid by
+ * an explicit `filter` (whose `name` wins), else the default active+default
+ * version.
+ */
+export declare function pluginLookupFilter(ref: Pick<PluginStepRef, 'name' | 'filter' | 'publisher'>): Record<string, unknown>;
+/**
+ * The plugin-alias SEGMENT of an artifact key — and the resolver's cache key:
+ * the explicit alias, or `${name}-alias` when there is none
+ * (`${publisher}-${name}-alias` for a qualified reference). THE rule — the frontend's artifact picker
+ * (`frontend/src/lib/artifact-keys.ts`), the CLI's pre-resolver and
+ * `PluginLookup.normalize` all build keys this way.
+ *
+ * The places that REGISTER keys must use it too: a stage step registering the
+ * bare name (`nodejs-build`) or a synth step suffixing an explicit alias
+ * (`my-synth-alias`) would fail any UI-picked input artifact with "No artifact
+ * registered", because the key it asks for is never the key that was stored.
+ */
+export declare function pluginArtifactAlias(plugin: PluginRefIdentity): string;
+/** The fields of a plugin REFERENCE that identify it. */
+export interface PluginRefIdentity {
+    readonly name: string;
+    readonly alias?: string;
+    /** Publisher handle of an installed listing; absent for an unqualified reference. */
+    readonly publisher?: string;
+}
+/**
+ * A publisher handle as it may appear in a construct id or a key: only
+ * `[A-Za-z0-9_-]` (handles already are; this is the guarantee).
+ */
+export declare function sanitizePublisher(publisher: string): string;
+/**
+ * The construct-id segment of a plugin step: the explicit alias, else
+ * `<publisher>-<name>` for a qualified reference, else the bare name — so a
+ * step using `acme`'s `lint` and one using the org's own `lint` never collide,
+ * while an unqualified step keeps the id it always had (renaming it would make
+ * CloudFormation replace its CodeBuild project).
+ */
+export declare function pluginStepIdAlias(plugin: PluginRefIdentity): string;

package/lib/core/plugin-contract.js

@@ -0,0 +1,217 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Plugin contract enforcement. A plugin spec declares
+ * the `{{ pipeline.metadata.X }}` / `{{ pipeline.vars.X }}` keys a pipeline
+ * must supply (`requiredMetadata` / `requiredVars`) and the coercion type of
+ * each (`metadataTypes` / `varsTypes`). The upload validates the spec against
+ * its own templates; this module checks a PIPELINE against the contracts of
+ * the plugins it references.
+ *
+ * CDK-free: shared by the pipeline service (create / update → 400 listing
+ * every problem per step) and the synth (fail fast for a pipeline that never
+ * went through the API, e.g. a CLI-authored props file).
+ *
+ * The checks mirror the template evaluator (`template/evaluator.ts`) exactly,
+ * so "passes here" means "resolves at synth":
+ *   - a key is MISSING when absent, null or the empty string (the evaluator
+ *     falls to `| default:` or fails for all three);
+ *   - an object/array value never interpolates;
+ *   - `number` / `bool` / `json` accept what the `| number` / `| bool` /
+ *     `| json` filters accept after stringification.
+ */
+import { merge } from './metadata-helpers.js';
+function asRecord(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+/**
+ * `pipeline.metadata` as synth builds it: `global` ← `defaults.metadata` ←
+ * `synth.metadata` (last wins). The single definition — `PipelineConfiguration`
+ * uses it too, so the API check and the synth scope cannot drift.
+ */
+export function pipelineScopeMetadata(props) {
+    return merge(asRecord(props.global), asRecord(asRecord(props.defaults).metadata), asRecord(asRecord(props.synth).metadata));
+}
+/** The contract scope of a pipeline's props (see {@link pipelineScopeMetadata}). */
+export function pipelineContractScope(props) {
+    return { metadata: pipelineScopeMetadata(props), vars: asRecord(props.vars) };
+}
+/**
+ * The contract scope inside a synth template scope (`{ pipeline: { metadata,
+ * vars, … } }`, see `PipelineConfiguration.getPipelineScope`).
+ */
+export function contractScopeFromTemplateScope(templateScope) {
+    const pipeline = asRecord(templateScope.pipeline);
+    return { metadata: asRecord(pipeline.metadata), vars: asRecord(pipeline.vars) };
+}
+/** Would the evaluator treat `value` as absent (missing / null / empty string)? */
+function isMissing(value) {
+    return value === undefined || value === null || value === '';
+}
+/**
+ * Does `value` satisfy the declared `type` once interpolated? Mirrors the
+ * evaluator's `resolveOne` (objects never interpolate) and `applyCoercion`.
+ */
+export function isContractValueOfType(value, type) {
+    if (typeof value === 'object' && value !== null)
+        return false;
+    const raw = String(value);
+    switch (type) {
+        case 'string':
+            return true;
+        case 'number':
+            return Number.isFinite(Number(raw));
+        case 'bool':
+            return ['true', '1', 'yes', 'false', '0', 'no', ''].includes(raw.trim().toLowerCase());
+        case 'json':
+            try {
+                JSON.parse(raw);
+                return true;
+            }
+            catch {
+                return false;
+            }
+    }
+}
+/** A value still carrying `{{ … }}` is resolved later (pipeline pass 1), so its type can't be judged yet. */
+function isUnresolvedTemplate(value) {
+    return typeof value === 'string' && value.includes('{{');
+}
+function checkKind(kind, required, types, supplied) {
+    const issues = [];
+    const where = kind === 'metadata' ? 'metadata (global / defaults.metadata / synth.metadata)' : 'vars';
+    for (const key of new Set(required ?? [])) {
+        if (isMissing(supplied[key])) {
+            issues.push({ kind, key, problem: 'missing', message: `pipeline ${where} must supply '${key}'` });
+        }
+    }
+    for (const [key, expected] of Object.entries(types ?? {})) {
+        const value = supplied[key];
+        if (isMissing(value) || isUnresolvedTemplate(value))
+            continue;
+        if (!isContractValueOfType(value, expected)) {
+            const got = typeof value === 'object' ? (Array.isArray(value) ? 'an array' : 'an object') : JSON.stringify(value);
+            issues.push({ kind, key, problem: 'type', expected, message: `pipeline ${kind}.${key} must be a ${expected}, got ${got}` });
+        }
+    }
+    return issues;
+}
+/**
+ * Check one plugin's contract against the pipeline's scope. Returns every
+ * issue (missing keys first, then ill-typed ones, metadata before vars);
+ * empty when the contract is met. Declared types are checked for every
+ * SUPPLIED key, required or not (an optional key with a `| default:` is still
+ * coerced when it is supplied).
+ */
+export function checkPluginContract(contract, scope) {
+    return [
+        ...checkKind('metadata', contract.requiredMetadata, contract.metadataTypes, scope.metadata),
+        ...checkKind('vars', contract.requiredVars, contract.varsTypes, scope.vars),
+    ];
+}
+/**
+ * Synth-time guard: throw when `plugin` (resolved for `step`) has unmet
+ * contract keys. The API refuses such a pipeline at create/update; this
+ * catches one that reached synth another way.
+ */
+export function assertPluginContract(plugin, scope, step) {
+    const issues = checkPluginContract(plugin, scope);
+    if (issues.length === 0)
+        return;
+    throw new Error(`Step "${step}" uses plugin "${plugin.name}${plugin.version ? `@${plugin.version}` : ''}" whose contract is not met:\n`
+        + issues.map((i) => `  • ${i.message}`).join('\n'));
+}
+function toRef(raw, path, label) {
+    const r = asRecord(raw);
+    if (typeof r.name !== 'string' || r.name.length === 0)
+        return null;
+    const alias = typeof r.alias === 'string' ? r.alias : undefined;
+    const publisher = typeof r.publisher === 'string' && r.publisher.length > 0 ? r.publisher : undefined;
+    const filter = r.filter && typeof r.filter === 'object' ? r.filter : undefined;
+    return {
+        path,
+        label: label(r.name, alias, publisher),
+        name: r.name,
+        ...(publisher ? { publisher } : {}),
+        ...(alias ? { alias } : {}),
+        ...(filter ? { filter } : {}),
+    };
+}
+/**
+ * Every plugin reference in a pipeline's props: `synth.plugin`, then each
+ * `stages[].steps[].plugin` in order. One entry per STEP (not de-duplicated) —
+ * the contract result is reported per step.
+ */
+export function collectPluginSteps(props) {
+    const p = asRecord(props);
+    const out = [];
+    const synth = toRef(asRecord(p.synth).plugin, 'synth', () => 'synth');
+    if (synth)
+        out.push(synth);
+    const stages = Array.isArray(p.stages) ? p.stages : [];
+    stages.forEach((stage, i) => {
+        const s = asRecord(stage);
+        const stageName = typeof s.stageName === 'string' ? s.stageName : `stage ${i + 1}`;
+        const steps = Array.isArray(s.steps) ? s.steps : [];
+        steps.forEach((step, j) => {
+            const ref = toRef(asRecord(step).plugin, `stages[${i}].steps[${j}]`, (name, alias, publisher) => `${stageName}/${alias ?? (publisher ? `${publisher}/${name}` : name)}`);
+            if (ref)
+                out.push(ref);
+        });
+    });
+    return out;
+}
+/**
+ * The lookup filter synth sends for a reference (pipeline-manager
+ * `resolvePluginsForProps`, the deploy-time custom resource, the pipeline
+ * service's contract check): the ref's name — and its `publisher`, which
+ * routes the lookup to that publisher's installed listing — overlaid by
+ * an explicit `filter` (whose `name` wins), else the default active+default
+ * version.
+ */
+export function pluginLookupFilter(ref) {
+    return {
+        name: ref.name,
+        ...(ref.publisher ? { publisher: ref.publisher } : {}),
+        ...(ref.filter ?? { isActive: true, isDefault: true }),
+    };
+}
+// -----------------------------------------------------------------------------
+// Reference identity (CDK-free: the CLI, the pipeline service and synth share it)
+// -----------------------------------------------------------------------------
+/**
+ * The plugin-alias SEGMENT of an artifact key — and the resolver's cache key:
+ * the explicit alias, or `${name}-alias` when there is none
+ * (`${publisher}-${name}-alias` for a qualified reference). THE rule — the frontend's artifact picker
+ * (`frontend/src/lib/artifact-keys.ts`), the CLI's pre-resolver and
+ * `PluginLookup.normalize` all build keys this way.
+ *
+ * The places that REGISTER keys must use it too: a stage step registering the
+ * bare name (`nodejs-build`) or a synth step suffixing an explicit alias
+ * (`my-synth-alias`) would fail any UI-picked input artifact with "No artifact
+ * registered", because the key it asks for is never the key that was stored.
+ */
+export function pluginArtifactAlias(plugin) {
+    if (plugin.alias)
+        return plugin.alias;
+    return plugin.publisher ? `${sanitizePublisher(plugin.publisher)}-${plugin.name}-alias` : `${plugin.name}-alias`;
+}
+/**
+ * A publisher handle as it may appear in a construct id or a key: only
+ * `[A-Za-z0-9_-]` (handles already are; this is the guarantee).
+ */
+export function sanitizePublisher(publisher) {
+    return publisher.replace(/[^A-Za-z0-9_-]/g, '-');
+}
+/**
+ * The construct-id segment of a plugin step: the explicit alias, else
+ * `<publisher>-<name>` for a qualified reference, else the bare name — so a
+ * step using `acme`'s `lint` and one using the org's own `lint` never collide,
+ * while an unqualified step keeps the id it always had (renaming it would make
+ * CloudFormation replace its CodeBuild project).
+ */
+export function pluginStepIdAlias(plugin) {
+    // `??`, not `||`: an explicit (even empty) alias keeps the id it always had.
+    return plugin.alias ?? (plugin.publisher ? `${sanitizePublisher(plugin.publisher)}-${plugin.name}` : plugin.name);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-contract.js","sourceRoot":"","sources":["../../src/core/plugin-contract.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAsC9C,SAAS,QAAQ,CAAC,CAAU;IAC1B,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAA4B,CAAC,CAAC,CAAC,EAAE,CAAC;AAC7F,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAyB;IAC7D,OAAO,KAAK,CACV,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAiB,EACtC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAiB,EAC3D,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAiB,CACzD,CAAC;AACJ,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,qBAAqB,CAAC,KAAyB;IAC7D,OAAO,EAAE,QAAQ,EAAE,qBAAqB,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;AAChF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,8BAA8B,CAAC,aAAgD;IAC7F,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAClD,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;AAClF,CAAC;AAED,mFAAmF;AACnF,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAc,EAAE,IAAuB;IAC3E,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,IAAI,CAAC;QACd,KAAK,QAAQ;YACX,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;QACtC,KAAK,MAAM;YACT,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;QACzF,KAAK,MAAM;YACT,IAAI,CAAC;gBACH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAChB,OAAO,IAAI,CAAC;YACd,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,KAAK,CAAC;YACf,CAAC;IACL,CAAC;AACH,CAAC;AAED,6GAA6G;AAC7G,SAAS,oBAAoB,CAAC,KAAc;IAC1C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAC3D,CAAC;AAED,SAAS,SAAS,CAChB,IAAyB,EACzB,QAA8C,EAC9C,KAAqE,EACrE,QAA2C;IAE3C,MAAM,MAAM,GAAoB,EAAE,CAAC;IACnC,MAAM,KAAK,GAAG,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,wDAAwD,CAAC,CAAC,CAAC,MAAM,CAAC;IACtG,KAAK,MAAM,GAAG,IAAI,IAAI,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,EAAE,CAAC;QAC1C,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAC7B,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,KAAK,iBAAiB,GAAG,GAAG,EAAE,CAAC,CAAC;QACpG,CAAC;IACH,CAAC;IACD,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,CAAC;QAC1D,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC5B,IAAI,SAAS,CAAC,KAAK,CAAC,IAAI,oBAAoB,CAAC,KAAK,CAAC;YAAE,SAAS;QAC9D,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC;YAC5C,MAAM,GAAG,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YAClH,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,IAAI,IAAI,GAAG,cAAc,QAAQ,SAAS,GAAG,EAAE,EAAE,CAAC,CAAC;QAC9H,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAwB,EAAE,KAAoB;IAChF,OAAO;QACL,GAAG,SAAS,CAAC,UAAU,EAAE,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,CAAC,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC;QAC3F,GAAG,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC;KAC5E,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAA6E,EAC7E,KAAoB,EACpB,IAAY;IAEZ,MAAM,MAAM,GAAG,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAClD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAChC,MAAM,IAAI,KAAK,CACb,SAAS,IAAI,kBAAkB,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,gCAAgC;UACrH,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CACnD,CAAC;AACJ,CAAC;AAeD,SAAS,KAAK,CAAC,GAAY,EAAE,IAAY,EAAE,KAAmE;IAC5G,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACnE,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAChE,MAAM,SAAS,GAAG,OAAO,CAAC,CAAC,SAAS,KAAK,QAAQ,IAAI,CAAC,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtG,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,MAAiC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1G,OAAO;QACL,IAAI;QACJ,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC;QACtC,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACnC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3B,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC9B,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC1B,MAAM,GAAG,GAAoB,EAAE,CAAC;IAChC,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,CAAC;IACtE,IAAI,KAAK;QAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3B,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IACvD,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;QAC1B,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC1B,MAAM,SAAS,GAAG,OAAO,CAAC,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC;QACnF,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QACpD,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;YACxB,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,EACjE,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,GAAG,SAAS,IAAI,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACtG,IAAI,GAAG;gBAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAyD;IAC1F,OAAO;QACL,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACtD,GAAG,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;KACvD,CAAC;AACJ,CAAC;AAED,gFAAgF;AAChF,kFAAkF;AAClF,gFAAgF;AAEhF;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAyB;IAC3D,IAAI,MAAM,CAAC,KAAK;QAAE,OAAO,MAAM,CAAC,KAAK,CAAC;IACtC,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,QAAQ,CAAC;AACnH,CAAC;AAUD;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAAiB;IACjD,OAAO,SAAS,CAAC,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAyB;IACzD,6EAA6E;IAC7E,OAAO,MAAM,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACpH,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Plugin contract enforcement. A plugin spec declares\n * the `{{ pipeline.metadata.X }}` / `{{ pipeline.vars.X }}` keys a pipeline\n * must supply (`requiredMetadata` / `requiredVars`) and the coercion type of\n * each (`metadataTypes` / `varsTypes`). The upload validates the spec against\n * its own templates; this module checks a PIPELINE against the contracts of\n * the plugins it references.\n *\n * CDK-free: shared by the pipeline service (create / update → 400 listing\n * every problem per step) and the synth (fail fast for a pipeline that never\n * went through the API, e.g. a CLI-authored props file).\n *\n * The checks mirror the template evaluator (`template/evaluator.ts`) exactly,\n * so \"passes here\" means \"resolves at synth\":\n *   - a key is MISSING when absent, null or the empty string (the evaluator\n *     falls to `| default:` or fails for all three);\n *   - an object/array value never interpolates;\n *   - `number` / `bool` / `json` accept what the `| number` / `| bool` /\n *     `| json` filters accept after stringification.\n */\n\nimport { merge } from './metadata-helpers.js';\nimport type { MetaDataType } from './pipeline-types.js';\n\n/** Declared coercion type of a contract key. */\nexport type ContractValueType = 'string' | 'number' | 'bool' | 'json';\n\n/** The contract fields of a plugin record (as `plugins` stores them). */\nexport interface PluginContract {\n  readonly requiredMetadata?: readonly string[] | null;\n  readonly requiredVars?: readonly string[] | null;\n  readonly metadataTypes?: Readonly<Record<string, ContractValueType>> | null;\n  readonly varsTypes?: Readonly<Record<string, ContractValueType>> | null;\n}\n\n/** What `{{ pipeline.metadata.* }}` and `{{ pipeline.vars.* }}` resolve against. */\nexport interface ContractScope {\n  readonly metadata: Readonly<Record<string, unknown>>;\n  readonly vars: Readonly<Record<string, unknown>>;\n}\n\n/** One unmet contract key. */\nexport interface ContractIssue {\n  readonly kind: 'metadata' | 'vars';\n  readonly key: string;\n  readonly problem: 'missing' | 'type';\n  /** The declared type, for a `type` problem. */\n  readonly expected?: ContractValueType;\n  readonly message: string;\n}\n\n/** The pipeline-props fields the contract scope is built from (BuilderProps subset). */\nexport interface ContractScopeProps {\n  readonly global?: unknown;\n  readonly defaults?: unknown;\n  readonly synth?: unknown;\n  readonly vars?: unknown;\n}\n\nfunction asRecord(v: unknown): Record<string, unknown> {\n  return v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, unknown> : {};\n}\n\n/**\n * `pipeline.metadata` as synth builds it: `global` ← `defaults.metadata` ←\n * `synth.metadata` (last wins). The single definition — `PipelineConfiguration`\n * uses it too, so the API check and the synth scope cannot drift.\n */\nexport function pipelineScopeMetadata(props: ContractScopeProps): MetaDataType {\n  return merge(\n    asRecord(props.global) as MetaDataType,\n    asRecord(asRecord(props.defaults).metadata) as MetaDataType,\n    asRecord(asRecord(props.synth).metadata) as MetaDataType,\n  );\n}\n\n/** The contract scope of a pipeline's props (see {@link pipelineScopeMetadata}). */\nexport function pipelineContractScope(props: ContractScopeProps): ContractScope {\n  return { metadata: pipelineScopeMetadata(props), vars: asRecord(props.vars) };\n}\n\n/**\n * The contract scope inside a synth template scope (`{ pipeline: { metadata,\n * vars, … } }`, see `PipelineConfiguration.getPipelineScope`).\n */\nexport function contractScopeFromTemplateScope(templateScope: Readonly<Record<string, unknown>>): ContractScope {\n  const pipeline = asRecord(templateScope.pipeline);\n  return { metadata: asRecord(pipeline.metadata), vars: asRecord(pipeline.vars) };\n}\n\n/** Would the evaluator treat `value` as absent (missing / null / empty string)? */\nfunction isMissing(value: unknown): boolean {\n  return value === undefined || value === null || value === '';\n}\n\n/**\n * Does `value` satisfy the declared `type` once interpolated? Mirrors the\n * evaluator's `resolveOne` (objects never interpolate) and `applyCoercion`.\n */\nexport function isContractValueOfType(value: unknown, type: ContractValueType): boolean {\n  if (typeof value === 'object' && value !== null) return false;\n  const raw = String(value);\n  switch (type) {\n    case 'string':\n      return true;\n    case 'number':\n      return Number.isFinite(Number(raw));\n    case 'bool':\n      return ['true', '1', 'yes', 'false', '0', 'no', ''].includes(raw.trim().toLowerCase());\n    case 'json':\n      try {\n        JSON.parse(raw);\n        return true;\n      } catch {\n        return false;\n      }\n  }\n}\n\n/** A value still carrying `{{ … }}` is resolved later (pipeline pass 1), so its type can't be judged yet. */\nfunction isUnresolvedTemplate(value: unknown): boolean {\n  return typeof value === 'string' && value.includes('{{');\n}\n\nfunction checkKind(\n  kind: 'metadata' | 'vars',\n  required: readonly string[] | null | undefined,\n  types: Readonly<Record<string, ContractValueType>> | null | undefined,\n  supplied: Readonly<Record<string, unknown>>,\n): ContractIssue[] {\n  const issues: ContractIssue[] = [];\n  const where = kind === 'metadata' ? 'metadata (global / defaults.metadata / synth.metadata)' : 'vars';\n  for (const key of new Set(required ?? [])) {\n    if (isMissing(supplied[key])) {\n      issues.push({ kind, key, problem: 'missing', message: `pipeline ${where} must supply '${key}'` });\n    }\n  }\n  for (const [key, expected] of Object.entries(types ?? {})) {\n    const value = supplied[key];\n    if (isMissing(value) || isUnresolvedTemplate(value)) continue;\n    if (!isContractValueOfType(value, expected)) {\n      const got = typeof value === 'object' ? (Array.isArray(value) ? 'an array' : 'an object') : JSON.stringify(value);\n      issues.push({ kind, key, problem: 'type', expected, message: `pipeline ${kind}.${key} must be a ${expected}, got ${got}` });\n    }\n  }\n  return issues;\n}\n\n/**\n * Check one plugin's contract against the pipeline's scope. Returns every\n * issue (missing keys first, then ill-typed ones, metadata before vars);\n * empty when the contract is met. Declared types are checked for every\n * SUPPLIED key, required or not (an optional key with a `| default:` is still\n * coerced when it is supplied).\n */\nexport function checkPluginContract(contract: PluginContract, scope: ContractScope): ContractIssue[] {\n  return [\n    ...checkKind('metadata', contract.requiredMetadata, contract.metadataTypes, scope.metadata),\n    ...checkKind('vars', contract.requiredVars, contract.varsTypes, scope.vars),\n  ];\n}\n\n/**\n * Synth-time guard: throw when `plugin` (resolved for `step`) has unmet\n * contract keys. The API refuses such a pipeline at create/update; this\n * catches one that reached synth another way.\n */\nexport function assertPluginContract(\n  plugin: PluginContract & { readonly name: string; readonly version?: string },\n  scope: ContractScope,\n  step: string,\n): void {\n  const issues = checkPluginContract(plugin, scope);\n  if (issues.length === 0) return;\n  throw new Error(\n    `Step \"${step}\" uses plugin \"${plugin.name}${plugin.version ? `@${plugin.version}` : ''}\" whose contract is not met:\\n`\n    + issues.map((i) => `  • ${i.message}`).join('\\n'),\n  );\n}\n\n/** A plugin reference in pipeline props, with where it sits. */\nexport interface PluginStepRef {\n  /** JSON path of the step: `synth` or `stages[i].steps[j]`. */\n  readonly path: string;\n  /** Human label: `synth` or `<stageName>/<alias ?? name>`. */\n  readonly label: string;\n  readonly name: string;\n  /** Publisher handle of an installed listing. */\n  readonly publisher?: string;\n  readonly alias?: string;\n  readonly filter?: Readonly<Record<string, unknown>>;\n}\n\nfunction toRef(raw: unknown, path: string, label: (name: string, alias?: string, publisher?: string) => string): PluginStepRef | null {\n  const r = asRecord(raw);\n  if (typeof r.name !== 'string' || r.name.length === 0) return null;\n  const alias = typeof r.alias === 'string' ? r.alias : undefined;\n  const publisher = typeof r.publisher === 'string' && r.publisher.length > 0 ? r.publisher : undefined;\n  const filter = r.filter && typeof r.filter === 'object' ? r.filter as Record<string, unknown> : undefined;\n  return {\n    path,\n    label: label(r.name, alias, publisher),\n    name: r.name,\n    ...(publisher ? { publisher } : {}),\n    ...(alias ? { alias } : {}),\n    ...(filter ? { filter } : {}),\n  };\n}\n\n/**\n * Every plugin reference in a pipeline's props: `synth.plugin`, then each\n * `stages[].steps[].plugin` in order. One entry per STEP (not de-duplicated) —\n * the contract result is reported per step.\n */\nexport function collectPluginSteps(props: unknown): PluginStepRef[] {\n  const p = asRecord(props);\n  const out: PluginStepRef[] = [];\n  const synth = toRef(asRecord(p.synth).plugin, 'synth', () => 'synth');\n  if (synth) out.push(synth);\n  const stages = Array.isArray(p.stages) ? p.stages : [];\n  stages.forEach((stage, i) => {\n    const s = asRecord(stage);\n    const stageName = typeof s.stageName === 'string' ? s.stageName : `stage ${i + 1}`;\n    const steps = Array.isArray(s.steps) ? s.steps : [];\n    steps.forEach((step, j) => {\n      const ref = toRef(asRecord(step).plugin, `stages[${i}].steps[${j}]`,\n        (name, alias, publisher) => `${stageName}/${alias ?? (publisher ? `${publisher}/${name}` : name)}`);\n      if (ref) out.push(ref);\n    });\n  });\n  return out;\n}\n\n/**\n * The lookup filter synth sends for a reference (pipeline-manager\n * `resolvePluginsForProps`, the deploy-time custom resource, the pipeline\n * service's contract check): the ref's name — and its `publisher`, which\n * routes the lookup to that publisher's installed listing — overlaid by\n * an explicit `filter` (whose `name` wins), else the default active+default\n * version.\n */\nexport function pluginLookupFilter(ref: Pick<PluginStepRef, 'name' | 'filter' | 'publisher'>): Record<string, unknown> {\n  return {\n    name: ref.name,\n    ...(ref.publisher ? { publisher: ref.publisher } : {}),\n    ...(ref.filter ?? { isActive: true, isDefault: true }),\n  };\n}\n\n// -----------------------------------------------------------------------------\n// Reference identity (CDK-free: the CLI, the pipeline service and synth share it)\n// -----------------------------------------------------------------------------\n\n/**\n * The plugin-alias SEGMENT of an artifact key — and the resolver's cache key:\n * the explicit alias, or `${name}-alias` when there is none\n * (`${publisher}-${name}-alias` for a qualified reference). THE rule — the frontend's artifact picker\n * (`frontend/src/lib/artifact-keys.ts`), the CLI's pre-resolver and\n * `PluginLookup.normalize` all build keys this way.\n *\n * The places that REGISTER keys must use it too: a stage step registering the\n * bare name (`nodejs-build`) or a synth step suffixing an explicit alias\n * (`my-synth-alias`) would fail any UI-picked input artifact with \"No artifact\n * registered\", because the key it asks for is never the key that was stored.\n */\nexport function pluginArtifactAlias(plugin: PluginRefIdentity): string {\n  if (plugin.alias) return plugin.alias;\n  return plugin.publisher ? `${sanitizePublisher(plugin.publisher)}-${plugin.name}-alias` : `${plugin.name}-alias`;\n}\n\n/** The fields of a plugin REFERENCE that identify it. */\nexport interface PluginRefIdentity {\n  readonly name: string;\n  readonly alias?: string;\n  /** Publisher handle of an installed listing; absent for an unqualified reference. */\n  readonly publisher?: string;\n}\n\n/**\n * A publisher handle as it may appear in a construct id or a key: only\n * `[A-Za-z0-9_-]` (handles already are; this is the guarantee).\n */\nexport function sanitizePublisher(publisher: string): string {\n  return publisher.replace(/[^A-Za-z0-9_-]/g, '-');\n}\n\n/**\n * The construct-id segment of a plugin step: the explicit alias, else\n * `<publisher>-<name>` for a qualified reference, else the bare name — so a\n * step using `acme`'s `lint` and one using the org's own `lint` never collide,\n * while an unqualified step keeps the id it always had (renaming it would make\n * CloudFormation replace its CodeBuild project).\n */\nexport function pluginStepIdAlias(plugin: PluginRefIdentity): string {\n  // `??`, not `||`: an explicit (even empty) alias keeps the id it always had.\n  return plugin.alias ?? (plugin.publisher ? `${sanitizePublisher(plugin.publisher)}-${plugin.name}` : plugin.name);\n}\n"]}

package/lib/core/plugin-lookup-envelope.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from '@pipeline-builder/pipeline-data';
+/**
+ * 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
+ * lifecycle warning messages (deprecated / yanked-but-pinned) that ride beside it.
+ *
+ * Dependency-free (type-only imports) so the plugin-lookup Lambda can bundle it.
+ */
+export declare function unwrapLookup(body: unknown): {
+    plugin: Plugin | null;
+    warnings: string[];
+};

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

@@ -0,0 +1,29 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * 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
+ * lifecycle warning messages (deprecated / yanked-but-pinned) that ride beside it.
+ *
+ * Dependency-free (type-only imports) so the plugin-lookup Lambda can bundle it.
+ */
+export function unwrapLookup(body) {
+    if (!body || typeof body !== 'object')
+        return { plugin: null, warnings: [] };
+    const inner = body.data;
+    const container = (inner && typeof inner === 'object' ? inner : body);
+    const candidate = container.plugin ?? container;
+    const plugin = candidate && typeof candidate === 'object' && typeof candidate.name === 'string'
+        && candidate.name.length > 0
+        ? candidate
+        : null;
+    const warnings = Array.isArray(container.warnings)
+        ? container.warnings
+            .map((w) => (w && typeof w === 'object' ? w.message : undefined))
+            .filter((m) => typeof m === 'string' && m.length > 0)
+        : [];
+    return { plugin, warnings };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,50 @@
+/**
+ * File the synth app writes the manifest to, inside the cloud assembly
+ * directory (`cdk deploy --output=<dir>`). The CLI reads it back after a
+ * successful deploy and forwards it on the registry POST.
+ */
+export declare const STEP_MANIFEST_FILE = "pb-step-manifest.json";
+/**
+ * `id` of every synthesized placeholder plugin (PluginLookup `fallback()` /
+ * `bootstrap()`) — a record standing in for a lookup that could not resolve at
+ * synth. Never a real `plugins` row, so the step manifest never records it.
+ */
+export declare const PLACEHOLDER_PLUGIN_ID = "00000000-0000-0000-0000-000000000000";
+/**
+ * One manifest entry as the synth records it. Carries the resolved plugin
+ * record's id so the pipeline service can re-resolve the authoritative
+ * name/version/digest/owner itself — the CLI's claim is never trusted for
+ * anything that feeds cross-org stats (publisher, verified use).
+ */
+export interface StepManifestEntry {
+    /** CodePipeline stage name, as the built pipeline names it. */
+    readonly stageName: string;
+    /** CodePipeline action name, as the built pipeline names it. */
+    readonly actionName: string;
+    /** `plugins.id` of the resolved plugin record. */
+    readonly pluginId: string;
+    readonly pluginName: string;
+    readonly pluginVersion: string;
+    /** Signed image digest the step is pinned to; null for image-less plugins. */
+    readonly imageDigest: string | null;
+}
+/** The plugin fields {@link pluginImageRepository} reads. */
+export interface PluginImageRef {
+    readonly orgId: string;
+    readonly name: string;
+    readonly buildType?: string | null;
+}
+/**
+ * Registry repository an org-owned plugin ROW's image lives at
+ * (`<namespace>/<name>`, no host, no digest): the system org's under
+ * `system/`, a tenant's under `org-<orgId>/`. Must match the push side
+ * (api/plugin `pluginUri`). Returns null for a `metadata_only` plugin.
+ *
+ * Only for rows the caller's org resolves as its OWN (or its parent's): the
+ * plugin lookup stamps it as the record's `imageRepository`. A listed plugin's
+ * repository is its listing version's `public/<publisher>/<name>` copy —
+ * synth never derives a repository itself.
+ */
+export declare function pluginImageRepository(plugin: PluginImageRef): string | null;
+/** A plugin image repository lookup may return: `public/<publisher>/<name>`, `org-<id>/<name>` or `system/<name>`. */
+export declare const PLUGIN_IMAGE_REPOSITORY_RE: RegExp;

package/lib/core/step-manifest.js

@@ -0,0 +1,47 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * 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 { SYSTEM_ORG_ID } from '@pipeline-builder/api-core';
+/**
+ * File the synth app writes the manifest to, inside the cloud assembly
+ * directory (`cdk deploy --output=<dir>`). The CLI reads it back after a
+ * successful deploy and forwards it on the registry POST.
+ */
+export const STEP_MANIFEST_FILE = 'pb-step-manifest.json';
+/**
+ * `id` of every synthesized placeholder plugin (PluginLookup `fallback()` /
+ * `bootstrap()`) — a record standing in for a lookup that could not resolve at
+ * synth. Never a real `plugins` row, so the step manifest never records it.
+ */
+export const PLACEHOLDER_PLUGIN_ID = '00000000-0000-0000-0000-000000000000';
+/**
+ * Registry repository an org-owned plugin ROW's image lives at
+ * (`<namespace>/<name>`, no host, no digest): the system org's under
+ * `system/`, a tenant's under `org-<orgId>/`. Must match the push side
+ * (api/plugin `pluginUri`). Returns null for a `metadata_only` plugin.
+ *
+ * Only for rows the caller's org resolves as its OWN (or its parent's): the
+ * plugin lookup stamps it as the record's `imageRepository`. A listed plugin's
+ * repository is its listing version's `public/<publisher>/<name>` copy —
+ * synth never derives a repository itself.
+ */
+export function pluginImageRepository(plugin) {
+    if (plugin.buildType === 'metadata_only')
+        return null;
+    const namespace = plugin.orgId === SYSTEM_ORG_ID ? 'system' : `org-${plugin.orgId}`;
+    return `${namespace}/${plugin.name}`;
+}
+/** 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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

package/lib/handlers/platform-credential.d.ts

@@ -0,0 +1,47 @@
+import { SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+/**
+ * The platform credential a deployed Lambda holds: an opaque service-account key
+ * (`pb_sa_…`), stored in the `password` field of the Secrets Manager secret that
+ * `pipeline-manager infra store-token` writes. `password` stays the canonical
+ * field because CodeBuild's `secretsManagerCredentials` reads the same one.
+ *
+ * Dependency-free apart from the Secrets Manager client so every Lambda bundle
+ * can import it without dragging in aws-cdk-lib.
+ */
+/** Access-key prefixes platform issues. A stored JWT is NOT one of these. */
+export declare const ACCESS_KEY_PREFIXES: readonly string[];
+/** True for an HTTP status that means "this credential was refused". */
+export declare function isCredentialRefusal(status: number | undefined): boolean;
+/**
+ * Refuse anything that is not an opaque access key, naming where it came from.
+ * A stored JWT would otherwise surface much later as an opaque 401 from the API,
+ * several layers away from the secret an operator has to fix.
+ */
+export declare function assertAccessKey(value: string, source: string): void;
+/** Read and parse a Secrets Manager secret holding a JSON credential record. */
+export declare function readCredentialSecret<T extends Record<string, unknown>>(secretName: string, client?: Pick<SecretsManagerClient, 'send'>): Promise<T>;
+/** Read the `pb_sa_…` key from a credential secret, refusing a missing or non-key value. */
+export declare function readAccessKeyFromSecret(secretName: string): Promise<string>;
+export interface PlatformCredential {
+    /** The cached key, read from the secret on first use (or after {@link invalidate}). */
+    getKey(): Promise<string>;
+    /**
+     * Forget the cached key after the API refused it (401/403). The token-renew
+     * Lambda rotates the secret and then revokes the predecessor, so a warm
+     * container that kept its cached key would present the retired one forever.
+     * The next {@link getKey} re-reads the secret and picks up the replacement.
+     */
+    invalidate(): void;
+    /** Forget everything, including an env-provided key (tests). */
+    reset(): void;
+}
+/**
+ * A per-container cached platform credential. `envKeyVar` names an optional env
+ * var holding the key directly; an env-provided key cannot change without a new
+ * container, so {@link PlatformCredential.invalidate} keeps it.
+ */
+export declare function createPlatformCredential(opts: {
+    /** The secret name, or a getter read at first use (env set after module load). */
+    secretName?: string | (() => string | undefined);
+    envKeyVar?: string;
+}): PlatformCredential;