@pipeline-builder/pipeline-core 4.1.15 → 4.1.17

package/lib/handlers/platform-credential.js

@@ -0,0 +1,87 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { GetSecretValueCommand, 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 const ACCESS_KEY_PREFIXES = ['pb_sa_', 'pb_pat_'];
+/** True for an HTTP status that means "this credential was refused". */
+export function isCredentialRefusal(status) {
+    return status === 401 || status === 403;
+}
+/**
+ * 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 function assertAccessKey(value, source) {
+    if (ACCESS_KEY_PREFIXES.some((p) => value.startsWith(p)))
+        return;
+    const looksLikeJwt = value.split('.').length === 3;
+    throw new Error(`${source} does not hold an opaque access key (expected a "pb_sa_…" value)`
+        + (looksLikeJwt
+            ? ' — it holds a JWT, not a service-account key. Re-run "pipeline-manager infra store-token" to issue one.'
+            : '.'));
+}
+/** Read and parse a Secrets Manager secret holding a JSON credential record. */
+export async function readCredentialSecret(secretName, client = new SecretsManagerClient({})) {
+    const response = await client.send(new GetSecretValueCommand({ SecretId: secretName }));
+    if (!response.SecretString)
+        throw new Error(`Secret "${secretName}" is empty`);
+    return JSON.parse(response.SecretString);
+}
+/** Read the `pb_sa_…` key from a credential secret, refusing a missing or non-key value. */
+export async function readAccessKeyFromSecret(secretName) {
+    const secret = await readCredentialSecret(secretName);
+    const key = typeof secret.password === 'string' ? secret.password : '';
+    if (!key) {
+        throw new Error(`Secret "${secretName}" missing password — run "pipeline-manager infra store-token" to provision a service-account key`);
+    }
+    assertAccessKey(key, `secret "${secretName}"`);
+    return key;
+}
+/**
+ * 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 function createPlatformCredential(opts) {
+    let cached = null;
+    let fromEnv = false;
+    return {
+        async getKey() {
+            if (cached)
+                return cached;
+            const direct = opts.envKeyVar ? process.env[opts.envKeyVar] : undefined;
+            if (direct) {
+                assertAccessKey(direct, opts.envKeyVar);
+                cached = direct;
+                fromEnv = true;
+                return cached;
+            }
+            const secretName = typeof opts.secretName === 'function' ? opts.secretName() : opts.secretName;
+            if (!secretName) {
+                throw new Error(`${opts.envKeyVar ? `${opts.envKeyVar} or ` : ''}PLATFORM_SECRET_NAME environment variable is required`);
+            }
+            cached = await readAccessKeyFromSecret(secretName);
+            fromEnv = false;
+            return cached;
+        },
+        invalidate() {
+            if (!fromEnv)
+                cached = null;
+        },
+        reset() {
+            cached = null;
+            fromEnv = false;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-credential.js","sourceRoot":"","sources":["../../src/handlers/platform-credential.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';\n\n/**\n * The platform credential a deployed Lambda holds: an opaque service-account key\n * (`pb_sa_…`), stored in the `password` field of the Secrets Manager secret that\n * `pipeline-manager infra store-token` writes. `password` stays the canonical\n * field because CodeBuild's `secretsManagerCredentials` reads the same one.\n *\n * Dependency-free apart from the Secrets Manager client so every Lambda bundle\n * can import it without dragging in aws-cdk-lib.\n */\n\n/** Access-key prefixes platform issues. A stored JWT is NOT one of these. */\nexport const ACCESS_KEY_PREFIXES: readonly string[] = ['pb_sa_', 'pb_pat_'];\n\n/** True for an HTTP status that means \"this credential was refused\". */\nexport function isCredentialRefusal(status: number | undefined): boolean {\n  return status === 401 || status === 403;\n}\n\n/**\n * Refuse anything that is not an opaque access key, naming where it came from.\n * A stored JWT would otherwise surface much later as an opaque 401 from the API,\n * several layers away from the secret an operator has to fix.\n */\nexport function assertAccessKey(value: string, source: string): void {\n  if (ACCESS_KEY_PREFIXES.some((p) => value.startsWith(p))) return;\n  const looksLikeJwt = value.split('.').length === 3;\n  throw new Error(\n    `${source} does not hold an opaque access key (expected a \"pb_sa_…\" value)`\n    + (looksLikeJwt\n      ? ' — it holds a JWT, not a service-account key. Re-run \"pipeline-manager infra store-token\" to issue one.'\n      : '.'),\n  );\n}\n\n/** Read and parse a Secrets Manager secret holding a JSON credential record. */\nexport async function readCredentialSecret<T extends Record<string, unknown>>(\n  secretName: string,\n  client: Pick<SecretsManagerClient, 'send'> = new SecretsManagerClient({}),\n): Promise<T> {\n  const response = await client.send(new GetSecretValueCommand({ SecretId: secretName }));\n  if (!response.SecretString) throw new Error(`Secret \"${secretName}\" is empty`);\n  return JSON.parse(response.SecretString) as T;\n}\n\n/** Read the `pb_sa_…` key from a credential secret, refusing a missing or non-key value. */\nexport async function readAccessKeyFromSecret(secretName: string): Promise<string> {\n  const secret = await readCredentialSecret<{ password?: unknown }>(secretName);\n  const key = typeof secret.password === 'string' ? secret.password : '';\n  if (!key) {\n    throw new Error(`Secret \"${secretName}\" missing password — run \"pipeline-manager infra store-token\" to provision a service-account key`);\n  }\n  assertAccessKey(key, `secret \"${secretName}\"`);\n  return key;\n}\n\nexport interface PlatformCredential {\n  /** The cached key, read from the secret on first use (or after {@link invalidate}). */\n  getKey(): Promise<string>;\n  /**\n   * Forget the cached key after the API refused it (401/403). The token-renew\n   * Lambda rotates the secret and then revokes the predecessor, so a warm\n   * container that kept its cached key would present the retired one forever.\n   * The next {@link getKey} re-reads the secret and picks up the replacement.\n   */\n  invalidate(): void;\n  /** Forget everything, including an env-provided key (tests). */\n  reset(): void;\n}\n\n/**\n * A per-container cached platform credential. `envKeyVar` names an optional env\n * var holding the key directly; an env-provided key cannot change without a new\n * container, so {@link PlatformCredential.invalidate} keeps it.\n */\nexport function createPlatformCredential(opts: {\n  /** The secret name, or a getter read at first use (env set after module load). */\n  secretName?: string | (() => string | undefined);\n  envKeyVar?: string;\n}): PlatformCredential {\n  let cached: string | null = null;\n  let fromEnv = false;\n  return {\n    async getKey(): Promise<string> {\n      if (cached) return cached;\n      const direct = opts.envKeyVar ? process.env[opts.envKeyVar] : undefined;\n      if (direct) {\n        assertAccessKey(direct, opts.envKeyVar!);\n        cached = direct;\n        fromEnv = true;\n        return cached;\n      }\n      const secretName = typeof opts.secretName === 'function' ? opts.secretName() : opts.secretName;\n      if (!secretName) {\n        throw new Error(`${opts.envKeyVar ? `${opts.envKeyVar} or ` : ''}PLATFORM_SECRET_NAME environment variable is required`);\n      }\n      cached = await readAccessKeyFromSecret(secretName);\n      fromEnv = false;\n      return cached;\n    },\n    invalidate(): void {\n      if (!fromEnv) cached = null;\n    },\n    reset(): void {\n      cached = null;\n      fromEnv = false;\n    },\n  };\n}\n"]}

package/lib/handlers/plugin-lookup-handler.d.ts

@@ -2,7 +2,7 @@ import type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceRes
 /**
  * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.
  *
- * Authenticates using JWT token from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).
+ * Authenticates with the service-account key from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).
  * Create the secret with: `pipeline-manager infra store-token`
  *
  * Request Types:

package/lib/handlers/plugin-lookup-handler.js

@@ -1,11 +1,12 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
 import axios, { AxiosError } from 'axios';
 // Import the dependency-free leaf, NOT `app-config.js`/`CoreConstants`: the latter
 // transitively pulls infrastructure-config → aws-cdk-lib, which esbuild then tries
 // to bundle into this Lambda (hundreds of MB → OOM/SIGKILL during cold-start synth).
 import { HANDLER_TIMEOUT_MS, HANDLER_MAX_RETRIES, HANDLER_RETRY_DELAY_MS, HANDLER_DEFAULT_BASE_URL, } from '../config/handler-constants.js';
+import { unwrapLookup } from '../core/plugin-lookup-envelope.js';
+import { createPlatformCredential, isCredentialRefusal } from './platform-credential.js';
 /**
  * Structured logger for Lambda (outputs JSON to CloudWatch).
  * Debug messages only emitted when LOG_LEVEL=debug.
@@ -16,6 +17,9 @@ function logEntry(level, tag, message, data) {
         case 'ERROR':
             console.error(line);
             break;
+        case 'WARN':
+            console.warn(line);
+            break;
         case 'DEBUG':
             if (process.env.LOG_LEVEL === 'debug')
                 console.debug(line);
@@ -26,6 +30,7 @@ function logEntry(level, tag, message, data) {
 const lambdaLog = {
     info: (tag, message, data) => logEntry('INFO', tag, message, data),
     error: (tag, message, data) => logEntry('ERROR', tag, message, data),
+    warn: (tag, message, data) => logEntry('WARN', tag, message, data),
     debug: (tag, message, data) => logEntry('DEBUG', tag, message, data),
 };
 const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
@@ -38,53 +43,32 @@ const PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;
 if (!PLATFORM_SECRET_NAME) {
     throw new Error('PLATFORM_SECRET_NAME environment variable is required');
 }
-/** Cached token to avoid repeated Secrets Manager calls within a single invocation. */
-let cachedToken = null;
-/** @internal Reset cached token (for testing only). */
-export function _resetCredentialsCache() { cachedToken = null; }
 /**
- * Fetch JWT token from AWS Secrets Manager.
- * Caches the result for the lifetime of the Lambda execution context.
- *
- * The secret name is set via PLATFORM_SECRET_NAME env var (e.g. `{prefix}/{orgId}/platform`)
- * Create it with: `pipeline-manager infra store-token`
+ * The service-account key (`pb_sa_…`) from Secrets Manager, cached for the warm
+ * container. The plugin API trades it for a short-lived JWT itself, so the key
+ * goes out as the Bearer credential. Create the secret with
+ * `pipeline-manager infra store-token`.
  */
-async function getToken() {
-    if (cachedToken)
-        return cachedToken;
-    lambdaLog.info('AUTH', `Fetching token from Secrets Manager: ${PLATFORM_SECRET_NAME}`);
-    const client = new SecretsManagerClient({});
-    const response = await client.send(new GetSecretValueCommand({ SecretId: PLATFORM_SECRET_NAME }));
-    if (!response.SecretString) {
-        throw new Error(`Secret "${PLATFORM_SECRET_NAME}" is empty`);
-    }
-    const parsed = JSON.parse(response.SecretString);
-    // Schema is `{ username, password, ... }` — the `password` field is the
-    // platform JWT. Same secret is read by CodeBuild's `secretsManagerCredentials`
-    // for registry pulls (Basic auth: username:password = orgId:JWT). The
-    // pipeline-image-registry token endpoint validates the password as a JWT
-    // and issues a registry token scoped to the JWT's org.
-    if (!parsed.password) {
-        throw new Error(`Secret "${PLATFORM_SECRET_NAME}" missing password — run "pipeline-manager infra store-token" to generate`);
-    }
-    cachedToken = parsed.password;
-    lambdaLog.info('AUTH', 'Token retrieved from Secrets Manager');
-    return cachedToken;
+const credential = createPlatformCredential({ secretName: PLATFORM_SECRET_NAME });
+/** @internal Reset cached credential (for testing only). */
+export function _resetCredentialsCache() { credential.reset(); }
+/** The API refused the credential (401/403) — the caller may refresh it and retry once. */
+class CredentialRefusedError extends Error {
 }
 /**
  * Creates a pre-configured Axios instance for API requests.
  *
  * @param baseURL - Base URL of the target API
- * @param token - JWT token for authorization
+ * @param key - service-account key sent as the Bearer credential
  * @returns Configured Axios instance
  */
-function create(baseURL, token) {
+function create(baseURL, key) {
     return axios.create({
         baseURL,
         timeout: HANDLER_TIMEOUT_MS,
         headers: {
             'Content-Type': 'application/json',
-            'Authorization': `Bearer ${token}`,
+            'Authorization': `Bearer ${key}`,
         },
     });
 }
@@ -108,12 +92,17 @@ async function fetch(api, pluginFilter) {
             await sleep(delay);
         }
         try {
-            const { data, status } = await api.post('/api/plugins/lookup', {
+            const { data: body, status } = await api.post('/api/plugins/lookup', {
                 filter: pluginFilter,
             });
+            const { plugin: data, warnings } = unwrapLookup(body);
             if (!data) {
                 throw new Error('Empty response data from API');
             }
+            // Lifecycle warnings (deprecated / yanked-but-pinned) — surfaced in the
+            // deploy log; the lookup still succeeds.
+            for (const message of warnings)
+                lambdaLog.warn('LIFECYCLE', message, { plugin: data.name, version: data.version });
             lambdaLog.info('FETCH', 'Plugin fetched successfully', {
                 status,
                 plugin: data.name,
@@ -134,6 +123,10 @@ async function fetch(api, pluginFilter) {
                 const msg = error.response
                     ? `API error ${error.response.status}: ${error.response.statusText}`
                     : error.code || error.message;
+                if (isCredentialRefusal(error.response?.status)) {
+                    lambdaLog.warn('AUTH', `Credential refused: ${msg}`);
+                    throw new CredentialRefusedError(`Failed to fetch plugin: ${msg}`);
+                }
                 if (retryable && attempt < HANDLER_MAX_RETRIES) {
                     lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });
                     lastError = new Error(`Failed to fetch plugin: ${msg}`);
@@ -153,6 +146,23 @@ async function fetch(api, pluginFilter) {
     }
     throw lastError ?? new Error('Failed to fetch plugin after retries');
 }
+/**
+ * Look the plugin up with the cached credential. On a 401/403 the key was most
+ * likely rotated underneath this warm container (token-renew stores the new key
+ * and revokes the old one), so drop the cache, re-read the secret and retry once.
+ */
+async function lookupWithCredentialRefresh(baseURL, pluginFilter) {
+    try {
+        return await fetch(create(baseURL, await credential.getKey()), pluginFilter);
+    }
+    catch (err) {
+        if (!(err instanceof CredentialRefusedError))
+            throw err;
+        credential.invalidate();
+        lambdaLog.info('AUTH', 'Re-reading the service-account key from Secrets Manager and retrying once');
+        return fetch(create(baseURL, await credential.getKey()), pluginFilter);
+    }
+}
 /**
  * Validates the plugin filter object
  *
@@ -173,7 +183,7 @@ function validatePluginFilter(pluginFilter) {
 /**
  * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.
  *
- * Authenticates using JWT token from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).
+ * Authenticates with the service-account key from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).
  * Create the secret with: `pipeline-manager infra store-token`
  *
  * Request Types:
@@ -234,12 +244,8 @@ export const handler = async (event) => {
         }
         lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });
         validatePluginFilter(pluginFilter);
-        // Get token from Secrets Manager and create API client
-        const token = await getToken();
-        const api = create(baseURL, token);
-        // Fetch plugin
         lambdaLog.info('FETCH', 'Initiating plugin lookup...');
-        const plugin = await fetch(api, pluginFilter);
+        const plugin = await lookupWithCredentialRefresh(baseURL, pluginFilter);
         lambdaLog.info('FETCH', 'Plugin retrieved successfully', {
             name: plugin.name,
             version: plugin.version,
@@ -289,4 +295,4 @@ export const handler = async (event) => {
         lambdaLog.info('END', 'Custom resource execution completed');
     }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup-handler.js","sourceRoot":"","sources":["../../src/handlers/plugin-lookup-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';\nimport type { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse } from 'aws-lambda';\nimport axios, { type AxiosInstance, AxiosError } from 'axios';\n// Import the dependency-free leaf, NOT `app-config.js`/`CoreConstants`: the latter\n// transitively pulls infrastructure-config → aws-cdk-lib, which esbuild then tries\n// to bundle into this Lambda (hundreds of MB → OOM/SIGKILL during cold-start synth).\nimport {\n  HANDLER_TIMEOUT_MS,\n  HANDLER_MAX_RETRIES,\n  HANDLER_RETRY_DELAY_MS,\n  HANDLER_DEFAULT_BASE_URL,\n} from '../config/handler-constants.js';\n\n/**\n * Structured logger for Lambda (outputs JSON to CloudWatch).\n * Debug messages only emitted when LOG_LEVEL=debug.\n */\nfunction logEntry(level: string, tag: string, message: string, data?: unknown) {\n  const line = JSON.stringify({ level, tag, message, data, ts: new Date().toISOString() });\n  switch (level) {\n    case 'ERROR': console.error(line); break;\n    case 'DEBUG': if (process.env.LOG_LEVEL === 'debug') console.debug(line); break;\n    default: console.log(line);\n  }\n}\n\nconst lambdaLog = {\n  info: (tag: string, message: string, data?: unknown) => logEntry('INFO', tag, message, data),\n  error: (tag: string, message: string, data?: unknown) => logEntry('ERROR', tag, message, data),\n  debug: (tag: string, message: string, data?: unknown) => logEntry('DEBUG', tag, message, data),\n};\n\nconst RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);\nconst RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */\nconst PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;\nif (!PLATFORM_SECRET_NAME) {\n  throw new Error('PLATFORM_SECRET_NAME environment variable is required');\n}\n\n/** Cached token to avoid repeated Secrets Manager calls within a single invocation. */\nlet cachedToken: string | null = null;\n\n/** @internal Reset cached token (for testing only). */\nexport function _resetCredentialsCache(): void { cachedToken = null; }\n\n/**\n * Fetch JWT token from AWS Secrets Manager.\n * Caches the result for the lifetime of the Lambda execution context.\n *\n * The secret name is set via PLATFORM_SECRET_NAME env var (e.g. `{prefix}/{orgId}/platform`)\n * Create it with: `pipeline-manager infra store-token`\n */\nasync function getToken(): Promise<string> {\n  if (cachedToken) return cachedToken;\n\n  lambdaLog.info('AUTH', `Fetching token from Secrets Manager: ${PLATFORM_SECRET_NAME}`);\n\n  const client = new SecretsManagerClient({});\n  const response = await client.send(new GetSecretValueCommand({ SecretId: PLATFORM_SECRET_NAME }));\n\n  if (!response.SecretString) {\n    throw new Error(`Secret \"${PLATFORM_SECRET_NAME}\" is empty`);\n  }\n\n  const parsed = JSON.parse(response.SecretString) as Record<string, string>;\n  // Schema is `{ username, password, ... }` — the `password` field is the\n  // platform JWT. Same secret is read by CodeBuild's `secretsManagerCredentials`\n  // for registry pulls (Basic auth: username:password = orgId:JWT). The\n  // pipeline-image-registry token endpoint validates the password as a JWT\n  // and issues a registry token scoped to the JWT's org.\n  if (!parsed.password) {\n    throw new Error(`Secret \"${PLATFORM_SECRET_NAME}\" missing password — run \"pipeline-manager infra store-token\" to generate`);\n  }\n\n  cachedToken = parsed.password;\n  lambdaLog.info('AUTH', 'Token retrieved from Secrets Manager');\n  return cachedToken;\n}\n\n/**\n * Creates a pre-configured Axios instance for API requests.\n *\n * @param baseURL - Base URL of the target API\n * @param token - JWT token for authorization\n * @returns Configured Axios instance\n */\nfunction create(baseURL: string, token: string): AxiosInstance {\n  return axios.create({\n    baseURL,\n    timeout: HANDLER_TIMEOUT_MS,\n    headers: {\n      'Content-Type': 'application/json',\n      'Authorization': `Bearer ${token}`,\n    },\n  });\n}\n\n/**\n * Fetches plugin configuration from the external API with retry logic.\n * Retries on transient failures (429, 502, 503, 504, network errors)\n * with exponential backoff.\n *\n * @param api - Configured Axios instance\n * @param pluginFilter - Filter criteria for the plugin lookup\n * @returns The plugin data returned by the API\n * @throws Error on persistent failure, timeout or invalid response\n */\nasync function fetch(api: AxiosInstance, pluginFilter: PluginFilter): Promise<Plugin> {\n  lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });\n\n  let lastError: Error | undefined;\n\n  for (let attempt = 0; attempt <= HANDLER_MAX_RETRIES; attempt++) {\n    if (attempt > 0) {\n      const delay = HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1);\n      lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${HANDLER_MAX_RETRIES + 1} after ${delay}ms`);\n      await sleep(delay);\n    }\n\n    try {\n      const { data, status } = await api.post<Plugin>('/api/plugins/lookup', {\n        filter: pluginFilter,\n      });\n\n      if (!data) {\n        throw new Error('Empty response data from API');\n      }\n\n      lambdaLog.info('FETCH', 'Plugin fetched successfully', {\n        status,\n        plugin: data.name,\n        version: data.version,\n        id: data.id,\n      });\n\n      return data;\n    } catch (error) {\n      if (error instanceof AxiosError) {\n        if (error.code === 'ECONNABORTED') {\n          lambdaLog.error('FETCH', `Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n          throw new Error(`Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n        }\n\n        const retryable = error.response\n          ? RETRYABLE_STATUSES.has(error.response.status)\n          : RETRYABLE_CODES.has(error.code ?? '');\n\n        const msg = error.response\n          ? `API error ${error.response.status}: ${error.response.statusText}`\n          : error.code || error.message;\n\n        if (retryable && attempt < HANDLER_MAX_RETRIES) {\n          lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });\n          lastError = new Error(`Failed to fetch plugin: ${msg}`);\n          continue;\n        }\n\n        // Don't log the upstream body verbatim — it may carry a stack trace,\n        // a request payload echo, or other sensitive data we shouldn't echo\n        // into Lambda CloudWatch logs. Keep just the high-level shape.\n        const safeBody = error.response?.data && typeof error.response.data === 'object'\n          ? { code: (error.response.data as { code?: string }).code, message: (error.response.data as { message?: string }).message }\n          : undefined;\n        lambdaLog.error('FETCH', msg, { responseBody: safeBody });\n        throw new Error(`Failed to fetch plugin: ${msg}`);\n      }\n\n      throw error instanceof Error ? error : new Error('Unknown error during plugin fetch');\n    }\n  }\n\n  throw lastError ?? new Error('Failed to fetch plugin after retries');\n}\n\n/**\n * Validates the plugin filter object\n *\n * @param pluginFilter - Filter to validate\n * @returns true if valid\n * @throws Error if invalid\n */\nfunction validatePluginFilter(pluginFilter: unknown): pluginFilter is PluginFilter {\n  if (!pluginFilter || typeof pluginFilter !== 'object') {\n    throw new Error('Missing or invalid pluginFilter');\n  }\n\n  const filter = pluginFilter as Record<string, unknown>;\n  if (!filter.name && !filter.id && !filter.version && !filter.orgId) {\n    throw new Error('PluginFilter must have at least one criterion (name, id, version, or orgId)');\n  }\n\n  return true;\n}\n\n/**\n * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.\n *\n * Authenticates using JWT token from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).\n * Create the secret with: `pipeline-manager infra store-token`\n *\n * Request Types:\n * - Create/Update: fetches and returns plugin configuration from API\n * - Delete: no-op (always succeeds)\n *\n * Response:\n * - Success: Returns base64-encoded plugin JSON in Data.ResultValue\n * - Failure: Returns error message in Reason\n *\n * @param event - CloudFormation custom resource event\n * @returns CloudFormation response\n *\n * @example\n * Custom Resource Properties:\n * ```json\n * {\n *   \"baseURL\": \"https://api.example.com\",\n *   \"pluginFilter\": {\n *     \"name\": \"nodejs-build\",\n *     \"version\": \"1.0.0\",\n *     \"isActive\": true\n *   }\n * }\n * ```\n */\nexport const handler = async (\n  event: CloudFormationCustomResourceEvent,\n): Promise<CloudFormationCustomResourceResponse> => {\n  // NOTE: never log event.StackId here — the CloudFormation Stack ARN embeds the\n  // AWS account id (arn:aws:cloudformation:<region>:<ACCOUNT_ID>:stack/…), which\n  // must never be persisted to CloudWatch. requestId + logicalResourceId are\n  // sufficient for correlation. (StackId is still returned in the CFN response\n  // body below — that is the mandatory CFN protocol field and is not a log.)\n  lambdaLog.info('START', `${event.RequestType} request received`, {\n    logicalResourceId: event.LogicalResourceId,\n    requestId: event.RequestId,\n  });\n\n  const baseResponse: Partial<CloudFormationCustomResourceResponse> = {\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId,\n    PhysicalResourceId: event.LogicalResourceId,\n  };\n\n  try {\n    // Handle Delete - always succeed (no-op)\n    if (event.RequestType === 'Delete') {\n      lambdaLog.info('DELETE', 'No-op - returning SUCCESS');\n      return {\n        ...baseResponse,\n        Status: 'SUCCESS',\n        Reason: 'Delete completed (no-op)',\n      } as CloudFormationCustomResourceResponse;\n    }\n\n    // Extract and validate properties\n    const pluginFilter = event.ResourceProperties.pluginFilter;\n    const baseURL = event.ResourceProperties.baseURL || HANDLER_DEFAULT_BASE_URL;\n\n    if (!baseURL.startsWith('https://') && !baseURL.startsWith('http://')) {\n      throw new Error(`Invalid baseURL: \"${baseURL}\" — must start with http:// or https://`);\n    }\n\n    lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });\n\n    validatePluginFilter(pluginFilter);\n\n    // Get token from Secrets Manager and create API client\n    const token = await getToken();\n    const api = create(baseURL, token);\n\n    // Fetch plugin\n    lambdaLog.info('FETCH', 'Initiating plugin lookup...');\n    const plugin = await fetch(api, pluginFilter);\n    lambdaLog.info('FETCH', 'Plugin retrieved successfully', {\n      name: plugin.name,\n      version: plugin.version,\n      id: plugin.id,\n    });\n\n    // Strip large fields to stay within CloudFormation's 4096-byte Data limit.\n    // CDK constructs only need the fields used by createCodeBuildStep().\n    const slim = {\n      id: plugin.id,\n      name: plugin.name,\n      version: plugin.version,\n      pluginType: plugin.pluginType,\n      computeType: plugin.computeType,\n      commands: plugin.commands,\n      installCommands: plugin.installCommands,\n      env: plugin.env,\n      metadata: plugin.metadata,\n      primaryOutputDirectory: plugin.primaryOutputDirectory,\n      secrets: plugin.secrets,\n      failureBehavior: plugin.failureBehavior,\n      timeout: plugin.timeout,\n    };\n\n    const encoded = Buffer.from(JSON.stringify(slim), 'utf-8').toString('base64');\n    lambdaLog.debug('ENCODE', 'Encoded plugin data', { length: encoded.length });\n\n    return {\n      ...baseResponse,\n      Status: 'SUCCESS',\n      Reason: `Plugin '${plugin.name}' (v${plugin.version}) retrieved successfully`,\n      Data: {\n        ResultValue: encoded,\n      },\n    } as CloudFormationCustomResourceResponse;\n  } catch (error) {\n    const reason = error instanceof Error ? error.message : 'Unexpected error occurred';\n    lambdaLog.error('ERROR', 'Handler failed', {\n      reason,\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n\n    return {\n      ...baseResponse,\n      Status: 'FAILED',\n      Reason: reason,\n    } as CloudFormationCustomResourceResponse;\n  } finally {\n    lambdaLog.info('END', 'Custom resource execution completed');\n  }\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup-handler.js","sourceRoot":"","sources":["../../src/handlers/plugin-lookup-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse } from 'aws-lambda';\nimport axios, { type AxiosInstance, AxiosError } from 'axios';\n// Import the dependency-free leaf, NOT `app-config.js`/`CoreConstants`: the latter\n// transitively pulls infrastructure-config → aws-cdk-lib, which esbuild then tries\n// to bundle into this Lambda (hundreds of MB → OOM/SIGKILL during cold-start synth).\nimport {\n  HANDLER_TIMEOUT_MS,\n  HANDLER_MAX_RETRIES,\n  HANDLER_RETRY_DELAY_MS,\n  HANDLER_DEFAULT_BASE_URL,\n} from '../config/handler-constants.js';\nimport { unwrapLookup } from '../core/plugin-lookup-envelope.js';\nimport { createPlatformCredential, isCredentialRefusal } from './platform-credential.js';\n\n/**\n * Structured logger for Lambda (outputs JSON to CloudWatch).\n * Debug messages only emitted when LOG_LEVEL=debug.\n */\nfunction logEntry(level: string, tag: string, message: string, data?: unknown) {\n  const line = JSON.stringify({ level, tag, message, data, ts: new Date().toISOString() });\n  switch (level) {\n    case 'ERROR': console.error(line); break;\n    case 'WARN': console.warn(line); break;\n    case 'DEBUG': if (process.env.LOG_LEVEL === 'debug') console.debug(line); break;\n    default: console.log(line);\n  }\n}\n\nconst lambdaLog = {\n  info: (tag: string, message: string, data?: unknown) => logEntry('INFO', tag, message, data),\n  error: (tag: string, message: string, data?: unknown) => logEntry('ERROR', tag, message, data),\n  warn: (tag: string, message: string, data?: unknown) => logEntry('WARN', tag, message, data),\n  debug: (tag: string, message: string, data?: unknown) => logEntry('DEBUG', tag, message, data),\n};\n\nconst RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);\nconst RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */\nconst PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;\nif (!PLATFORM_SECRET_NAME) {\n  throw new Error('PLATFORM_SECRET_NAME environment variable is required');\n}\n\n/**\n * The service-account key (`pb_sa_…`) from Secrets Manager, cached for the warm\n * container. The plugin API trades it for a short-lived JWT itself, so the key\n * goes out as the Bearer credential. Create the secret with\n * `pipeline-manager infra store-token`.\n */\nconst credential = createPlatformCredential({ secretName: PLATFORM_SECRET_NAME });\n\n/** @internal Reset cached credential (for testing only). */\nexport function _resetCredentialsCache(): void { credential.reset(); }\n\n/** The API refused the credential (401/403) — the caller may refresh it and retry once. */\nclass CredentialRefusedError extends Error {}\n\n/**\n * Creates a pre-configured Axios instance for API requests.\n *\n * @param baseURL - Base URL of the target API\n * @param key - service-account key sent as the Bearer credential\n * @returns Configured Axios instance\n */\nfunction create(baseURL: string, key: string): AxiosInstance {\n  return axios.create({\n    baseURL,\n    timeout: HANDLER_TIMEOUT_MS,\n    headers: {\n      'Content-Type': 'application/json',\n      'Authorization': `Bearer ${key}`,\n    },\n  });\n}\n\n/**\n * Fetches plugin configuration from the external API with retry logic.\n * Retries on transient failures (429, 502, 503, 504, network errors)\n * with exponential backoff.\n *\n * @param api - Configured Axios instance\n * @param pluginFilter - Filter criteria for the plugin lookup\n * @returns The plugin data returned by the API\n * @throws Error on persistent failure, timeout or invalid response\n */\nasync function fetch(api: AxiosInstance, pluginFilter: PluginFilter): Promise<Plugin> {\n  lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });\n\n  let lastError: Error | undefined;\n\n  for (let attempt = 0; attempt <= HANDLER_MAX_RETRIES; attempt++) {\n    if (attempt > 0) {\n      const delay = HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1);\n      lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${HANDLER_MAX_RETRIES + 1} after ${delay}ms`);\n      await sleep(delay);\n    }\n\n    try {\n      const { data: body, status } = await api.post<unknown>('/api/plugins/lookup', {\n        filter: pluginFilter,\n      });\n\n      const { plugin: data, warnings } = unwrapLookup(body);\n      if (!data) {\n        throw new Error('Empty response data from API');\n      }\n      // Lifecycle warnings (deprecated / yanked-but-pinned) — surfaced in the\n      // deploy log; the lookup still succeeds.\n      for (const message of warnings) lambdaLog.warn('LIFECYCLE', message, { plugin: data.name, version: data.version });\n\n      lambdaLog.info('FETCH', 'Plugin fetched successfully', {\n        status,\n        plugin: data.name,\n        version: data.version,\n        id: data.id,\n      });\n\n      return data;\n    } catch (error) {\n      if (error instanceof AxiosError) {\n        if (error.code === 'ECONNABORTED') {\n          lambdaLog.error('FETCH', `Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n          throw new Error(`Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n        }\n\n        const retryable = error.response\n          ? RETRYABLE_STATUSES.has(error.response.status)\n          : RETRYABLE_CODES.has(error.code ?? '');\n\n        const msg = error.response\n          ? `API error ${error.response.status}: ${error.response.statusText}`\n          : error.code || error.message;\n\n        if (isCredentialRefusal(error.response?.status)) {\n          lambdaLog.warn('AUTH', `Credential refused: ${msg}`);\n          throw new CredentialRefusedError(`Failed to fetch plugin: ${msg}`);\n        }\n\n        if (retryable && attempt < HANDLER_MAX_RETRIES) {\n          lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });\n          lastError = new Error(`Failed to fetch plugin: ${msg}`);\n          continue;\n        }\n\n        // Don't log the upstream body verbatim — it may carry a stack trace,\n        // a request payload echo, or other sensitive data we shouldn't echo\n        // into Lambda CloudWatch logs. Keep just the high-level shape.\n        const safeBody = error.response?.data && typeof error.response.data === 'object'\n          ? { code: (error.response.data as { code?: string }).code, message: (error.response.data as { message?: string }).message }\n          : undefined;\n        lambdaLog.error('FETCH', msg, { responseBody: safeBody });\n        throw new Error(`Failed to fetch plugin: ${msg}`);\n      }\n\n      throw error instanceof Error ? error : new Error('Unknown error during plugin fetch');\n    }\n  }\n\n  throw lastError ?? new Error('Failed to fetch plugin after retries');\n}\n\n/**\n * Look the plugin up with the cached credential. On a 401/403 the key was most\n * likely rotated underneath this warm container (token-renew stores the new key\n * and revokes the old one), so drop the cache, re-read the secret and retry once.\n */\nasync function lookupWithCredentialRefresh(baseURL: string, pluginFilter: PluginFilter): Promise<Plugin> {\n  try {\n    return await fetch(create(baseURL, await credential.getKey()), pluginFilter);\n  } catch (err) {\n    if (!(err instanceof CredentialRefusedError)) throw err;\n    credential.invalidate();\n    lambdaLog.info('AUTH', 'Re-reading the service-account key from Secrets Manager and retrying once');\n    return fetch(create(baseURL, await credential.getKey()), pluginFilter);\n  }\n}\n\n/**\n * Validates the plugin filter object\n *\n * @param pluginFilter - Filter to validate\n * @returns true if valid\n * @throws Error if invalid\n */\nfunction validatePluginFilter(pluginFilter: unknown): pluginFilter is PluginFilter {\n  if (!pluginFilter || typeof pluginFilter !== 'object') {\n    throw new Error('Missing or invalid pluginFilter');\n  }\n\n  const filter = pluginFilter as Record<string, unknown>;\n  if (!filter.name && !filter.id && !filter.version && !filter.orgId) {\n    throw new Error('PluginFilter must have at least one criterion (name, id, version, or orgId)');\n  }\n\n  return true;\n}\n\n/**\n * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.\n *\n * Authenticates with the service-account key from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).\n * Create the secret with: `pipeline-manager infra store-token`\n *\n * Request Types:\n * - Create/Update: fetches and returns plugin configuration from API\n * - Delete: no-op (always succeeds)\n *\n * Response:\n * - Success: Returns base64-encoded plugin JSON in Data.ResultValue\n * - Failure: Returns error message in Reason\n *\n * @param event - CloudFormation custom resource event\n * @returns CloudFormation response\n *\n * @example\n * Custom Resource Properties:\n * ```json\n * {\n *   \"baseURL\": \"https://api.example.com\",\n *   \"pluginFilter\": {\n *     \"name\": \"nodejs-build\",\n *     \"version\": \"1.0.0\",\n *     \"isActive\": true\n *   }\n * }\n * ```\n */\nexport const handler = async (\n  event: CloudFormationCustomResourceEvent,\n): Promise<CloudFormationCustomResourceResponse> => {\n  // NOTE: never log event.StackId here — the CloudFormation Stack ARN embeds the\n  // AWS account id (arn:aws:cloudformation:<region>:<ACCOUNT_ID>:stack/…), which\n  // must never be persisted to CloudWatch. requestId + logicalResourceId are\n  // sufficient for correlation. (StackId is still returned in the CFN response\n  // body below — that is the mandatory CFN protocol field and is not a log.)\n  lambdaLog.info('START', `${event.RequestType} request received`, {\n    logicalResourceId: event.LogicalResourceId,\n    requestId: event.RequestId,\n  });\n\n  const baseResponse: Partial<CloudFormationCustomResourceResponse> = {\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId,\n    PhysicalResourceId: event.LogicalResourceId,\n  };\n\n  try {\n    // Handle Delete - always succeed (no-op)\n    if (event.RequestType === 'Delete') {\n      lambdaLog.info('DELETE', 'No-op - returning SUCCESS');\n      return {\n        ...baseResponse,\n        Status: 'SUCCESS',\n        Reason: 'Delete completed (no-op)',\n      } as CloudFormationCustomResourceResponse;\n    }\n\n    // Extract and validate properties\n    const pluginFilter = event.ResourceProperties.pluginFilter;\n    const baseURL = event.ResourceProperties.baseURL || HANDLER_DEFAULT_BASE_URL;\n\n    if (!baseURL.startsWith('https://') && !baseURL.startsWith('http://')) {\n      throw new Error(`Invalid baseURL: \"${baseURL}\" — must start with http:// or https://`);\n    }\n\n    lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });\n\n    validatePluginFilter(pluginFilter);\n\n    lambdaLog.info('FETCH', 'Initiating plugin lookup...');\n    const plugin = await lookupWithCredentialRefresh(baseURL, pluginFilter);\n    lambdaLog.info('FETCH', 'Plugin retrieved successfully', {\n      name: plugin.name,\n      version: plugin.version,\n      id: plugin.id,\n    });\n\n    // Strip large fields to stay within CloudFormation's 4096-byte Data limit.\n    // CDK constructs only need the fields used by createCodeBuildStep().\n    const slim = {\n      id: plugin.id,\n      name: plugin.name,\n      version: plugin.version,\n      pluginType: plugin.pluginType,\n      computeType: plugin.computeType,\n      commands: plugin.commands,\n      installCommands: plugin.installCommands,\n      env: plugin.env,\n      metadata: plugin.metadata,\n      primaryOutputDirectory: plugin.primaryOutputDirectory,\n      secrets: plugin.secrets,\n      failureBehavior: plugin.failureBehavior,\n      timeout: plugin.timeout,\n    };\n\n    const encoded = Buffer.from(JSON.stringify(slim), 'utf-8').toString('base64');\n    lambdaLog.debug('ENCODE', 'Encoded plugin data', { length: encoded.length });\n\n    return {\n      ...baseResponse,\n      Status: 'SUCCESS',\n      Reason: `Plugin '${plugin.name}' (v${plugin.version}) retrieved successfully`,\n      Data: {\n        ResultValue: encoded,\n      },\n    } as CloudFormationCustomResourceResponse;\n  } catch (error) {\n    const reason = error instanceof Error ? error.message : 'Unexpected error occurred';\n    lambdaLog.error('ERROR', 'Handler failed', {\n      reason,\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n\n    return {\n      ...baseResponse,\n      Status: 'FAILED',\n      Reason: reason,\n    } as CloudFormationCustomResourceResponse;\n  } finally {\n    lambdaLog.info('END', 'Custom resource execution completed');\n  }\n};\n"]}

package/lib/index.d.ts

@@ -22,9 +22,7 @@
  *
  * **Helpers**
  * - replaceNonAlphanumeric, extractMetadataEnv — string and metadata utilities
- *
- * **Re-exports from api-core**
- * - ErrorCode, createLogger
+ * - resolveFailureBehavior, wrapCommandsForFailureBehavior — a step's failureBehavior, as CodeBuild runs it
  *
  * The Postgres/Drizzle data layer (db, schema, CrudService, query builders,
  * filter/compliance types, etc.) is NOT re-exported here — import those
@@ -32,13 +30,15 @@
  */
 export * from './config/app-config.js';
 export * from './config/config-types.js';
-export * from './config/entitlements.js';
 export * from './config/service-client.js';
 export { parsePlatformBaseUrl } from './config/infrastructure-config.js';
-export * from './core/pipeline-types.js';
+export { ComputeType, PluginType, type MetaDataType, type Visibility, TriggerType, MetadataKeys, type MetadataKey, CDK_METADATA_PREFIX } from './core/pipeline-types.js';
 export * from './core/role-types.js';
 export * from './core/security-group-types.js';
-export * from './core/id-generator.js';
-export { replaceNonAlphanumeric, extractMetadataEnv } from './core/metadata-helpers.js';
+export { replaceNonAlphanumeric, extractMetadataEnv, resolveFailureBehavior, wrapCommandsForFailureBehavior, STEP_BOOTSTRAP_CMD } from './core/metadata-helpers.js';
+export * from './core/step-manifest.js';
+export { type ContractValueType, type PluginContract, type ContractScope, type ContractIssue, type ContractScopeProps, pipelineScopeMetadata, pipelineContractScope, contractScopeFromTemplateScope, isContractValueOfType, checkPluginContract, type PluginStepRef, collectPluginSteps, pluginLookupFilter, pluginArtifactAlias, type PluginRefIdentity, sanitizePublisher, } from './core/plugin-contract.js';
+export { unwrapLookup } from './core/plugin-lookup-envelope.js';
 export * from './pipeline/plugin-spec.js';
-export * from './template/index.js';
+export { tokenize, hasTemplate, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, type Token, type LiteralToken, type ExprToken, type SourcePosition, resolve, dependencies, type Scope, type EvalError, type WalkEntry, type FieldPredicate, type TopoNode, type TopoResult, validateTemplates, detectCycles, allowedScopeRoots, type TemplateError, type TemplateValidationResult, type ResolveResult, resolveSelfReferencing, } from './template/index.js';
+export { resolvePluginTemplates, isPluginTemplatableField } from './template/plugin-resolver.js';

package/lib/index.js

@@ -24,9 +24,7 @@
  *
  * **Helpers**
  * - replaceNonAlphanumeric, extractMetadataEnv — string and metadata utilities
- *
- * **Re-exports from api-core**
- * - ErrorCode, createLogger
+ * - resolveFailureBehavior, wrapCommandsForFailureBehavior — a step's failureBehavior, as CodeBuild runs it
  *
  * The Postgres/Drizzle data layer (db, schema, CrudService, query builders,
  * filter/compliance types, etc.) is NOT re-exported here — import those
@@ -35,17 +33,20 @@
 // Configuration
 export * from './config/app-config.js';
 export * from './config/config-types.js';
-export * from './config/entitlements.js';
 export * from './config/service-client.js';
 export { parsePlatformBaseUrl } from './config/infrastructure-config.js';
 // Core types (public surface)
-export * from './core/pipeline-types.js';
+export { ComputeType, PluginType, TriggerType, MetadataKeys, CDK_METADATA_PREFIX } from './core/pipeline-types.js';
 export * from './core/role-types.js';
 export * from './core/security-group-types.js';
-export * from './core/id-generator.js';
-export { replaceNonAlphanumeric, extractMetadataEnv } from './core/metadata-helpers.js';
+export { replaceNonAlphanumeric, extractMetadataEnv, resolveFailureBehavior, wrapCommandsForFailureBehavior, STEP_BOOTSTRAP_CMD } from './core/metadata-helpers.js';
+export * from './core/step-manifest.js';
+export { pipelineScopeMetadata, pipelineContractScope, contractScopeFromTemplateScope, isContractValueOfType, checkPluginContract, collectPluginSteps, pluginLookupFilter, pluginArtifactAlias, sanitizePublisher, } from './core/plugin-contract.js';
+export { unwrapLookup } from './core/plugin-lookup-envelope.js';
 // Plugin domain type (the synth-time authoring types live in the `/cdk` entry)
 export * from './pipeline/plugin-spec.js';
 // Template engine — synth-time scripting for pipeline config + plugin specs
-export * from './template/index.js';
-//# sourceMappingURL=data:application/json;base64,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
+export { tokenize, hasTemplate, MAX_FIELD_SIZE_BYTES, MAX_PATH_DEPTH, resolve, dependencies, validateTemplates, detectCycles, allowedScopeRoots, resolveSelfReferencing, } from './template/index.js';
+// A plugin's `{{ … }}` resolution against a pipeline scope (synth, `plugin test`)
+export { resolvePluginTemplates, isPluginTemplatableField } from './template/plugin-resolver.js';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/pipeline/pipeline-builder.d.ts

@@ -7,6 +7,7 @@ import type { RegistryConfig } from '../config/config-types.js';
 import type { CodeBuildDefaults } from '../core/network-types.js';
 import type { MetaDataType } from '../core/pipeline-types.js';
 import type { RoleConfig } from '../core/role-types.js';
+import type { StepManifestEntry } from '../core/step-manifest.js';
 /**
  * Configuration properties for the PipelineBuilder construct
  */
@@ -107,6 +108,12 @@ export interface BuilderProps {
 export declare class PipelineBuilder extends Construct {
     readonly pipeline: CodePipeline;
     readonly config: PipelineConfiguration;
+    /**
+     * Which plugin each CodePipeline action runs, read off the built
+     * pipeline. The CLI ships it with the registry registration so event ingest
+     * can attribute action outcomes to a plugin version.
+     */
+    readonly stepManifest: StepManifestEntry[];
     constructor(scope: Construct, id: string, props: BuilderProps);
     /**
      * Build a custom artifact bucket when `encryption.kmsKeyArn` and/or