@pipeline-builder/pipeline-events 4.3.3 → 4.3.5

package/lib/failure-reason.d.ts

@@ -0,0 +1,37 @@
+import { type SynthFailure } from '@pipeline-builder/pipeline-core/lib/core/synth-failure.js';
+/**
+ * The build id of a failed CodeBuild action, from the event detail; null for a
+ * non-CodeBuild action or an event that carries no external execution id.
+ */
+export declare function codeBuildIdOf(detail: Record<string, unknown>): string | null;
+/**
+ * The compute size a finished CodeBuild action ran on, AS AWS SPELLS IT
+ * (`BUILD_GENERAL1_MEDIUM`), or null.
+ *
+ * Returned raw and narrowed server-side rather than here, for one hard reason:
+ * this Lambda ships as a SINGLE bundled file, and the vocabulary lives in the
+ * pipeline-core barrel, which carries dynamic imports that break that constraint
+ * (`test/single-file-constraint.test.ts` is the check). Sending the raw string
+ * also keeps the stored `detail.computeType` the observation rather than an
+ * interpretation of it.
+ *
+ * WHY IT IS READ FROM AWS rather than from our own stored pipeline config: the
+ * config holds a step's REQUESTED compute type, and what the build actually ran
+ * on is what consumed vCPU — a pipeline edited between the start and the finish
+ * would otherwise be priced against the new value. `BatchGetBuilds` answers the
+ * authoritative one, and this Lambda already holds that permission for the
+ * failure-reason read below.
+ *
+ * Best-effort, like everything else here: a throttle or a missing permission
+ * yields null, the event forwards without the field, and the ingest records that
+ * action as unmeasured rather than as free. A size that cannot be read must not
+ * be guessed — SMALL is the cheapest and therefore the most flattering guess.
+ *
+ * NOT folded into {@link readSynthFailure}, which makes the same call: that one
+ * runs on FAILED actions only, this one on every terminal CodeBuild action, and
+ * sharing a cache between them would mean holding build records for the whole
+ * batch to save one call on the minority path.
+ */
+export declare function readBuildCompute(region: string, buildId: string): Promise<string | null>;
+/** Find the `PB_SYNTH_FAILURE` line in a failed build's log, or null. */
+export declare function readSynthFailure(region: string, buildId: string): Promise<SynthFailure | null>;

package/lib/failure-reason.js

@@ -0,0 +1,111 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { parseSynthFailure, SYNTH_FAILURE_MARKER } from '@pipeline-builder/pipeline-core/lib/core/synth-failure.js';
+import { loadSdk, log } from './util.js';
+let loader = loadSdk;
+const clients = new Map();
+/** @internal Test-only: substitute the SDK loader (and drop cached clients). */
+export function _setFailureReasonLoaderForTests(next) {
+    loader = next ?? loadSdk;
+    clients.clear();
+}
+async function client(kind, region) {
+    const mod = kind === 'codebuild'
+        ? await loader('@aws-sdk/client-codebuild')
+        : await loader('@aws-sdk/client-cloudwatch-logs');
+    const key = `${kind}:${region}`;
+    let c = clients.get(key);
+    if (!c) {
+        c = kind === 'codebuild'
+            ? new mod.CodeBuildClient({ region })
+            : new mod.CloudWatchLogsClient({ region });
+        clients.set(key, c);
+    }
+    return { client: c, mod };
+}
+/** A CodeBuild build id: `<project>:<uuid>`. */
+const BUILD_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{1,254}:[0-9a-f-]{36}$/;
+/**
+ * The build id of a failed CodeBuild action, from the event detail; null for a
+ * non-CodeBuild action or an event that carries no external execution id.
+ */
+export function codeBuildIdOf(detail) {
+    const type = detail.type;
+    if (type?.provider !== undefined && type.provider !== 'CodeBuild')
+        return null;
+    const result = detail['execution-result'];
+    const id = result?.['external-execution-id'];
+    return typeof id === 'string' && BUILD_ID_RE.test(id) ? id : null;
+}
+/**
+ * The compute size a finished CodeBuild action ran on, AS AWS SPELLS IT
+ * (`BUILD_GENERAL1_MEDIUM`), or null.
+ *
+ * Returned raw and narrowed server-side rather than here, for one hard reason:
+ * this Lambda ships as a SINGLE bundled file, and the vocabulary lives in the
+ * pipeline-core barrel, which carries dynamic imports that break that constraint
+ * (`test/single-file-constraint.test.ts` is the check). Sending the raw string
+ * also keeps the stored `detail.computeType` the observation rather than an
+ * interpretation of it.
+ *
+ * WHY IT IS READ FROM AWS rather than from our own stored pipeline config: the
+ * config holds a step's REQUESTED compute type, and what the build actually ran
+ * on is what consumed vCPU — a pipeline edited between the start and the finish
+ * would otherwise be priced against the new value. `BatchGetBuilds` answers the
+ * authoritative one, and this Lambda already holds that permission for the
+ * failure-reason read below.
+ *
+ * Best-effort, like everything else here: a throttle or a missing permission
+ * yields null, the event forwards without the field, and the ingest records that
+ * action as unmeasured rather than as free. A size that cannot be read must not
+ * be guessed — SMALL is the cheapest and therefore the most flattering guess.
+ *
+ * NOT folded into {@link readSynthFailure}, which makes the same call: that one
+ * runs on FAILED actions only, this one on every terminal CodeBuild action, and
+ * sharing a cache between them would mean holding build records for the whole
+ * batch to save one call on the minority path.
+ */
+export async function readBuildCompute(region, buildId) {
+    try {
+        const cb = await client('codebuild', region);
+        const out = await cb.client.send(new cb.mod.BatchGetBuildsCommand({ ids: [buildId] }));
+        return out.builds?.[0]?.environment?.computeType ?? null;
+    }
+    catch (err) {
+        log.warn('Could not read the build\'s compute size (forwarding without it)', {
+            buildId, error: String(err),
+        });
+        return null;
+    }
+}
+/** Find the `PB_SYNTH_FAILURE` line in a failed build's log, or null. */
+export async function readSynthFailure(region, buildId) {
+    try {
+        const cb = await client('codebuild', region);
+        const out = await cb.client.send(new cb.mod.BatchGetBuildsCommand({ ids: [buildId] }));
+        const logs = out.builds?.[0]?.logs;
+        if (!logs?.groupName || !logs.streamName)
+            return null;
+        const cw = await client('logs', region);
+        const res = await cw.client.send(new cw.mod.FilterLogEventsCommand({
+            logGroupName: logs.groupName,
+            logStreamNames: [logs.streamName],
+            filterPattern: `"${SYNTH_FAILURE_MARKER}"`,
+            limit: 5,
+        }));
+        for (const event of res.events ?? []) {
+            const failure = typeof event.message === 'string' ? parseSynthFailure(event.message) : null;
+            if (failure)
+                return failure;
+        }
+        return null;
+    }
+    catch (err) {
+        log.warn('Could not read the failed build\'s structured failure reason (forwarding without it)', {
+            buildId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"failure-reason.js","sourceRoot":"","sources":["../src/failure-reason.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { parseSynthFailure, SYNTH_FAILURE_MARKER, type SynthFailure } from '@pipeline-builder/pipeline-core/lib/core/synth-failure.js';\nimport { loadSdk, log } from './util.js';\n\n// Structured failure reasons for failed CodeBuild actions.\n//\n// A CodePipeline action-failure event carries only CodeBuild's generic summary\n// (\"Error while executing command: … exit status 1\"), never the build output —\n// so WHY a synth refused a plugin (not installed, denied by policy, bad signature)\n// was readable only in the build log. `pipeline-manager pipeline synth` prints\n// one `PB_SYNTH_FAILURE {…}` line when it fails inside CodeBuild; this module\n// finds that line in the failed build's CloudWatch log stream.\n//\n// In-account and best-effort: BatchGetBuilds → the build's log group/stream →\n// FilterLogEvents for the marker. Any failure (no permission, logs not yet\n// flushed, no marker) yields null and the event is forwarded without it — a\n// missing reason must never hold up event ingestion. Requires\n// `codebuild:BatchGetBuilds` + `logs:FilterLogEvents` (events-stack.json).\n//\n// The SDK clients come from the Lambda runtime (variable-specifier load, like\n// CodeCommit/SQS), so they are not dependencies of this package.\n\ninterface SdkClient { send(command: unknown): Promise<unknown> }\ninterface CodeBuildModule {\n  CodeBuildClient: new (config: { region: string }) => SdkClient;\n  BatchGetBuildsCommand: new (input: { ids: string[] }) => unknown;\n}\n\n/** What `BatchGetBuilds` answers, for the two things this module reads off it. */\ninterface BatchGetBuildsOutput {\n  builds?: Array<{\n    logs?: { groupName?: string; streamName?: string };\n    environment?: { computeType?: string };\n  }>;\n}\ninterface LogsModule {\n  CloudWatchLogsClient: new (config: { region: string }) => SdkClient;\n  FilterLogEventsCommand: new (input: {\n    logGroupName: string; logStreamNames: string[]; filterPattern: string; limit: number;\n  }) => unknown;\n}\n\ntype Loader = <T>(pkg: string) => Promise<T>;\nlet loader: Loader = loadSdk;\nconst clients = new Map<string, SdkClient>();\n\n/** @internal Test-only: substitute the SDK loader (and drop cached clients). */\nexport function _setFailureReasonLoaderForTests(next: Loader | undefined): void {\n  loader = next ?? loadSdk;\n  clients.clear();\n}\n\nasync function client(kind: 'codebuild' | 'logs', region: string): Promise<{ client: SdkClient; mod: CodeBuildModule | LogsModule }> {\n  const mod = kind === 'codebuild'\n    ? await loader<CodeBuildModule>('@aws-sdk/client-codebuild')\n    : await loader<LogsModule>('@aws-sdk/client-cloudwatch-logs');\n  const key = `${kind}:${region}`;\n  let c = clients.get(key);\n  if (!c) {\n    c = kind === 'codebuild'\n      ? new (mod as CodeBuildModule).CodeBuildClient({ region })\n      : new (mod as LogsModule).CloudWatchLogsClient({ region });\n    clients.set(key, c);\n  }\n  return { client: c, mod };\n}\n\n/** A CodeBuild build id: `<project>:<uuid>`. */\nconst BUILD_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{1,254}:[0-9a-f-]{36}$/;\n\n/**\n * The build id of a failed CodeBuild action, from the event detail; null for a\n * non-CodeBuild action or an event that carries no external execution id.\n */\nexport function codeBuildIdOf(detail: Record<string, unknown>): string | null {\n  const type = detail.type as { provider?: unknown } | undefined;\n  if (type?.provider !== undefined && type.provider !== 'CodeBuild') return null;\n  const result = detail['execution-result'] as { 'external-execution-id'?: unknown } | undefined;\n  const id = result?.['external-execution-id'];\n  return typeof id === 'string' && BUILD_ID_RE.test(id) ? id : null;\n}\n\n/**\n * The compute size a finished CodeBuild action ran on, AS AWS SPELLS IT\n * (`BUILD_GENERAL1_MEDIUM`), or null.\n *\n * Returned raw and narrowed server-side rather than here, for one hard reason:\n * this Lambda ships as a SINGLE bundled file, and the vocabulary lives in the\n * pipeline-core barrel, which carries dynamic imports that break that constraint\n * (`test/single-file-constraint.test.ts` is the check). Sending the raw string\n * also keeps the stored `detail.computeType` the observation rather than an\n * interpretation of it.\n *\n * WHY IT IS READ FROM AWS rather than from our own stored pipeline config: the\n * config holds a step's REQUESTED compute type, and what the build actually ran\n * on is what consumed vCPU — a pipeline edited between the start and the finish\n * would otherwise be priced against the new value. `BatchGetBuilds` answers the\n * authoritative one, and this Lambda already holds that permission for the\n * failure-reason read below.\n *\n * Best-effort, like everything else here: a throttle or a missing permission\n * yields null, the event forwards without the field, and the ingest records that\n * action as unmeasured rather than as free. A size that cannot be read must not\n * be guessed — SMALL is the cheapest and therefore the most flattering guess.\n *\n * NOT folded into {@link readSynthFailure}, which makes the same call: that one\n * runs on FAILED actions only, this one on every terminal CodeBuild action, and\n * sharing a cache between them would mean holding build records for the whole\n * batch to save one call on the minority path.\n */\nexport async function readBuildCompute(region: string, buildId: string): Promise<string | null> {\n  try {\n    const cb = await client('codebuild', region);\n    const out = await cb.client.send(\n      new (cb.mod as CodeBuildModule).BatchGetBuildsCommand({ ids: [buildId] }),\n    ) as BatchGetBuildsOutput;\n    return out.builds?.[0]?.environment?.computeType ?? null;\n  } catch (err) {\n    log.warn('Could not read the build\\'s compute size (forwarding without it)', {\n      buildId, error: String(err),\n    });\n    return null;\n  }\n}\n\n/** Find the `PB_SYNTH_FAILURE` line in a failed build's log, or null. */\nexport async function readSynthFailure(region: string, buildId: string): Promise<SynthFailure | null> {\n  try {\n    const cb = await client('codebuild', region);\n    const out = await cb.client.send(\n      new (cb.mod as CodeBuildModule).BatchGetBuildsCommand({ ids: [buildId] }),\n    ) as BatchGetBuildsOutput;\n    const logs = out.builds?.[0]?.logs;\n    if (!logs?.groupName || !logs.streamName) return null;\n\n    const cw = await client('logs', region);\n    const res = await cw.client.send(new (cw.mod as LogsModule).FilterLogEventsCommand({\n      logGroupName: logs.groupName,\n      logStreamNames: [logs.streamName],\n      filterPattern: `\"${SYNTH_FAILURE_MARKER}\"`,\n      limit: 5,\n    })) as { events?: Array<{ message?: string }> };\n    for (const event of res.events ?? []) {\n      const failure = typeof event.message === 'string' ? parseSynthFailure(event.message) : null;\n      if (failure) return failure;\n    }\n    return null;\n  } catch (err) {\n    log.warn('Could not read the failed build\\'s structured failure reason (forwarding without it)', {\n      buildId,\n      error: err instanceof Error ? err.message : String(err),\n    });\n    return null;\n  }\n}\n"]}

package/lib/health.d.ts

@@ -2,9 +2,10 @@
  * Throttled, best-effort post-success work: emit per-org ingest-health and self-heal
  * the DLQ. Never throws. `forwarded`/`lastEventAt` accumulate PER ORG across batches
  * between health posts; `dropped` is the shared fleet DLQ depth snapshot. A per-org
- * counter is zeroed only after that org's health POST is confirmed 2xx.
+ * counter is zeroed only after that org's health POST is confirmed 2xx. `requestId`
+ * is the batch's request id (see index.ts), sent as `X-Request-Id`.
  */
-export declare function reportHealthAndRedrive(baseUrl: string, mainQueueArn: string | undefined): Promise<void>;
+export declare function reportHealthAndRedrive(baseUrl: string, mainQueueArn: string | undefined, requestId: string): Promise<void>;
 /** Count a forwarded batch toward each resolved org's delivery-health report. */
 export declare function recordForwarded(events: ReadonlyArray<{
     orgId: string | null;

package/lib/health.js

@@ -1,7 +1,8 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { correlationHeaders } from '@pipeline-builder/pipeline-core/lib/core/audit-correlation.js';
 import { getAuthToken } from './auth.js';
-import { BoundedMap, CACHE_MAX_ENTRIES, fetchWithTimeout, loadSdk, log } from './util.js';
+import { arnRef, BoundedMap, CACHE_MAX_ENTRIES, fetchWithTimeout, loadSdk, log } from './util.js';
 let sqsMod;
 let sqsClientsByRegion;
 async function sqsClient(region) {
@@ -78,12 +79,12 @@ async function startMoveTask(region, dlqArn, mainArn) {
 /** POST one org's ingest-health signal. Returns true only on a confirmed 2xx so the
  *  caller resets that org's `forwarded` counter ONLY when the signal was accepted
  *  (a dropped/failed POST must not silently zero the accumulated count). */
-async function postIngestHealth(baseUrl, body) {
+async function postIngestHealth(baseUrl, body, requestId) {
     try {
         const token = await getAuthToken();
         const res = await fetchWithTimeout(`${baseUrl}/api/reports/ingest-health`, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
+            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}`, ...correlationHeaders({ requestId }) },
             body: JSON.stringify(body),
         });
         if (!res.ok) {
@@ -101,9 +102,10 @@ async function postIngestHealth(baseUrl, body) {
  * Throttled, best-effort post-success work: emit per-org ingest-health and self-heal
  * the DLQ. Never throws. `forwarded`/`lastEventAt` accumulate PER ORG across batches
  * between health posts; `dropped` is the shared fleet DLQ depth snapshot. A per-org
- * counter is zeroed only after that org's health POST is confirmed 2xx.
+ * counter is zeroed only after that org's health POST is confirmed 2xx. `requestId`
+ * is the batch's request id (see index.ts), sent as `X-Request-Id`.
  */
-export async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
+export async function reportHealthAndRedrive(baseUrl, mainQueueArn, requestId) {
     const now = Date.now();
     if (now - lastHealthAt < HEALTH_THROTTLE_MS)
         return;
@@ -136,7 +138,7 @@ export async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
                 forwarded,
                 dropped: depth,
                 lastEventAt,
-            });
+            }, requestId);
             // Reset the forwarded counter ONLY on a confirmed 2xx — a failed/dropped POST
             // keeps the count so the next tick re-reports it instead of losing it.
             if (ok)
@@ -147,7 +149,7 @@ export async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
             // past the ceiling — that message keeps failing and would loop DLQ→main→DLQ.
             if (oldestAgeSec > MAX_DLQ_REDRIVE_AGE_SEC) {
                 log.warn('DLQ oldest message exceeds poison-age ceiling — skipping redrive (needs manual attention)', {
-                    dlqArn: q.dlqArn, dropped: depth, oldestAgeSec, ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC,
+                    dlq: arnRef(q.dlqArn), dropped: depth, oldestAgeSec, ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC,
                 });
             }
             else {
@@ -155,7 +157,7 @@ export async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
                     if (!(await hasActiveMoveTask(q.region, q.dlqArn))) {
                         lastRedriveAt = now;
                         await startMoveTask(q.region, q.dlqArn, q.mainArn);
-                        log.info('Started self-healing DLQ→main redrive', { dlqArn: q.dlqArn, dropped: depth, oldestAgeSec });
+                        log.info('Started self-healing DLQ→main redrive', { dlq: arnRef(q.dlqArn), dropped: depth, oldestAgeSec });
                     }
                 }
                 catch (err) {
@@ -188,4 +190,4 @@ export function _resetHealthForTests() {
     lastHealthAt = 0;
     lastRedriveAt = 0;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health.js","sourceRoot":"","sources":["../src/health.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAyB1F,IAAI,MAA6B,CAAC;AAClC,IAAI,kBAA0D,CAAC;AAC/D,KAAK,UAAU,SAAS,CAAC,MAAc;IACrC,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,MAAM,OAAO,CAAY,qBAAqB,CAAC,CAAC;IACtE,IAAI,CAAC,kBAAkB;QAAE,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAC;IACxD,IAAI,MAAM,GAAG,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QAC1C,kBAAkB,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,qFAAqF;AACrF,kFAAkF;AAClF,mFAAmF;AACnF,oFAAoF;AACpF,sFAAsF;AACtF,MAAM,cAAc,GAAG,IAAI,UAAU,CAAiB,iBAAiB,CAAC,CAAC;AACzE,MAAM,gBAAgB,GAAG,IAAI,UAAU,CAAiB,iBAAiB,CAAC,CAAC;AAC3E,IAAI,YAAY,GAAG,CAAC,CAAC;AACrB,IAAI,aAAa,GAAG,CAAC,CAAC;AACtB,MAAM,kBAAkB,GAAG,EAAE,GAAG,IAAI,CAAC;AACrC,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAC1C,gFAAgF;AAChF,qFAAqF;AACrF,wEAAwE;AACxE,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU;AAEvD,gFAAgF;AAChF,SAAS,YAAY,CAAC,YAAgC;IACpD,IAAI,CAAC,YAAY;QAAE,OAAO,SAAS,CAAC;IACpC,wCAAwC;IACxC,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACtC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7D,MAAM,CAAC,EAAE,AAAD,EAAG,AAAD,EAAG,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC;IAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,eAAe,MAAM,IAAI,OAAO,IAAI,IAAI,MAAM,CAAC;IAC3F,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,MAAM,CAAC;IACzD,MAAM,MAAM,GAAG,eAAe,MAAM,kBAAkB,OAAO,IAAI,OAAO,EAAE,CAAC;IAC3E,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AAC3D,CAAC;AAED;8EAC8E;AAC9E,KAAK,UAAU,QAAQ,CAAC,MAAc,EAAE,MAAc;IACpD,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,MAAM,OAAO,CAAY,qBAAqB,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,yBAAyB,CAAC;QACjE,QAAQ,EAAE,MAAM;QAChB,cAAc,EAAE,CAAC,6BAA6B,EAAE,+BAA+B,CAAC;KACjF,CAAC,CAAsG,CAAC;IACzG,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,2BAA2B,IAAI,GAAG,CAAC,CAAC;IACrE,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,6BAA6B,IAAI,GAAG,CAAC,CAAC;IACzE,OAAO;QACL,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjC,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC7C,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,iBAAiB,CAAC,MAAc,EAAE,MAAc;IAC7D,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,MAAM,OAAO,CAAY,qBAAqB,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,2BAA2B,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAE1F,CAAC;IACF,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC;AAC/D,CAAC;AAED,KAAK,UAAU,aAAa,CAAC,MAAc,EAAE,MAAc,EAAE,OAAe;IAC1E,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,MAAM,OAAO,CAAY,qBAAqB,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,2BAA2B,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AAC5G,CAAC;AAED;;4EAE4E;AAC5E,KAAK,UAAU,gBAAgB,CAAC,OAAe,EAAE,IAAkF;IACjI,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,YAAY,EAAE,CAAC;QACnC,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,GAAG,OAAO,4BAA4B,EAAE;YACzE,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,eAAe,EAAE,UAAU,KAAK,EAAE,EAAE;YACnF,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SAC3B,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,GAAG,CAAC,IAAI,CAAC,+CAA+C,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;YACrG,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CAAC,qCAAqC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAC3F,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,OAAe,EAAE,YAAgC;IAC5F,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,IAAI,GAAG,GAAG,YAAY,GAAG,kBAAkB;QAAE,OAAO;IACpD,YAAY,GAAG,GAAG,CAAC;IACnB,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;QACrC,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,EAAE,CAAC;YACN,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;gBACjD,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;gBACpB,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;YACpC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,GAAG,CAAC,IAAI,CAAC,kCAAkC,EAAE,EAAE,KAAK,EAAG,GAAyB,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC3G,CAAC;QACH,CAAC;QAED,iFAAiF;QACjF,+EAA+E;QAC/E,sEAAsE;QACtE,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,cAAc,CAAC,IAAI,EAAE,EAAE,GAAG,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAChF,IAAI,OAAO,CAAC,IAAI,KAAK,CAAC;YAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,6CAA6C;QACtF,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,MAAM,SAAS,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC/C,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC9C,MAAM,EAAE,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE;gBACzC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC9B,SAAS;gBACT,OAAO,EAAE,KAAK;gBACd,WAAW;aACZ,CAAC,CAAC;YACH,8EAA8E;YAC9E,uEAAuE;YACvE,IAAI,EAAE;gBAAE,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACrC,CAAC;QAED,IAAI,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,GAAG,GAAG,aAAa,IAAI,mBAAmB,EAAE,CAAC;YACjE,4EAA4E;YAC5E,6EAA6E;YAC7E,IAAI,YAAY,GAAG,uBAAuB,EAAE,CAAC;gBAC3C,GAAG,CAAC,IAAI,CAAC,2FAA2F,EAAE;oBACpG,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,uBAAuB;iBACpF,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC;oBACH,IAAI,CAAC,CAAC,MAAM,iBAAiB,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;wBACnD,aAAa,GAAG,GAAG,CAAC;wBACpB,MAAM,aAAa,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;wBACnD,GAAG,CAAC,IAAI,CAAC,uCAAuC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;oBACxG,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,GAAG,CAAC,IAAI,CAAC,8BAA8B,EAAE,EAAE,KAAK,EAAG,GAAyB,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACvG,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CAAC,sCAAsC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;AACH,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,eAAe,CAAC,MAAyF;IACvH,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;QAC1B,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5D,MAAM,EAAE,GAAG,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,SAAS,CAAC;QACxC,IAAI,EAAE,EAAE,CAAC;YACP,MAAM,IAAI,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACvC,IAAI,CAAC,IAAI,IAAI,EAAE,GAAG,IAAI;gBAAE,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;AACH,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,oBAAoB;IAClC,cAAc,CAAC,KAAK,EAAE,CAAC;IACvB,gBAAgB,CAAC,KAAK,EAAE,CAAC;IACzB,YAAY,GAAG,CAAC,CAAC;IACjB,aAAa,GAAG,CAAC,CAAC;AACpB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { getAuthToken } from './auth.js';\nimport { BoundedMap, CACHE_MAX_ENTRIES, fetchWithTimeout, loadSdk, log } from './util.js';\n\n// Delivery health + self-healing DLQ redrive.\n// After a SUCCESSFUL batch POST we (throttled, best-effort):\n//   1. POST an ingest-health signal to /api/reports/ingest-health so the Reports UI\n//      can show flowing / stale / dropping.\n//   2. If the DLQ is non-empty, no move task is already running, AND the oldest DLQ\n//      message is younger than the poison-age ceiling, kick off an SQS\n//      MessageMoveTask (DLQ → main queue) so retryable failures self-heal without a\n//      new AWS service. The reporting ingest's partial-unique index dedupes any\n//      redelivered event, so a redrive can't double-count.\n// Guards: only on success, one-at-a-time (ListMessageMoveTasks), a poison-age ceiling\n// (so a message that always fails can't loop DLQ→main→DLQ forever), and throttled via\n// module timestamps. NEVER throws — a failure here must not fail the batch.\n//\n// IAM required (document only — granted on the events stack):\n//   sqs:GetQueueAttributes, sqs:ListMessageMoveTasks, sqs:StartMessageMoveTask (on the DLQ)\n\ninterface SqsClientLike { send(command: unknown): Promise<unknown> }\ninterface SqsModule {\n  SQSClient: new (config: { region: string }) => SqsClientLike;\n  GetQueueAttributesCommand: new (input: { QueueUrl: string; AttributeNames: string[] }) => unknown;\n  ListMessageMoveTasksCommand: new (input: { SourceArn: string }) => unknown;\n  StartMessageMoveTaskCommand: new (input: { SourceArn: string; DestinationArn?: string }) => unknown;\n}\nlet sqsMod: SqsModule | undefined;\nlet sqsClientsByRegion: Map<string, SqsClientLike> | undefined;\nasync function sqsClient(region: string): Promise<SqsClientLike> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  if (!sqsClientsByRegion) sqsClientsByRegion = new Map();\n  let client = sqsClientsByRegion.get(region);\n  if (!client) {\n    client = new sqsMod.SQSClient({ region });\n    sqsClientsByRegion.set(region, client);\n  }\n  return client;\n}\n\n// Delivery-health counters are attributed PER RESOLVED ORG (the forwarder is a fleet\n// Lambda serving many orgs; a single global counter would mis-attribute one org's\n// throughput to another). Keyed by orgId ('' bucket = pipeline with no OrgId tag).\n// The DLQ depth (`dropped`) is genuinely fleet-global — one shared DLQ — so it is a\n// single snapshot posted alongside each org's health, documented as the shared depth.\nconst forwardedByOrg = new BoundedMap<string, number>(CACHE_MAX_ENTRIES);\nconst lastEventAtByOrg = new BoundedMap<string, string>(CACHE_MAX_ENTRIES);\nlet lastHealthAt = 0;\nlet lastRedriveAt = 0;\nconst HEALTH_THROTTLE_MS = 60 * 1000;\nconst REDRIVE_THROTTLE_MS = 5 * 60 * 1000;\n// Poison-message ceiling: if the oldest DLQ message is older than this, we STOP\n// redriving it (DLQ→main→fail→DLQ would loop forever). Such messages are left for an\n// alarm / manual inspection instead of churning the fleet indefinitely.\nconst MAX_DLQ_REDRIVE_AGE_SEC = 6 * 60 * 60; // 6 hours\n\n/** Parse the SQS trigger ARN and derive the main + DLQ ARNs and the DLQ URL. */\nfunction deriveQueues(mainQueueArn: string | undefined): { region: string; mainArn: string; dlqArn: string; dlqUrl: string } | undefined {\n  if (!mainQueueArn) return undefined;\n  // arn:aws:sqs:{region}:{account}:{name}\n  const parts = mainQueueArn.split(':');\n  if (parts.length < 6 || parts[2] !== 'sqs') return undefined;\n  const [, , , region, account, name] = parts;\n  const dlqArn = process.env.EVENT_DLQ_ARN || `arn:aws:sqs:${region}:${account}:${name}-dlq`;\n  const dlqName = dlqArn.split(':').pop() ?? `${name}-dlq`;\n  const dlqUrl = `https://sqs.${region}.amazonaws.com/${account}/${dlqName}`;\n  return { region, mainArn: mainQueueArn, dlqArn, dlqUrl };\n}\n\n/** Snapshot the DLQ depth + the age (seconds) of its oldest message (for the\n *  poison-message redrive ceiling). Missing/NaN attributes fall back to 0. */\nasync function dlqStats(region: string, dlqUrl: string): Promise<{ depth: number; oldestAgeSec: number }> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  const out = await client.send(new sqsMod.GetQueueAttributesCommand({\n    QueueUrl: dlqUrl,\n    AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateAgeOfOldestMessage'],\n  })) as { Attributes?: { ApproximateNumberOfMessages?: string; ApproximateAgeOfOldestMessage?: string } };\n  const n = Number(out.Attributes?.ApproximateNumberOfMessages ?? '0');\n  const age = Number(out.Attributes?.ApproximateAgeOfOldestMessage ?? '0');\n  return {\n    depth: Number.isFinite(n) ? n : 0,\n    oldestAgeSec: Number.isFinite(age) ? age : 0,\n  };\n}\n\nasync function hasActiveMoveTask(region: string, dlqArn: string): Promise<boolean> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  const out = await client.send(new sqsMod.ListMessageMoveTasksCommand({ SourceArn: dlqArn })) as {\n    Results?: Array<{ Status?: string }>;\n  };\n  return (out.Results ?? []).some(t => t.Status === 'RUNNING');\n}\n\nasync function startMoveTask(region: string, dlqArn: string, mainArn: string): Promise<void> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  await client.send(new sqsMod.StartMessageMoveTaskCommand({ SourceArn: dlqArn, DestinationArn: mainArn }));\n}\n\n/** POST one org's ingest-health signal. Returns true only on a confirmed 2xx so the\n *  caller resets that org's `forwarded` counter ONLY when the signal was accepted\n *  (a dropped/failed POST must not silently zero the accumulated count). */\nasync function postIngestHealth(baseUrl: string, body: { orgId?: string; forwarded: number; dropped: number; lastEventAt?: string }): Promise<boolean> {\n  try {\n    const token = await getAuthToken();\n    const res = await fetchWithTimeout(`${baseUrl}/api/reports/ingest-health`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },\n      body: JSON.stringify(body),\n    });\n    if (!res.ok) {\n      log.warn('ingest-health POST returned non-2xx (ignored)', { status: res.status, orgId: body.orgId });\n      return false;\n    }\n    return true;\n  } catch (err) {\n    log.warn('ingest-health POST failed (ignored)', { error: String(err), orgId: body.orgId });\n    return false;\n  }\n}\n\n/**\n * Throttled, best-effort post-success work: emit per-org ingest-health and self-heal\n * the DLQ. Never throws. `forwarded`/`lastEventAt` accumulate PER ORG across batches\n * between health posts; `dropped` is the shared fleet DLQ depth snapshot. A per-org\n * counter is zeroed only after that org's health POST is confirmed 2xx.\n */\nexport async function reportHealthAndRedrive(baseUrl: string, mainQueueArn: string | undefined): Promise<void> {\n  const now = Date.now();\n  if (now - lastHealthAt < HEALTH_THROTTLE_MS) return;\n  lastHealthAt = now;\n  try {\n    const q = deriveQueues(mainQueueArn);\n    let depth = 0;\n    let oldestAgeSec = 0;\n    if (q) {\n      try {\n        const stats = await dlqStats(q.region, q.dlqUrl);\n        depth = stats.depth;\n        oldestAgeSec = stats.oldestAgeSec;\n      } catch (err) {\n        log.warn('DLQ stats check failed (ignored)', { error: (err as { name?: string })?.name ?? String(err) });\n      }\n    }\n\n    // Post one health signal per resolved org, attributing its own forwarded count +\n    // last event time. `dropped` (the shared fleet DLQ depth) rides along on each.\n    // Snapshot the keys first so we don't mutate the map while iterating.\n    const orgKeys = new Set([...forwardedByOrg.keys(), ...lastEventAtByOrg.keys()]);\n    if (orgKeys.size === 0) orgKeys.add(''); // nothing forwarded yet → still report depth\n    for (const key of orgKeys) {\n      const forwarded = forwardedByOrg.get(key) ?? 0;\n      const lastEventAt = lastEventAtByOrg.get(key);\n      const ok = await postIngestHealth(baseUrl, {\n        ...(key ? { orgId: key } : {}),\n        forwarded,\n        dropped: depth,\n        lastEventAt,\n      });\n      // Reset the forwarded counter ONLY on a confirmed 2xx — a failed/dropped POST\n      // keeps the count so the next tick re-reports it instead of losing it.\n      if (ok) forwardedByOrg.set(key, 0);\n    }\n\n    if (q && depth > 0 && now - lastRedriveAt >= REDRIVE_THROTTLE_MS) {\n      // Poison-message ceiling: never redrive a DLQ whose oldest message has aged\n      // past the ceiling — that message keeps failing and would loop DLQ→main→DLQ.\n      if (oldestAgeSec > MAX_DLQ_REDRIVE_AGE_SEC) {\n        log.warn('DLQ oldest message exceeds poison-age ceiling — skipping redrive (needs manual attention)', {\n          dlqArn: q.dlqArn, dropped: depth, oldestAgeSec, ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC,\n        });\n      } else {\n        try {\n          if (!(await hasActiveMoveTask(q.region, q.dlqArn))) {\n            lastRedriveAt = now;\n            await startMoveTask(q.region, q.dlqArn, q.mainArn);\n            log.info('Started self-healing DLQ→main redrive', { dlqArn: q.dlqArn, dropped: depth, oldestAgeSec });\n          }\n        } catch (err) {\n          log.warn('DLQ redrive failed (ignored)', { error: (err as { name?: string })?.name ?? String(err) });\n        }\n      }\n    }\n  } catch (err) {\n    log.warn('health/redrive step failed (ignored)', { error: String(err) });\n  }\n}\n\n/** Count a forwarded batch toward each resolved org's delivery-health report. */\nexport function recordForwarded(events: ReadonlyArray<{ orgId: string | null; completedAt?: string; startedAt?: string }>): void {\n  for (const e of events) {\n    const key = e.orgId ?? '';\n    forwardedByOrg.set(key, (forwardedByOrg.get(key) ?? 0) + 1);\n    const at = e.completedAt || e.startedAt;\n    if (at) {\n      const prev = lastEventAtByOrg.get(key);\n      if (!prev || at > prev) lastEventAtByOrg.set(key, at);\n    }\n  }\n}\n\n/** @internal Test-only: forget health counters and throttles. */\nexport function _resetHealthForTests(): void {\n  forwardedByOrg.clear();\n  lastEventAtByOrg.clear();\n  lastHealthAt = 0;\n  lastRedriveAt = 0;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health.js","sourceRoot":"","sources":["../src/health.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { correlationHeaders } from '@pipeline-builder/pipeline-core/lib/core/audit-correlation.js';\nimport { getAuthToken } from './auth.js';\nimport { arnRef, BoundedMap, CACHE_MAX_ENTRIES, fetchWithTimeout, loadSdk, log } from './util.js';\n\n// Delivery health + self-healing DLQ redrive.\n// After a SUCCESSFUL batch POST we (throttled, best-effort):\n//   1. POST an ingest-health signal to /api/reports/ingest-health so the Reports UI\n//      can show flowing / stale / dropping.\n//   2. If the DLQ is non-empty, no move task is already running, AND the oldest DLQ\n//      message is younger than the poison-age ceiling, kick off an SQS\n//      MessageMoveTask (DLQ → main queue) so retryable failures self-heal without a\n//      new AWS service. The reporting ingest's partial-unique index dedupes any\n//      redelivered event, so a redrive can't double-count.\n// Guards: only on success, one-at-a-time (ListMessageMoveTasks), a poison-age ceiling\n// (so a message that always fails can't loop DLQ→main→DLQ forever), and throttled via\n// module timestamps. NEVER throws — a failure here must not fail the batch.\n//\n// IAM required (document only — granted on the events stack):\n//   sqs:GetQueueAttributes, sqs:ListMessageMoveTasks, sqs:StartMessageMoveTask (on the DLQ)\n\ninterface SqsClientLike { send(command: unknown): Promise<unknown> }\ninterface SqsModule {\n  SQSClient: new (config: { region: string }) => SqsClientLike;\n  GetQueueAttributesCommand: new (input: { QueueUrl: string; AttributeNames: string[] }) => unknown;\n  ListMessageMoveTasksCommand: new (input: { SourceArn: string }) => unknown;\n  StartMessageMoveTaskCommand: new (input: { SourceArn: string; DestinationArn?: string }) => unknown;\n}\nlet sqsMod: SqsModule | undefined;\nlet sqsClientsByRegion: Map<string, SqsClientLike> | undefined;\nasync function sqsClient(region: string): Promise<SqsClientLike> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  if (!sqsClientsByRegion) sqsClientsByRegion = new Map();\n  let client = sqsClientsByRegion.get(region);\n  if (!client) {\n    client = new sqsMod.SQSClient({ region });\n    sqsClientsByRegion.set(region, client);\n  }\n  return client;\n}\n\n// Delivery-health counters are attributed PER RESOLVED ORG (the forwarder is a fleet\n// Lambda serving many orgs; a single global counter would mis-attribute one org's\n// throughput to another). Keyed by orgId ('' bucket = pipeline with no OrgId tag).\n// The DLQ depth (`dropped`) is genuinely fleet-global — one shared DLQ — so it is a\n// single snapshot posted alongside each org's health, documented as the shared depth.\nconst forwardedByOrg = new BoundedMap<string, number>(CACHE_MAX_ENTRIES);\nconst lastEventAtByOrg = new BoundedMap<string, string>(CACHE_MAX_ENTRIES);\nlet lastHealthAt = 0;\nlet lastRedriveAt = 0;\nconst HEALTH_THROTTLE_MS = 60 * 1000;\nconst REDRIVE_THROTTLE_MS = 5 * 60 * 1000;\n// Poison-message ceiling: if the oldest DLQ message is older than this, we STOP\n// redriving it (DLQ→main→fail→DLQ would loop forever). Such messages are left for an\n// alarm / manual inspection instead of churning the fleet indefinitely.\nconst MAX_DLQ_REDRIVE_AGE_SEC = 6 * 60 * 60; // 6 hours\n\n/** Parse the SQS trigger ARN and derive the main + DLQ ARNs and the DLQ URL. */\nfunction deriveQueues(mainQueueArn: string | undefined): { region: string; mainArn: string; dlqArn: string; dlqUrl: string } | undefined {\n  if (!mainQueueArn) return undefined;\n  // arn:aws:sqs:{region}:{account}:{name}\n  const parts = mainQueueArn.split(':');\n  if (parts.length < 6 || parts[2] !== 'sqs') return undefined;\n  const [, , , region, account, name] = parts;\n  const dlqArn = process.env.EVENT_DLQ_ARN || `arn:aws:sqs:${region}:${account}:${name}-dlq`;\n  const dlqName = dlqArn.split(':').pop() ?? `${name}-dlq`;\n  const dlqUrl = `https://sqs.${region}.amazonaws.com/${account}/${dlqName}`;\n  return { region, mainArn: mainQueueArn, dlqArn, dlqUrl };\n}\n\n/** Snapshot the DLQ depth + the age (seconds) of its oldest message (for the\n *  poison-message redrive ceiling). Missing/NaN attributes fall back to 0. */\nasync function dlqStats(region: string, dlqUrl: string): Promise<{ depth: number; oldestAgeSec: number }> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  const out = await client.send(new sqsMod.GetQueueAttributesCommand({\n    QueueUrl: dlqUrl,\n    AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateAgeOfOldestMessage'],\n  })) as { Attributes?: { ApproximateNumberOfMessages?: string; ApproximateAgeOfOldestMessage?: string } };\n  const n = Number(out.Attributes?.ApproximateNumberOfMessages ?? '0');\n  const age = Number(out.Attributes?.ApproximateAgeOfOldestMessage ?? '0');\n  return {\n    depth: Number.isFinite(n) ? n : 0,\n    oldestAgeSec: Number.isFinite(age) ? age : 0,\n  };\n}\n\nasync function hasActiveMoveTask(region: string, dlqArn: string): Promise<boolean> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  const out = await client.send(new sqsMod.ListMessageMoveTasksCommand({ SourceArn: dlqArn })) as {\n    Results?: Array<{ Status?: string }>;\n  };\n  return (out.Results ?? []).some(t => t.Status === 'RUNNING');\n}\n\nasync function startMoveTask(region: string, dlqArn: string, mainArn: string): Promise<void> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  await client.send(new sqsMod.StartMessageMoveTaskCommand({ SourceArn: dlqArn, DestinationArn: mainArn }));\n}\n\n/** POST one org's ingest-health signal. Returns true only on a confirmed 2xx so the\n *  caller resets that org's `forwarded` counter ONLY when the signal was accepted\n *  (a dropped/failed POST must not silently zero the accumulated count). */\nasync function postIngestHealth(baseUrl: string, body: { orgId?: string; forwarded: number; dropped: number; lastEventAt?: string }, requestId: string): Promise<boolean> {\n  try {\n    const token = await getAuthToken();\n    const res = await fetchWithTimeout(`${baseUrl}/api/reports/ingest-health`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}`, ...correlationHeaders({ requestId }) },\n      body: JSON.stringify(body),\n    });\n    if (!res.ok) {\n      log.warn('ingest-health POST returned non-2xx (ignored)', { status: res.status, orgId: body.orgId });\n      return false;\n    }\n    return true;\n  } catch (err) {\n    log.warn('ingest-health POST failed (ignored)', { error: String(err), orgId: body.orgId });\n    return false;\n  }\n}\n\n/**\n * Throttled, best-effort post-success work: emit per-org ingest-health and self-heal\n * the DLQ. Never throws. `forwarded`/`lastEventAt` accumulate PER ORG across batches\n * between health posts; `dropped` is the shared fleet DLQ depth snapshot. A per-org\n * counter is zeroed only after that org's health POST is confirmed 2xx. `requestId`\n * is the batch's request id (see index.ts), sent as `X-Request-Id`.\n */\nexport async function reportHealthAndRedrive(baseUrl: string, mainQueueArn: string | undefined, requestId: string): Promise<void> {\n  const now = Date.now();\n  if (now - lastHealthAt < HEALTH_THROTTLE_MS) return;\n  lastHealthAt = now;\n  try {\n    const q = deriveQueues(mainQueueArn);\n    let depth = 0;\n    let oldestAgeSec = 0;\n    if (q) {\n      try {\n        const stats = await dlqStats(q.region, q.dlqUrl);\n        depth = stats.depth;\n        oldestAgeSec = stats.oldestAgeSec;\n      } catch (err) {\n        log.warn('DLQ stats check failed (ignored)', { error: (err as { name?: string })?.name ?? String(err) });\n      }\n    }\n\n    // Post one health signal per resolved org, attributing its own forwarded count +\n    // last event time. `dropped` (the shared fleet DLQ depth) rides along on each.\n    // Snapshot the keys first so we don't mutate the map while iterating.\n    const orgKeys = new Set([...forwardedByOrg.keys(), ...lastEventAtByOrg.keys()]);\n    if (orgKeys.size === 0) orgKeys.add(''); // nothing forwarded yet → still report depth\n    for (const key of orgKeys) {\n      const forwarded = forwardedByOrg.get(key) ?? 0;\n      const lastEventAt = lastEventAtByOrg.get(key);\n      const ok = await postIngestHealth(baseUrl, {\n        ...(key ? { orgId: key } : {}),\n        forwarded,\n        dropped: depth,\n        lastEventAt,\n      }, requestId);\n      // Reset the forwarded counter ONLY on a confirmed 2xx — a failed/dropped POST\n      // keeps the count so the next tick re-reports it instead of losing it.\n      if (ok) forwardedByOrg.set(key, 0);\n    }\n\n    if (q && depth > 0 && now - lastRedriveAt >= REDRIVE_THROTTLE_MS) {\n      // Poison-message ceiling: never redrive a DLQ whose oldest message has aged\n      // past the ceiling — that message keeps failing and would loop DLQ→main→DLQ.\n      if (oldestAgeSec > MAX_DLQ_REDRIVE_AGE_SEC) {\n        log.warn('DLQ oldest message exceeds poison-age ceiling — skipping redrive (needs manual attention)', {\n          dlq: arnRef(q.dlqArn), dropped: depth, oldestAgeSec, ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC,\n        });\n      } else {\n        try {\n          if (!(await hasActiveMoveTask(q.region, q.dlqArn))) {\n            lastRedriveAt = now;\n            await startMoveTask(q.region, q.dlqArn, q.mainArn);\n            log.info('Started self-healing DLQ→main redrive', { dlq: arnRef(q.dlqArn), dropped: depth, oldestAgeSec });\n          }\n        } catch (err) {\n          log.warn('DLQ redrive failed (ignored)', { error: (err as { name?: string })?.name ?? String(err) });\n        }\n      }\n    }\n  } catch (err) {\n    log.warn('health/redrive step failed (ignored)', { error: String(err) });\n  }\n}\n\n/** Count a forwarded batch toward each resolved org's delivery-health report. */\nexport function recordForwarded(events: ReadonlyArray<{ orgId: string | null; completedAt?: string; startedAt?: string }>): void {\n  for (const e of events) {\n    const key = e.orgId ?? '';\n    forwardedByOrg.set(key, (forwardedByOrg.get(key) ?? 0) + 1);\n    const at = e.completedAt || e.startedAt;\n    if (at) {\n      const prev = lastEventAtByOrg.get(key);\n      if (!prev || at > prev) lastEventAtByOrg.set(key, at);\n    }\n  }\n}\n\n/** @internal Test-only: forget health counters and throttles. */\nexport function _resetHealthForTests(): void {\n  forwardedByOrg.clear();\n  lastEventAtByOrg.clear();\n  lastHealthAt = 0;\n  lastRedriveAt = 0;\n}\n"]}

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import type { SQSBatchResponse, SQSEvent } from 'aws-lambda';
+import type { Context, SQSBatchResponse, SQSEvent } from 'aws-lambda';
 /**
  * Pipeline event ingestion Lambda handler.
  *
@@ -24,4 +24,4 @@ import type { SQSBatchResponse, SQSEvent } from 'aws-lambda';
  *   self-healing redrive; defaults to `<main-queue-arn>-dlq` derived from the SQS
  *   trigger's eventSourceARN.
  */
-export declare const handler: (event: SQSEvent) => Promise<SQSBatchResponse>;
+export declare const handler: (event: SQSEvent, context?: Pick<Context, 'awsRequestId'>) => Promise<SQSBatchResponse>;

package/lib/index.js

@@ -1,3 +1,31 @@
+// src/index.ts
+import { randomUUID } from "node:crypto";
+
+// ../pipeline-core/lib/core/audit-correlation.js
+var REQUEST_ID_HEADER = "X-Request-Id";
+var PIPELINE_EXECUTION_ID_HEADER = "X-Pipeline-Execution-Id";
+var CODEBUILD_BUILD_ID_HEADER = "X-CodeBuild-Build-Id";
+var MAX_CORRELATION_VALUE = 128;
+function sanitizeCorrelationValue(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const clean = value.replace(/[^\x21-\x7e]/g, "").slice(0, MAX_CORRELATION_VALUE);
+  return clean.length > 0 ? clean : void 0;
+}
+function correlationHeaders(ids) {
+  const headers = {};
+  const requestId = sanitizeCorrelationValue(ids.requestId);
+  const executionId = sanitizeCorrelationValue(ids.pipelineExecutionId);
+  const buildId = sanitizeCorrelationValue(ids.codeBuildBuildId);
+  if (requestId)
+    headers[REQUEST_ID_HEADER] = requestId;
+  if (executionId)
+    headers[PIPELINE_EXECUTION_ID_HEADER] = executionId;
+  if (buildId)
+    headers[CODEBUILD_BUILD_ID_HEADER] = buildId;
+  return headers;
+}
+
 // ../pipeline-core/lib/handlers/platform-credential.js
 import { GetSecretValueCommand, SecretsManagerClient } from "@aws-sdk/client-secrets-manager";
 var ACCESS_KEY_PREFIXES = ["pb_sa_", "pb_pat_"];
@@ -7,8 +35,8 @@ function assertAccessKey(value, source) {
   const looksLikeJwt = value.split(".").length === 3;
   throw new Error(`${source} does not hold an opaque access key (expected a "pb_sa_\u2026" value)` + (looksLikeJwt ? ' \u2014 it holds a JWT, not a service-account key. Re-run "pipeline-manager infra store-token" to issue one.' : "."));
 }
-async function readCredentialSecret(secretName, client = new SecretsManagerClient({})) {
-  const response = await client.send(new GetSecretValueCommand({ SecretId: secretName }));
+async function readCredentialSecret(secretName, client2 = new SecretsManagerClient({})) {
+  const response = await client2.send(new GetSecretValueCommand({ SecretId: secretName }));
   if (!response.SecretString)
     throw new Error(`Secret "${secretName}" is empty`);
   return JSON.parse(response.SecretString);
@@ -56,6 +84,7 @@ function createPlatformCredential(opts) {
 }
 
 // src/util.ts
+import { createHash } from "node:crypto";
 var log = {
   info: (msg, data) => console.log(JSON.stringify({ level: "INFO", message: msg, data, ts: (/* @__PURE__ */ new Date()).toISOString() })),
   warn: (msg, data) => console.log(JSON.stringify({ level: "WARN", message: msg, data, ts: (/* @__PURE__ */ new Date()).toISOString() })),
@@ -77,6 +106,9 @@ var BoundedMap = class extends Map {
     return super.set(key, value);
   }
 };
+function arnRef(arn) {
+  return `arn#${createHash("sha256").update(arn).digest("hex").slice(0, 12)}`;
+}
 var CACHE_MAX_ENTRIES = 5e3;
 async function loadSdk(pkg) {
   return await import(pkg);
@@ -140,12 +172,12 @@ var sqsClientsByRegion;
 async function sqsClient(region) {
   if (!sqsMod) sqsMod = await loadSdk("@aws-sdk/client-sqs");
   if (!sqsClientsByRegion) sqsClientsByRegion = /* @__PURE__ */ new Map();
-  let client = sqsClientsByRegion.get(region);
-  if (!client) {
-    client = new sqsMod.SQSClient({ region });
-    sqsClientsByRegion.set(region, client);
+  let client2 = sqsClientsByRegion.get(region);
+  if (!client2) {
+    client2 = new sqsMod.SQSClient({ region });
+    sqsClientsByRegion.set(region, client2);
   }
-  return client;
+  return client2;
 }
 var forwardedByOrg = new BoundedMap(CACHE_MAX_ENTRIES);
 var lastEventAtByOrg = new BoundedMap(CACHE_MAX_ENTRIES);
@@ -166,8 +198,8 @@ function deriveQueues(mainQueueArn) {
 }
 async function dlqStats(region, dlqUrl) {
   if (!sqsMod) sqsMod = await loadSdk("@aws-sdk/client-sqs");
-  const client = await sqsClient(region);
-  const out = await client.send(new sqsMod.GetQueueAttributesCommand({
+  const client2 = await sqsClient(region);
+  const out = await client2.send(new sqsMod.GetQueueAttributesCommand({
     QueueUrl: dlqUrl,
     AttributeNames: ["ApproximateNumberOfMessages", "ApproximateAgeOfOldestMessage"]
   }));
@@ -180,21 +212,21 @@ async function dlqStats(region, dlqUrl) {
 }
 async function hasActiveMoveTask(region, dlqArn) {
   if (!sqsMod) sqsMod = await loadSdk("@aws-sdk/client-sqs");
-  const client = await sqsClient(region);
-  const out = await client.send(new sqsMod.ListMessageMoveTasksCommand({ SourceArn: dlqArn }));
+  const client2 = await sqsClient(region);
+  const out = await client2.send(new sqsMod.ListMessageMoveTasksCommand({ SourceArn: dlqArn }));
   return (out.Results ?? []).some((t) => t.Status === "RUNNING");
 }
 async function startMoveTask(region, dlqArn, mainArn) {
   if (!sqsMod) sqsMod = await loadSdk("@aws-sdk/client-sqs");
-  const client = await sqsClient(region);
-  await client.send(new sqsMod.StartMessageMoveTaskCommand({ SourceArn: dlqArn, DestinationArn: mainArn }));
+  const client2 = await sqsClient(region);
+  await client2.send(new sqsMod.StartMessageMoveTaskCommand({ SourceArn: dlqArn, DestinationArn: mainArn }));
 }
-async function postIngestHealth(baseUrl, body) {
+async function postIngestHealth(baseUrl, body, requestId) {
   try {
     const token = await getAuthToken();
     const res = await fetchWithTimeout(`${baseUrl}/api/reports/ingest-health`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}`, ...correlationHeaders({ requestId }) },
       body: JSON.stringify(body)
     });
     if (!res.ok) {
@@ -207,7 +239,7 @@ async function postIngestHealth(baseUrl, body) {
     return false;
   }
 }
-async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
+async function reportHealthAndRedrive(baseUrl, mainQueueArn, requestId) {
   const now = Date.now();
   if (now - lastHealthAt < HEALTH_THROTTLE_MS) return;
   lastHealthAt = now;
@@ -234,13 +266,13 @@ async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
         forwarded,
         dropped: depth,
         lastEventAt
-      });
+      }, requestId);
       if (ok) forwardedByOrg.set(key, 0);
     }
     if (q && depth > 0 && now - lastRedriveAt >= REDRIVE_THROTTLE_MS) {
       if (oldestAgeSec > MAX_DLQ_REDRIVE_AGE_SEC) {
         log.warn("DLQ oldest message exceeds poison-age ceiling \u2014 skipping redrive (needs manual attention)", {
-          dlqArn: q.dlqArn,
+          dlq: arnRef(q.dlqArn),
           dropped: depth,
           oldestAgeSec,
           ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC
@@ -250,7 +282,7 @@ async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
           if (!await hasActiveMoveTask(q.region, q.dlqArn)) {
             lastRedriveAt = now;
             await startMoveTask(q.region, q.dlqArn, q.mainArn);
-            log.info("Started self-healing DLQ\u2192main redrive", { dlqArn: q.dlqArn, dropped: depth, oldestAgeSec });
+            log.info("Started self-healing DLQ\u2192main redrive", { dlq: arnRef(q.dlqArn), dropped: depth, oldestAgeSec });
           }
         } catch (err) {
           log.warn("DLQ redrive failed (ignored)", { error: err?.name ?? String(err) });
@@ -279,6 +311,105 @@ function _resetHealthForTests() {
   lastRedriveAt = 0;
 }
 
+// ../pipeline-core/lib/core/synth-failure.js
+var SYNTH_FAILURE_MARKER = "PB_SYNTH_FAILURE";
+var MAX_MESSAGE = 1e3;
+var MAX_PLUGINS = 10;
+var MAX_PLUGIN_MESSAGE = 300;
+var clip = (s, max) => s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+function synthFailure(message, plugins = []) {
+  const codes = [...new Set(plugins.map((p) => p.code))];
+  const code = plugins.length === 0 ? "SYNTH_FAILED" : codes.length === 1 ? codes[0] : "PLUGINS_REFUSED";
+  return {
+    code,
+    message: clip(message, MAX_MESSAGE),
+    plugins: plugins.slice(0, MAX_PLUGINS).map((p) => ({
+      plugin: clip(p.plugin, 100),
+      code: clip(p.code, 100),
+      message: clip(p.message, MAX_PLUGIN_MESSAGE)
+    }))
+  };
+}
+function parseSynthFailure(line) {
+  const at = line.indexOf(`${SYNTH_FAILURE_MARKER} {`);
+  if (at === -1)
+    return null;
+  try {
+    const parsed = JSON.parse(line.slice(at + SYNTH_FAILURE_MARKER.length + 1).trim());
+    if (typeof parsed.code !== "string" || typeof parsed.message !== "string")
+      return null;
+    const plugins = Array.isArray(parsed.plugins) ? parsed.plugins.filter((p) => !!p && typeof p.plugin === "string" && typeof p.code === "string" && typeof p.message === "string") : [];
+    return { ...synthFailure(parsed.message, plugins), code: clip(parsed.code, 100) };
+  } catch {
+    return null;
+  }
+}
+
+// src/failure-reason.ts
+var loader = loadSdk;
+var clients = /* @__PURE__ */ new Map();
+async function client(kind, region) {
+  const mod = kind === "codebuild" ? await loader("@aws-sdk/client-codebuild") : await loader("@aws-sdk/client-cloudwatch-logs");
+  const key = `${kind}:${region}`;
+  let c = clients.get(key);
+  if (!c) {
+    c = kind === "codebuild" ? new mod.CodeBuildClient({ region }) : new mod.CloudWatchLogsClient({ region });
+    clients.set(key, c);
+  }
+  return { client: c, mod };
+}
+var BUILD_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{1,254}:[0-9a-f-]{36}$/;
+function codeBuildIdOf(detail) {
+  const type = detail.type;
+  if (type?.provider !== void 0 && type.provider !== "CodeBuild") return null;
+  const result = detail["execution-result"];
+  const id = result?.["external-execution-id"];
+  return typeof id === "string" && BUILD_ID_RE.test(id) ? id : null;
+}
+async function readBuildCompute(region, buildId) {
+  try {
+    const cb = await client("codebuild", region);
+    const out = await cb.client.send(
+      new cb.mod.BatchGetBuildsCommand({ ids: [buildId] })
+    );
+    return out.builds?.[0]?.environment?.computeType ?? null;
+  } catch (err) {
+    log.warn("Could not read the build's compute size (forwarding without it)", {
+      buildId,
+      error: String(err)
+    });
+    return null;
+  }
+}
+async function readSynthFailure(region, buildId) {
+  try {
+    const cb = await client("codebuild", region);
+    const out = await cb.client.send(
+      new cb.mod.BatchGetBuildsCommand({ ids: [buildId] })
+    );
+    const logs = out.builds?.[0]?.logs;
+    if (!logs?.groupName || !logs.streamName) return null;
+    const cw = await client("logs", region);
+    const res = await cw.client.send(new cw.mod.FilterLogEventsCommand({
+      logGroupName: logs.groupName,
+      logStreamNames: [logs.streamName],
+      filterPattern: `"${SYNTH_FAILURE_MARKER}"`,
+      limit: 5
+    }));
+    for (const event of res.events ?? []) {
+      const failure = typeof event.message === "string" ? parseSynthFailure(event.message) : null;
+      if (failure) return failure;
+    }
+    return null;
+  } catch (err) {
+    log.warn("Could not read the failed build's structured failure reason (forwarding without it)", {
+      buildId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+
 // src/scm.ts
 import { GetSecretValueCommand as GetSecretValueCommand2, SecretsManagerClient as SecretsManagerClient2 } from "@aws-sdk/client-secrets-manager";
 var commitResultCache = new BoundedMap(CACHE_MAX_ENTRIES);
@@ -312,8 +443,8 @@ async function getGitHubToken(orgId) {
   }
   let token;
   try {
-    const client = new SecretsManagerClient2({});
-    const res = await client.send(new GetSecretValueCommand2({ SecretId: secretName }));
+    const client2 = new SecretsManagerClient2({});
+    const res = await client2.send(new GetSecretValueCommand2({ SecretId: secretName }));
     token = res.SecretString && res.SecretString.length > 0 ? res.SecretString.trim() : null;
   } catch (err) {
     log.warn("No github-token secret \u2014 GitHub commit resolution will be unauthenticated", { orgId, error: err?.name });
@@ -358,19 +489,19 @@ var codecommitMod;
 async function codeCommitClient(region) {
   if (!codecommitMod) codecommitMod = await loadSdk("@aws-sdk/client-codecommit");
   if (!codecommitClientsByRegion) codecommitClientsByRegion = /* @__PURE__ */ new Map();
-  let client = codecommitClientsByRegion.get(region);
-  if (!client) {
-    client = new codecommitMod.CodeCommitClient({ region });
-    codecommitClientsByRegion.set(region, client);
+  let client2 = codecommitClientsByRegion.get(region);
+  if (!client2) {
+    client2 = new codecommitMod.CodeCommitClient({ region });
+    codecommitClientsByRegion.set(region, client2);
   }
-  return client;
+  return client2;
 }
 async function codeCommitMeta(region, repositoryName, commitId) {
   const cached = commitMetaCache.get(commitId);
   if (cached) return cached;
   if (!codecommitMod) codecommitMod = await loadSdk("@aws-sdk/client-codecommit");
-  const client = await codeCommitClient(region);
-  const out = await client.send(new codecommitMod.GetCommitCommand({ repositoryName, commitId }));
+  const client2 = await codeCommitClient(region);
+  const out = await client2.send(new codecommitMod.GetCommitCommand({ repositoryName, commitId }));
   const commit = out.commit;
   const meta = { date: toIso(commit?.committer?.date ?? commit?.author?.date), parents: commit?.parents };
   commitMetaCache.set(commitId, meta);
@@ -538,13 +669,13 @@ function parseDeploys(value) {
   return map;
 }
 async function pipelineClient(region) {
-  let client = clientsByRegion.get(region);
-  if (!client) {
+  let client2 = clientsByRegion.get(region);
+  if (!client2) {
     const { CodePipelineClient } = await loadCodePipeline();
-    client = new CodePipelineClient({ region });
-    clientsByRegion.set(region, client);
+    client2 = new CodePipelineClient({ region });
+    clientsByRegion.set(region, client2);
   }
-  return client;
+  return client2;
 }
 async function resolvePipeline(arn, region) {
   const cached = resolvedByArn.get(arn);
@@ -552,29 +683,29 @@ async function resolvePipeline(arn, region) {
     return { pipelineId: cached.pipelineId, orgId: cached.orgId, deploys: cached.deploys };
   }
   try {
-    const client = await pipelineClient(region);
+    const client2 = await pipelineClient(region);
     const { ListTagsForResourceCommand } = await loadCodePipeline();
-    const out = await client.send(new ListTagsForResourceCommand({ resourceArn: arn }));
+    const out = await client2.send(new ListTagsForResourceCommand({ resourceArn: arn }));
     const pipelineId = out.tags?.find((t) => t.key === PIPELINE_ID_TAG)?.value ?? null;
     const orgId = out.tags?.find((t) => t.key === ORG_ID_TAG)?.value ?? null;
     const deploys = parseDeploys(out.tags?.find((t) => t.key === DEPLOYS_TAG)?.value);
-    if (!pipelineId) log.warn("Pipeline missing pb.pipeline-id tag \u2014 skipping (register it?)", { arn });
+    if (!pipelineId) log.warn("Pipeline missing pb.pipeline-id tag \u2014 skipping (register it?)", { pipeline: arnRef(arn) });
     resolvedByArn.set(arn, { pipelineId, orgId, deploys, ts: Date.now() });
     return { pipelineId, orgId, deploys };
   } catch (err) {
     const name = err?.name;
     if (name === "AccessDeniedException") {
-      log.error("AccessDenied calling codepipeline:ListTagsForResource \u2014 grant it to the Lambda role", { arn, error: name });
+      log.error("AccessDenied calling codepipeline:ListTagsForResource \u2014 grant it to the Lambda role", { pipeline: arnRef(arn), error: name });
       throw err;
     }
     const e = err;
     const status = e.$metadata?.httpStatusCode;
     const retryable = e.$retryable != null || typeof status === "number" && status >= 500 || /throttl|timeout|toomanyrequests|serviceunavailable|econnreset|networkingerror/i.test(name ?? "");
     if (retryable) {
-      log.error("Transient error resolving pb.pipeline-id tag \u2014 will retry the batch", { arn, error: name ?? String(err) });
+      log.error("Transient error resolving pb.pipeline-id tag \u2014 will retry the batch", { pipeline: arnRef(arn), error: name ?? String(err) });
       throw err;
     }
-    log.error("Failed to resolve pb.pipeline-id tag", { arn, error: name ?? String(err) });
+    log.error("Failed to resolve pb.pipeline-id tag", { pipeline: arnRef(arn), error: name ?? String(err) });
     return { pipelineId: null, orgId: null, deploys: /* @__PURE__ */ new Map() };
   }
 }
@@ -583,7 +714,12 @@ function _resetTagsForTests() {
 }
 
 // src/parse.ts
+var MAX_SOURCE_ID = 128;
+function sourceId(v) {
+  return typeof v === "string" && v.length > 0 ? v.slice(0, MAX_SOURCE_ID) : void 0;
+}
 var MAX_ERROR_MESSAGE = 4e3;
+var MAX_DETAIL_BYTES = 7500;
 function firstAttr(...vals) {
   for (const v of vals) {
     if (typeof v === "string" && v.length > 0) return v.slice(0, MAX_ATTR);
@@ -654,7 +790,25 @@ async function parseRecord(record) {
   }
   const result = detail["execution-result"];
   const summary = result?.["external-execution-summary"];
-  const errorMessage = typeof summary === "string" && summary.length > 0 ? summary.slice(0, MAX_ERROR_MESSAGE) : void 0;
+  let errorMessage = typeof summary === "string" && summary.length > 0 ? summary.slice(0, MAX_ERROR_MESSAGE) : void 0;
+  let computeType;
+  if (eventType === "ACTION" && ["SUCCEEDED", "FAILED", "STOPPED"].includes(state)) {
+    const cbId = codeBuildIdOf(detail);
+    computeType = (cbId ? await readBuildCompute(event.region, cbId) : null) ?? void 0;
+  }
+  if (eventType === "ACTION" && state === "FAILED") {
+    const buildId = codeBuildIdOf(detail);
+    const failure = buildId ? await readSynthFailure(event.region, buildId) : null;
+    if (failure) {
+      detail.pbFailure = failure;
+      if (JSON.stringify(detail).length >= MAX_DETAIL_BYTES) {
+        detail.pbFailure = { ...failure, plugins: failure.plugins.map(({ plugin, code }) => ({ plugin, code })) };
+      }
+      errorMessage = `${failure.code}: ${failure.message}`.slice(0, MAX_ERROR_MESSAGE);
+    }
+  }
+  const sourceEventId = sourceId(event.id);
+  const sourceMessageId = sourceId(record.messageId);
   const { commitSha, commitRef, revisionUrl } = extractCommit(detail);
   const executionId = detail["execution-id"];
   const stageName = detail.stage;
@@ -686,14 +840,18 @@ async function parseRecord(record) {
     ...commitTimestamp && { commitTimestamp },
     ...commitCount && { commitCount },
     ...environment && { environment },
+    ...computeType && { computeType },
+    ...sourceEventId && { sourceEventId },
+    ...sourceMessageId && { sourceMessageId },
     detail
   };
 }
 
 // src/index.ts
-var handler = async (event) => {
+var handler = async (event, context) => {
   const baseUrl = process.env.PLATFORM_BASE_URL;
   if (!baseUrl) throw new Error("PLATFORM_BASE_URL environment variable is required");
+  const requestId = context?.awsRequestId || randomUUID();
   const settled = await Promise.all(event.Records.map(async (record) => {
     try {
       return { record, parsed: await parseRecord(record) };
@@ -715,7 +873,7 @@ var handler = async (event) => {
   const payloadEvents = events.map(({ orgId: _orgId, ...rest }) => rest);
   const post = (token) => fetchWithTimeout(`${baseUrl}/api/reports/events`, {
     method: "POST",
-    headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+    headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}`, ...correlationHeaders({ requestId }) },
     body: JSON.stringify({ events: payloadEvents })
   });
   let res = await post(await getAuthToken());
@@ -735,7 +893,7 @@ var handler = async (event) => {
   const result = await res.json().catch(() => ({}));
   log.info(`Ingested ${events.length} events`, { inserted: result.data });
   recordForwarded(events);
-  await reportHealthAndRedrive(baseUrl, event.Records[0]?.eventSourceARN);
+  await reportHealthAndRedrive(baseUrl, event.Records[0]?.eventSourceARN, requestId);
   return batchResponse(failures);
 };
 function batchResponse(failed) {

package/lib/parse.d.ts

@@ -31,9 +31,27 @@ export interface ParsedEvent {
     commitTimestamp?: string;
     /** Number of commits in the resolved range (≥1). Undefined when unresolvable. */
     commitCount?: number;
+    /**
+     * The compute size a terminal CodeBuild action ran on (`SMALL` … `X2_LARGE`),
+     * read from AWS. Undefined for a non-CodeBuild action, a non-terminal event,
+     * or when the read failed — the ingest then records the action as UNMEASURED
+     * rather than as free, which is what makes the coverage gap visible instead of
+     * looking like idleness.
+     *
+     * Its own field rather than a `detail` key, for the reason `failure` has one:
+     * `detail` is bounded at 8 KB and already sheds content under that bound, so a
+     * one-word field riding inside it is a field that can be dropped by an
+     * unrelated payload getting large.
+     */
+    computeType?: string;
     /** Deploy environment — set only when the event's stage is listed in the
      *  pipeline's `pb.deploys` tag. Undefined otherwise (⇒ not a deploy). */
     environment?: string;
+    /** The EventBridge event `id` (≤128) — lets the server's audit trail name the
+     *  exact AWS event a row came from. Undefined when the body carries none. */
+    sourceEventId?: string;
+    /** The SQS record's messageId (≤128) — the delivery that carried the event. */
+    sourceMessageId?: string;
     detail: Record<string, unknown>;
 }
 /** Parse + resolve one record to a reportable event, or null to skip it. */

package/lib/parse.js

@@ -1,10 +1,19 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { codeBuildIdOf, readBuildCompute, readSynthFailure } from './failure-reason.js';
 import { classifySource, resolveCommitInfo } from './scm.js';
 import { MAX_ATTR, resolvePipeline } from './tags.js';
 import { log } from './util.js';
+/** Cap on `sourceEventId` / `sourceMessageId` — the reporting ingest's max. */
+const MAX_SOURCE_ID = 128;
+/** A non-empty string capped to `MAX_SOURCE_ID`, else undefined. */
+function sourceId(v) {
+    return typeof v === 'string' && v.length > 0 ? v.slice(0, MAX_SOURCE_ID) : undefined;
+}
 /** Cap on the stored failure summary — CodeBuild/Deploy summaries can be long. */
 const MAX_ERROR_MESSAGE = 4000;
+/** Headroom under the reporting ingest's 8 KB serialized `detail` bound. */
+const MAX_DETAIL_BYTES = 7500;
 /** First non-empty string among the candidates, capped to the ingest max. */
 function firstAttr(...vals) {
     for (const v of vals) {
@@ -110,9 +119,40 @@ export async function parseRecord(record) {
     // under `execution-result`.
     const result = detail['execution-result'];
     const summary = result?.['external-execution-summary'];
-    const errorMessage = typeof summary === 'string' && summary.length > 0
+    let errorMessage = typeof summary === 'string' && summary.length > 0
         ? summary.slice(0, MAX_ERROR_MESSAGE)
         : undefined;
+    // A failed CodeBuild action may have printed a structured reason (the synth's
+    // `PB_SYNTH_FAILURE` line — a refused plugin, with its code). CodeBuild's
+    // summary never carries the build output, so read it from the build's log and
+    // promote it: the code + message become the failure reason, the per-plugin
+    // list rides in `detail.pbFailure`. Best-effort (see failure-reason.ts).
+    // The compute size this action ran on, for the vCPU-minute figure Phase 4
+    // measures. Only on a TERMINAL CodeBuild action: an in-progress event has no
+    // duration to pair it with, so reading it there would spend an AWS call to
+    // learn nothing. Best-effort — null forwards without the field.
+    let computeType;
+    if (eventType === 'ACTION' && ['SUCCEEDED', 'FAILED', 'STOPPED'].includes(state)) {
+        const cbId = codeBuildIdOf(detail);
+        computeType = (cbId ? await readBuildCompute(event.region, cbId) : null) ?? undefined;
+    }
+    if (eventType === 'ACTION' && state === 'FAILED') {
+        const buildId = codeBuildIdOf(detail);
+        const failure = buildId ? await readSynthFailure(event.region, buildId) : null;
+        if (failure) {
+            detail.pbFailure = failure;
+            // The ingest bounds `detail` at 8 KB serialized; keep the codes, drop the
+            // per-plugin prose if the whole thing would not fit.
+            if (JSON.stringify(detail).length >= MAX_DETAIL_BYTES) {
+                detail.pbFailure = { ...failure, plugins: failure.plugins.map(({ plugin, code }) => ({ plugin, code })) };
+            }
+            errorMessage = `${failure.code}: ${failure.message}`.slice(0, MAX_ERROR_MESSAGE);
+        }
+    }
+    // Audit correlation back to the AWS side: which EventBridge event, carried by
+    // which SQS delivery. Both are opaque ids (no ARN, no account).
+    const sourceEventId = sourceId(event.id);
+    const sourceMessageId = sourceId(record.messageId);
     // DORA deploy attribution — all optional: omitted (undefined) when the
     // event/pipeline doesn't carry them.
     const { commitSha, commitRef, revisionUrl } = extractCommit(detail);
@@ -153,7 +193,10 @@ export async function parseRecord(record) {
         ...(commitTimestamp && { commitTimestamp }),
         ...(commitCount && { commitCount }),
         ...(environment && { environment }),
+        ...(computeType && { computeType }),
+        ...(sourceEventId && { sourceEventId }),
+        ...(sourceMessageId && { sourceMessageId }),
         detail,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse.js","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { SQSRecord } from 'aws-lambda';\nimport { classifySource, resolveCommitInfo } from './scm.js';\nimport { MAX_ATTR, resolvePipeline } from './tags.js';\nimport { log } from './util.js';\n\n// Event parsing: an SQS record → the normalized reporting event.\n\nexport interface ParsedEvent {\n  /**\n   * Resolved platform orgId (from the pipeline's OrgId tag; null when untagged).\n   * INTERNAL — used only to key the per-org GitHub token and to attribute\n   * ingest-health. Stripped from the payload POSTed to /reports/events (which\n   * resolves org from the pipeline registry, not the body).\n   */\n  orgId: string | null;\n  pipelineId: string;\n  eventSource: string;\n  eventType: string;\n  status: string;\n  executionId?: string;\n  stageName?: string;\n  actionName?: string;\n  /** Human-readable failure reason, from an Action event's\n   *  `execution-result.external-execution-summary`. The log URL + error-code\n   *  stay in `detail` for drill-down. */\n  errorMessage?: string;\n  startedAt?: string;\n  completedAt?: string;\n  durationMs?: number;\n  /** Source commit id (DORA deploy attribution). Undefined when the event\n   *  carries no source revision — stored NULL downstream. */\n  commitSha?: string;\n  /** Source branch/ref (DORA deploy attribution). Undefined when unavailable. */\n  commitRef?: string;\n  /** Oldest-unshipped commit timestamp (ISO 8601) for the range since the last\n   *  deploy — resolved in-account. Undefined when unresolvable. */\n  commitTimestamp?: string;\n  /** Number of commits in the resolved range (≥1). Undefined when unresolvable. */\n  commitCount?: number;\n  /** Deploy environment — set only when the event's stage is listed in the\n   *  pipeline's `pb.deploys` tag. Undefined otherwise (⇒ not a deploy). */\n  environment?: string;\n  detail: Record<string, unknown>;\n}\n\n/** Cap on the stored failure summary — CodeBuild/Deploy summaries can be long. */\nconst MAX_ERROR_MESSAGE = 4000;\n\n/** First non-empty string among the candidates, capped to the ingest max. */\nfunction firstAttr(...vals: unknown[]): string | undefined {\n  for (const v of vals) {\n    if (typeof v === 'string' && v.length > 0) return v.slice(0, MAX_ATTR);\n  }\n  return undefined;\n}\n\n/**\n * Best-effort extraction of the source commit id + ref (and the revision URL, used\n * only in-account to classify the source type for commit-range resolution) from a\n * CodePipeline event detail. CodePipeline surfaces the source revision under a few\n * shapes depending on the event type / source-action; we check the known ones and\n * leave the fields undefined when none are present (NULL downstream). Never pulls an\n * ARN/account id: only revision/branch/url string fields are read; the revisionUrl\n * is consumed in-account (source classification) and never forwarded on its own.\n */\nfunction extractCommit(detail: Record<string, unknown>): { commitSha?: string; commitRef?: string; revisionUrl?: string } {\n  // `source-revisions` (kebab, EventBridge) / `sourceRevisions` (camel) — first entry.\n  const revs = (detail['source-revisions'] ?? detail.sourceRevisions) as\n    | Array<Record<string, unknown>> | undefined;\n  const firstRev = Array.isArray(revs) ? revs[0] : undefined;\n  // On source actions the revision id can also ride on `execution-result`.\n  const execResult = detail['execution-result'] as Record<string, unknown> | undefined;\n\n  const commitSha = firstAttr(\n    detail.commitId,\n    detail.revisionId,\n    firstRev?.revisionId,\n    execResult?.revisionId,\n  );\n  const commitRef = firstAttr(\n    detail.commitRef,\n    detail.branch,\n    detail.sourceBranch,\n    firstRev?.branchName,\n    firstRev?.branch,\n  );\n  const revisionUrl = typeof firstRev?.revisionUrl === 'string' ? firstRev.revisionUrl : undefined;\n\n  return { ...(commitSha && { commitSha }), ...(commitRef && { commitRef }), ...(revisionUrl && { revisionUrl }) };\n}\n\nfunction classifyEvent(detailType: string): { eventType: string; eventSource: string } {\n  if (detailType.includes('Pipeline Execution')) return { eventType: 'PIPELINE', eventSource: 'codepipeline' };\n  if (detailType.includes('Stage Execution')) return { eventType: 'STAGE', eventSource: 'codepipeline' };\n  if (detailType.includes('Action Execution')) return { eventType: 'ACTION', eventSource: 'codepipeline' };\n  // CodeBuild \"Build State\" events identify a build *project*, not a pipeline, so\n  // parseRecord drops them on the `eventSource !== 'codepipeline'` check below —\n  // the 'BUILD' eventType is never persisted here (plugin BUILD events are\n  // recorded directly by the plugin service). The 'codebuild' source is what\n  // routes the drop; keep this branch only for that.\n  if (detailType.includes('Build State')) return { eventType: 'BUILD', eventSource: 'codebuild' };\n  return { eventType: 'PIPELINE', eventSource: 'codepipeline' };\n}\n\n/** Parse + resolve one record to a reportable event, or null to skip it. */\nexport async function parseRecord(record: SQSRecord): Promise<ParsedEvent | null> {\n  let event: {\n    'detail-type': string;\n    'source': string;\n    'detail': Record<string, unknown>;\n    'time': string;\n    'region': string;\n    'account': string;\n  };\n  // A malformed body is a dead message (retrying won't help) — log + skip it so\n  // it can't fail the whole batch. Resolution errors below (e.g. AccessDenied)\n  // are NOT caught here: those are transient/infra and must propagate to retry.\n  try {\n    event = JSON.parse(record.body);\n  } catch (err) {\n    log.warn('Skipping SQS record with unparseable body', { messageId: record.messageId, error: String(err) });\n    return null;\n  }\n\n  const { eventType, eventSource } = classifyEvent(event['detail-type']);\n  const detail = { ...event.detail };\n  // The raw account never needs to leave AWS now — drop it from the payload.\n  delete detail.account;\n\n  // CodeBuild \"Build State\" events identify a build *project*, not a pipeline,\n  // and a project can be shared across pipelines — there's no clean 1:1 mapping\n  // to a pipeline id, so skip them.\n  if (eventSource !== 'codepipeline') {\n    log.warn('Skipping non-CodePipeline event (no pipeline tag to resolve)', { detailType: event['detail-type'] });\n    return null;\n  }\n\n  const pipelineName = detail.pipeline as string | undefined;\n  if (!pipelineName) {\n    log.warn('CodePipeline event missing pipeline name — skipping');\n    return null;\n  }\n\n  // Resolve the pipeline's pb.pipeline-id (= platform pipelineId) + pb.deploys map.\n  // The ARN is only a transient handle for the tag lookup; it is never stored.\n  const arn = `arn:aws:codepipeline:${event.region}:${event.account}:${pipelineName}`;\n  const { pipelineId, orgId, deploys } = await resolvePipeline(arn, event.region);\n  if (!pipelineId) return null; // untagged / unregistered → skip\n\n  // AWS does not always send `start-time`. `event.time` stands in for it so the\n  // row still lands in the report windows, which filter on `started_at` — but it\n  // is NOT a measurement, and the duration below must not be computed from it.\n  const declaredStart = detail['start-time'] as string | undefined;\n  const startedAt = declaredStart || event.time;\n  const state = detail.state as string;\n\n  let durationMs: number | undefined;\n  let completedAt: string | undefined;\n\n  if (['SUCCEEDED', 'FAILED', 'CANCELED', 'STOPPED'].includes(state)) {\n    completedAt = event.time;\n    // ONLY from a start AWS actually declared. With the fallback, `startedAt` and\n    // `completedAt` are both `event.time` on a terminal event, so the duration came\n    // out as exactly 0 — reported as a real measurement, dragging every average and\n    // p95 stage duration toward zero with no sign anything was missing. Unknown is\n    // left unknown (NULL), which the reports already handle.\n    if (declaredStart) {\n      const ms = new Date(completedAt).getTime() - new Date(declaredStart).getTime();\n      if (Number.isFinite(ms) && ms >= 0) durationMs = ms;\n    }\n  }\n\n  // Promote the failure reason to a typed field. On Action events AWS puts the\n  // human-readable summary (and a log URL + error-code, which stay in `detail`)\n  // under `execution-result`.\n  const result = detail['execution-result'] as { 'external-execution-summary'?: unknown } | undefined;\n  const summary = result?.['external-execution-summary'];\n  const errorMessage = typeof summary === 'string' && summary.length > 0\n    ? summary.slice(0, MAX_ERROR_MESSAGE)\n    : undefined;\n\n  // DORA deploy attribution — all optional: omitted (undefined) when the\n  // event/pipeline doesn't carry them.\n  const { commitSha, commitRef, revisionUrl } = extractCommit(detail);\n\n  const executionId = detail['execution-id'] as string | undefined;\n  const stageName = detail.stage as string | undefined;\n  const actionName = detail.action as string | undefined;\n\n  // Environment (⇒ isDeploy) is set ONLY when this event's stage is listed in the\n  // pipeline's pb.deploys tag. PIPELINE events have no stage → never a deploy.\n  const environment = stageName ? deploys.get(stageName) : undefined;\n\n  // Resolve the commit range (oldest-unshipped timestamp + count) for any\n  // event carrying a commit. Best-effort/in-account; omitted on any failure.\n  // GATED on `DORA_ENABLED` (set by `setup-events --with-dora`): DORA lead time is an\n  // advanced_reporting add-on, so orgs without it skip the SCM/secret cost entirely —\n  // standard reporting (commitSha + all other fields) still forwards regardless.\n  let commitTimestamp: string | undefined;\n  let commitCount: number | undefined;\n  if (commitSha && process.env.DORA_ENABLED === 'true') {\n    const src = classifySource(revisionUrl);\n    const info = await resolveCommitInfo(pipelineId, orgId, event.region, { sha: commitSha, ...src });\n    commitTimestamp = info.commitTimestamp;\n    commitCount = info.commitCount;\n  }\n\n  return {\n    orgId,\n    pipelineId,\n    eventSource,\n    eventType,\n    status: state,\n    executionId,\n    stageName,\n    actionName,\n    errorMessage,\n    startedAt,\n    completedAt,\n    durationMs,\n    ...(commitSha && { commitSha }),\n    ...(commitRef && { commitRef }),\n    ...(commitTimestamp && { commitTimestamp }),\n    ...(commitCount && { commitCount }),\n    ...(environment && { environment }),\n    detail,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse.js","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { SQSRecord } from 'aws-lambda';\nimport { codeBuildIdOf, readBuildCompute, readSynthFailure } from './failure-reason.js';\nimport { classifySource, resolveCommitInfo } from './scm.js';\nimport { MAX_ATTR, resolvePipeline } from './tags.js';\nimport { log } from './util.js';\n\n// Event parsing: an SQS record → the normalized reporting event.\n\nexport interface ParsedEvent {\n  /**\n   * Resolved platform orgId (from the pipeline's OrgId tag; null when untagged).\n   * INTERNAL — used only to key the per-org GitHub token and to attribute\n   * ingest-health. Stripped from the payload POSTed to /reports/events (which\n   * resolves org from the pipeline registry, not the body).\n   */\n  orgId: string | null;\n  pipelineId: string;\n  eventSource: string;\n  eventType: string;\n  status: string;\n  executionId?: string;\n  stageName?: string;\n  actionName?: string;\n  /** Human-readable failure reason, from an Action event's\n   *  `execution-result.external-execution-summary`. The log URL + error-code\n   *  stay in `detail` for drill-down. */\n  errorMessage?: string;\n  startedAt?: string;\n  completedAt?: string;\n  durationMs?: number;\n  /** Source commit id (DORA deploy attribution). Undefined when the event\n   *  carries no source revision — stored NULL downstream. */\n  commitSha?: string;\n  /** Source branch/ref (DORA deploy attribution). Undefined when unavailable. */\n  commitRef?: string;\n  /** Oldest-unshipped commit timestamp (ISO 8601) for the range since the last\n   *  deploy — resolved in-account. Undefined when unresolvable. */\n  commitTimestamp?: string;\n  /** Number of commits in the resolved range (≥1). Undefined when unresolvable. */\n  commitCount?: number;\n  /**\n   * The compute size a terminal CodeBuild action ran on (`SMALL` … `X2_LARGE`),\n   * read from AWS. Undefined for a non-CodeBuild action, a non-terminal event,\n   * or when the read failed — the ingest then records the action as UNMEASURED\n   * rather than as free, which is what makes the coverage gap visible instead of\n   * looking like idleness.\n   *\n   * Its own field rather than a `detail` key, for the reason `failure` has one:\n   * `detail` is bounded at 8 KB and already sheds content under that bound, so a\n   * one-word field riding inside it is a field that can be dropped by an\n   * unrelated payload getting large.\n   */\n  computeType?: string;\n  /** Deploy environment — set only when the event's stage is listed in the\n   *  pipeline's `pb.deploys` tag. Undefined otherwise (⇒ not a deploy). */\n  environment?: string;\n  /** The EventBridge event `id` (≤128) — lets the server's audit trail name the\n   *  exact AWS event a row came from. Undefined when the body carries none. */\n  sourceEventId?: string;\n  /** The SQS record's messageId (≤128) — the delivery that carried the event. */\n  sourceMessageId?: string;\n  detail: Record<string, unknown>;\n}\n\n/** Cap on `sourceEventId` / `sourceMessageId` — the reporting ingest's max. */\nconst MAX_SOURCE_ID = 128;\n\n/** A non-empty string capped to `MAX_SOURCE_ID`, else undefined. */\nfunction sourceId(v: unknown): string | undefined {\n  return typeof v === 'string' && v.length > 0 ? v.slice(0, MAX_SOURCE_ID) : undefined;\n}\n\n/** Cap on the stored failure summary — CodeBuild/Deploy summaries can be long. */\nconst MAX_ERROR_MESSAGE = 4000;\n\n/** Headroom under the reporting ingest's 8 KB serialized `detail` bound. */\nconst MAX_DETAIL_BYTES = 7500;\n\n/** First non-empty string among the candidates, capped to the ingest max. */\nfunction firstAttr(...vals: unknown[]): string | undefined {\n  for (const v of vals) {\n    if (typeof v === 'string' && v.length > 0) return v.slice(0, MAX_ATTR);\n  }\n  return undefined;\n}\n\n/**\n * Best-effort extraction of the source commit id + ref (and the revision URL, used\n * only in-account to classify the source type for commit-range resolution) from a\n * CodePipeline event detail. CodePipeline surfaces the source revision under a few\n * shapes depending on the event type / source-action; we check the known ones and\n * leave the fields undefined when none are present (NULL downstream). Never pulls an\n * ARN/account id: only revision/branch/url string fields are read; the revisionUrl\n * is consumed in-account (source classification) and never forwarded on its own.\n */\nfunction extractCommit(detail: Record<string, unknown>): { commitSha?: string; commitRef?: string; revisionUrl?: string } {\n  // `source-revisions` (kebab, EventBridge) / `sourceRevisions` (camel) — first entry.\n  const revs = (detail['source-revisions'] ?? detail.sourceRevisions) as\n    | Array<Record<string, unknown>> | undefined;\n  const firstRev = Array.isArray(revs) ? revs[0] : undefined;\n  // On source actions the revision id can also ride on `execution-result`.\n  const execResult = detail['execution-result'] as Record<string, unknown> | undefined;\n\n  const commitSha = firstAttr(\n    detail.commitId,\n    detail.revisionId,\n    firstRev?.revisionId,\n    execResult?.revisionId,\n  );\n  const commitRef = firstAttr(\n    detail.commitRef,\n    detail.branch,\n    detail.sourceBranch,\n    firstRev?.branchName,\n    firstRev?.branch,\n  );\n  const revisionUrl = typeof firstRev?.revisionUrl === 'string' ? firstRev.revisionUrl : undefined;\n\n  return { ...(commitSha && { commitSha }), ...(commitRef && { commitRef }), ...(revisionUrl && { revisionUrl }) };\n}\n\nfunction classifyEvent(detailType: string): { eventType: string; eventSource: string } {\n  if (detailType.includes('Pipeline Execution')) return { eventType: 'PIPELINE', eventSource: 'codepipeline' };\n  if (detailType.includes('Stage Execution')) return { eventType: 'STAGE', eventSource: 'codepipeline' };\n  if (detailType.includes('Action Execution')) return { eventType: 'ACTION', eventSource: 'codepipeline' };\n  // CodeBuild \"Build State\" events identify a build *project*, not a pipeline, so\n  // parseRecord drops them on the `eventSource !== 'codepipeline'` check below —\n  // the 'BUILD' eventType is never persisted here (plugin BUILD events are\n  // recorded directly by the plugin service). The 'codebuild' source is what\n  // routes the drop; keep this branch only for that.\n  if (detailType.includes('Build State')) return { eventType: 'BUILD', eventSource: 'codebuild' };\n  return { eventType: 'PIPELINE', eventSource: 'codepipeline' };\n}\n\n/** Parse + resolve one record to a reportable event, or null to skip it. */\nexport async function parseRecord(record: SQSRecord): Promise<ParsedEvent | null> {\n  let event: {\n    'id'?: string;\n    'detail-type': string;\n    'source': string;\n    'detail': Record<string, unknown>;\n    'time': string;\n    'region': string;\n    'account': string;\n  };\n  // A malformed body is a dead message (retrying won't help) — log + skip it so\n  // it can't fail the whole batch. Resolution errors below (e.g. AccessDenied)\n  // are NOT caught here: those are transient/infra and must propagate to retry.\n  try {\n    event = JSON.parse(record.body);\n  } catch (err) {\n    log.warn('Skipping SQS record with unparseable body', { messageId: record.messageId, error: String(err) });\n    return null;\n  }\n\n  const { eventType, eventSource } = classifyEvent(event['detail-type']);\n  const detail = { ...event.detail };\n  // The raw account never needs to leave AWS now — drop it from the payload.\n  delete detail.account;\n\n  // CodeBuild \"Build State\" events identify a build *project*, not a pipeline,\n  // and a project can be shared across pipelines — there's no clean 1:1 mapping\n  // to a pipeline id, so skip them.\n  if (eventSource !== 'codepipeline') {\n    log.warn('Skipping non-CodePipeline event (no pipeline tag to resolve)', { detailType: event['detail-type'] });\n    return null;\n  }\n\n  const pipelineName = detail.pipeline as string | undefined;\n  if (!pipelineName) {\n    log.warn('CodePipeline event missing pipeline name — skipping');\n    return null;\n  }\n\n  // Resolve the pipeline's pb.pipeline-id (= platform pipelineId) + pb.deploys map.\n  // The ARN is only a transient handle for the tag lookup; it is never stored.\n  const arn = `arn:aws:codepipeline:${event.region}:${event.account}:${pipelineName}`;\n  const { pipelineId, orgId, deploys } = await resolvePipeline(arn, event.region);\n  if (!pipelineId) return null; // untagged / unregistered → skip\n\n  // AWS does not always send `start-time`. `event.time` stands in for it so the\n  // row still lands in the report windows, which filter on `started_at` — but it\n  // is NOT a measurement, and the duration below must not be computed from it.\n  const declaredStart = detail['start-time'] as string | undefined;\n  const startedAt = declaredStart || event.time;\n  const state = detail.state as string;\n\n  let durationMs: number | undefined;\n  let completedAt: string | undefined;\n\n  if (['SUCCEEDED', 'FAILED', 'CANCELED', 'STOPPED'].includes(state)) {\n    completedAt = event.time;\n    // ONLY from a start AWS actually declared. With the fallback, `startedAt` and\n    // `completedAt` are both `event.time` on a terminal event, so the duration came\n    // out as exactly 0 — reported as a real measurement, dragging every average and\n    // p95 stage duration toward zero with no sign anything was missing. Unknown is\n    // left unknown (NULL), which the reports already handle.\n    if (declaredStart) {\n      const ms = new Date(completedAt).getTime() - new Date(declaredStart).getTime();\n      if (Number.isFinite(ms) && ms >= 0) durationMs = ms;\n    }\n  }\n\n  // Promote the failure reason to a typed field. On Action events AWS puts the\n  // human-readable summary (and a log URL + error-code, which stay in `detail`)\n  // under `execution-result`.\n  const result = detail['execution-result'] as { 'external-execution-summary'?: unknown } | undefined;\n  const summary = result?.['external-execution-summary'];\n  let errorMessage = typeof summary === 'string' && summary.length > 0\n    ? summary.slice(0, MAX_ERROR_MESSAGE)\n    : undefined;\n\n  // A failed CodeBuild action may have printed a structured reason (the synth's\n  // `PB_SYNTH_FAILURE` line — a refused plugin, with its code). CodeBuild's\n  // summary never carries the build output, so read it from the build's log and\n  // promote it: the code + message become the failure reason, the per-plugin\n  // list rides in `detail.pbFailure`. Best-effort (see failure-reason.ts).\n  // The compute size this action ran on, for the vCPU-minute figure Phase 4\n  // measures. Only on a TERMINAL CodeBuild action: an in-progress event has no\n  // duration to pair it with, so reading it there would spend an AWS call to\n  // learn nothing. Best-effort — null forwards without the field.\n  let computeType: string | undefined;\n  if (eventType === 'ACTION' && ['SUCCEEDED', 'FAILED', 'STOPPED'].includes(state)) {\n    const cbId = codeBuildIdOf(detail);\n    computeType = (cbId ? await readBuildCompute(event.region, cbId) : null) ?? undefined;\n  }\n\n  if (eventType === 'ACTION' && state === 'FAILED') {\n    const buildId = codeBuildIdOf(detail);\n    const failure = buildId ? await readSynthFailure(event.region, buildId) : null;\n    if (failure) {\n      detail.pbFailure = failure;\n      // The ingest bounds `detail` at 8 KB serialized; keep the codes, drop the\n      // per-plugin prose if the whole thing would not fit.\n      if (JSON.stringify(detail).length >= MAX_DETAIL_BYTES) {\n        detail.pbFailure = { ...failure, plugins: failure.plugins.map(({ plugin, code }) => ({ plugin, code })) };\n      }\n      errorMessage = `${failure.code}: ${failure.message}`.slice(0, MAX_ERROR_MESSAGE);\n    }\n  }\n\n  // Audit correlation back to the AWS side: which EventBridge event, carried by\n  // which SQS delivery. Both are opaque ids (no ARN, no account).\n  const sourceEventId = sourceId(event.id);\n  const sourceMessageId = sourceId(record.messageId);\n\n  // DORA deploy attribution — all optional: omitted (undefined) when the\n  // event/pipeline doesn't carry them.\n  const { commitSha, commitRef, revisionUrl } = extractCommit(detail);\n\n  const executionId = detail['execution-id'] as string | undefined;\n  const stageName = detail.stage as string | undefined;\n  const actionName = detail.action as string | undefined;\n\n  // Environment (⇒ isDeploy) is set ONLY when this event's stage is listed in the\n  // pipeline's pb.deploys tag. PIPELINE events have no stage → never a deploy.\n  const environment = stageName ? deploys.get(stageName) : undefined;\n\n  // Resolve the commit range (oldest-unshipped timestamp + count) for any\n  // event carrying a commit. Best-effort/in-account; omitted on any failure.\n  // GATED on `DORA_ENABLED` (set by `setup-events --with-dora`): DORA lead time is an\n  // advanced_reporting add-on, so orgs without it skip the SCM/secret cost entirely —\n  // standard reporting (commitSha + all other fields) still forwards regardless.\n  let commitTimestamp: string | undefined;\n  let commitCount: number | undefined;\n  if (commitSha && process.env.DORA_ENABLED === 'true') {\n    const src = classifySource(revisionUrl);\n    const info = await resolveCommitInfo(pipelineId, orgId, event.region, { sha: commitSha, ...src });\n    commitTimestamp = info.commitTimestamp;\n    commitCount = info.commitCount;\n  }\n\n  return {\n    orgId,\n    pipelineId,\n    eventSource,\n    eventType,\n    status: state,\n    executionId,\n    stageName,\n    actionName,\n    errorMessage,\n    startedAt,\n    completedAt,\n    durationMs,\n    ...(commitSha && { commitSha }),\n    ...(commitRef && { commitRef }),\n    ...(commitTimestamp && { commitTimestamp }),\n    ...(commitCount && { commitCount }),\n    ...(environment && { environment }),\n    ...(computeType && { computeType }),\n    ...(sourceEventId && { sourceEventId }),\n    ...(sourceMessageId && { sourceMessageId }),\n    detail,\n  };\n}\n"]}

package/lib/tags.js

@@ -1,6 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { BoundedMap, CACHE_MAX_ENTRIES, log } from './util.js';
+import { arnRef, BoundedMap, CACHE_MAX_ENTRIES, log } from './util.js';
 let codepipelineMod;
 async function loadCodePipeline() {
     if (!codepipelineMod)
@@ -13,8 +13,8 @@ async function loadCodePipeline() {
 //   pb.deploys     = <stage>:<env> pairs joined by '+', e.g.
 //                    "Deploy-stg:staging+Deploy-prod:production"
 // We resolve those tags from the live CodePipeline (region-aware). The ARN/account
-// never leave AWS, so there's no masking. Cached per ARN (warm-container) to avoid
-// hammering the ListTags API.
+// never leave AWS, and never reach a log line either: logs carry `arnRef(arn)`, a
+// short digest. Cached per ARN (warm-container) to avoid hammering the ListTags API.
 //
 // Requires the Lambda execution role to allow `codepipeline:ListTagsForResource`.
 // AccessDenied is a config error (alert loudly); a missing pb.pipeline-id tag is
@@ -89,7 +89,7 @@ export async function resolvePipeline(arn, region) {
         const orgId = out.tags?.find(t => t.key === ORG_ID_TAG)?.value ?? null;
         const deploys = parseDeploys(out.tags?.find(t => t.key === DEPLOYS_TAG)?.value);
         if (!pipelineId)
-            log.warn('Pipeline missing pb.pipeline-id tag — skipping (register it?)', { arn });
+            log.warn('Pipeline missing pb.pipeline-id tag — skipping (register it?)', { pipeline: arnRef(arn) });
         resolvedByArn.set(arn, { pipelineId, orgId, deploys, ts: Date.now() });
         return { pipelineId, orgId, deploys };
     }
@@ -97,7 +97,7 @@ export async function resolvePipeline(arn, region) {
         const name = err?.name;
         if (name === 'AccessDeniedException') {
             // Don't cache — this is a fixable misconfig, not a property of the pipeline.
-            log.error('AccessDenied calling codepipeline:ListTagsForResource — grant it to the Lambda role', { arn, error: name });
+            log.error('AccessDenied calling codepipeline:ListTagsForResource — grant it to the Lambda role', { pipeline: arnRef(arn), error: name });
             throw err;
         }
         // Transient/infra errors (throttling, timeouts, 5xx) MUST propagate so the SQS
@@ -111,10 +111,10 @@ export async function resolvePipeline(arn, region) {
             || (typeof status === 'number' && status >= 500)
             || /throttl|timeout|toomanyrequests|serviceunavailable|econnreset|networkingerror/i.test(name ?? '');
         if (retryable) {
-            log.error('Transient error resolving pb.pipeline-id tag — will retry the batch', { arn, error: name ?? String(err) });
+            log.error('Transient error resolving pb.pipeline-id tag — will retry the batch', { pipeline: arnRef(arn), error: name ?? String(err) });
             throw err;
         }
-        log.error('Failed to resolve pb.pipeline-id tag', { arn, error: name ?? String(err) });
+        log.error('Failed to resolve pb.pipeline-id tag', { pipeline: arnRef(arn), error: name ?? String(err) });
         return { pipelineId: null, orgId: null, deploys: new Map() };
     }
 }
@@ -122,4 +122,4 @@ export async function resolvePipeline(arn, region) {
 export function _resetTagsForTests() {
     resolvedByArn.clear();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tags.js","sourceRoot":"","sources":["../src/tags.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAY/D,IAAI,eAA+C,CAAC;AACpD,KAAK,UAAU,gBAAgB;IAC7B,IAAI,CAAC,eAAe;QAAE,eAAe,GAAG,CAAC,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAkC,CAAC;IACxH,OAAO,eAAe,CAAC;AACzB,CAAC;AAED,+CAA+C;AAC/C,0CAA0C;AAC1C,2CAA2C;AAC3C,6DAA6D;AAC7D,iEAAiE;AACjE,mFAAmF;AACnF,mFAAmF;AACnF,8BAA8B;AAC9B,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,0CAA0C;AAE1C,MAAM,eAAe,GAAG,gBAAgB,CAAC;AACzC,MAAM,WAAW,GAAG,YAAY,CAAC;AACjC,gFAAgF;AAChF,iFAAiF;AACjF,6EAA6E;AAC7E,6CAA6C;AAC7C,MAAM,UAAU,GAAG,OAAO,CAAC;AAC3B,MAAM,eAAe,GAAG,IAAI,GAAG,EAAkC,CAAC;AAGlE,0EAA0E;AAC1E,gFAAgF;AAChF,gFAAgF;AAChF,+EAA+E;AAC/E,iEAAiE;AACjE,MAAM,aAAa,GAAG,IAAI,UAAU,CAAwG,iBAAiB,CAAC,CAAC;AAC/J,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AACvC,MAAM,gBAAgB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAYxC,iFAAiF;AACjF,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAG,CAAC;AAE5B;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,KAAyB;IAC7C,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtC,IAAI,CAAC,KAAK;QAAE,OAAO,GAAG,CAAC;IACvB,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,GAAG,IAAI,CAAC;YAAE,SAAS;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACvC,IAAI,KAAK,IAAI,GAAG;YAAE,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,KAAK,UAAU,cAAc,CAAC,MAAc;IAC1C,IAAI,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,EAAE,kBAAkB,EAAE,GAAG,MAAM,gBAAgB,EAAE,CAAC;QACxD,MAAM,GAAG,IAAI,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QAC5C,eAAe,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,GAAW,EAAE,MAAc;IAC/D,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,2EAA2E;IAC3E,uCAAuC;IACvC,IAAI,MAAM,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC1G,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;IACzF,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,EAAE,0BAA0B,EAAE,GAAG,MAAM,gBAAgB,EAAE,CAAC;QAChE,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,0BAA0B,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;QACpF,MAAM,UAAU,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,eAAe,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC;QACjF,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,UAAU,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC;QACvE,MAAM,OAAO,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,WAAW,CAAC,EAAE,KAAK,CAAC,CAAC;QAChF,IAAI,CAAC,UAAU;YAAE,GAAG,CAAC,IAAI,CAAC,+DAA+D,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;QACpG,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACvE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IACxC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,GAAI,GAAyB,EAAE,IAAI,CAAC;QAC9C,IAAI,IAAI,KAAK,uBAAuB,EAAE,CAAC;YACrC,6EAA6E;YAC7E,GAAG,CAAC,KAAK,CAAC,qFAAqF,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YACvH,MAAM,GAAG,CAAC;QACZ,CAAC;QACD,+EAA+E;QAC/E,8EAA8E;QAC9E,gFAAgF;QAChF,8EAA8E;QAC9E,kEAAkE;QAClE,MAAM,CAAC,GAAG,GAAuF,CAAC;QAClG,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,EAAE,cAAc,CAAC;QAC3C,MAAM,SAAS,GAAG,CAAC,CAAC,UAAU,IAAI,IAAI;eACjC,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,IAAI,GAAG,CAAC;eAC7C,gFAAgF,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QACvG,IAAI,SAAS,EAAE,CAAC;YACd,GAAG,CAAC,KAAK,CAAC,qEAAqE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACtH,MAAM,GAAG,CAAC;QACZ,CAAC;QACD,GAAG,CAAC,KAAK,CAAC,sCAAsC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACvF,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;IAC/D,CAAC;AACH,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,kBAAkB;IAChC,aAAa,CAAC,KAAK,EAAE,CAAC;AACxB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { BoundedMap, CACHE_MAX_ENTRIES, log } from './util.js';\n\n// AWS Lambda's Node runtime provides @aws-sdk v3, so the CodePipeline client is\n// loaded lazily via dynamic import() — a static workspace dependency would\n// perturb the shared @aws-sdk version tree. Minimal local types keep the call\n// sites type-checked.\ninterface ListTagsOutput { tags?: Array<{ key?: string; value?: string }> }\ninterface CodePipelineClientLike { send(command: unknown): Promise<ListTagsOutput> }\ninterface CodePipelineModule {\n  CodePipelineClient: new (config: { region: string }) => CodePipelineClientLike;\n  ListTagsForResourceCommand: new (input: { resourceArn: string }) => unknown;\n}\nlet codepipelineMod: CodePipelineModule | undefined;\nasync function loadCodePipeline(): Promise<CodePipelineModule> {\n  if (!codepipelineMod) codepipelineMod = (await import('@aws-sdk/client-codepipeline')) as unknown as CodePipelineModule;\n  return codepipelineMod;\n}\n\n// Tag resolution: pb.pipeline-id + pb.deploys.\n// Pipelines are tagged at CDK synth with:\n//   pb.pipeline-id = <platform pipelineId>\n//   pb.deploys     = <stage>:<env> pairs joined by '+', e.g.\n//                    \"Deploy-stg:staging+Deploy-prod:production\"\n// We resolve those tags from the live CodePipeline (region-aware). The ARN/account\n// never leave AWS, so there's no masking. Cached per ARN (warm-container) to avoid\n// hammering the ListTags API.\n//\n// Requires the Lambda execution role to allow `codepipeline:ListTagsForResource`.\n// AccessDenied is a config error (alert loudly); a missing pb.pipeline-id tag is\n// treated as \"not yet registered\" (skip).\n\nconst PIPELINE_ID_TAG = 'pb.pipeline-id';\nconst DEPLOYS_TAG = 'pb.deploys';\n// Canonical per-pipeline org tag (applied at synth by pipeline-core). It is the\n// RESOLVED org for every event of this pipeline — used to key the per-org GitHub\n// token and to attribute ingest-health. orgId is a platform id, never an AWS\n// account id, so it is safe to read/forward.\nconst ORG_ID_TAG = 'OrgId';\nconst clientsByRegion = new Map<string, CodePipelineClientLike>();\n\n\n// `ts` lets BOTH outcomes expire: a negative (resolved-but-untagged) so a\n// pipeline tagged AFTER its first event becomes resolvable, and a positive so a\n// re-synth that changes `pb.deploys` (a stage renamed, an environment added) or\n// `OrgId` is picked up without recycling the warm container — a lifetime cache\n// would keep attributing deploys to stages that no longer exist.\nconst resolvedByArn = new BoundedMap<string, { pipelineId: string | null; orgId: string | null; deploys: Map<string, string>; ts: number }>(CACHE_MAX_ENTRIES);\nconst NEG_CACHE_TTL_MS = 5 * 60 * 1000;\nconst POS_CACHE_TTL_MS = 15 * 60 * 1000;\n\n/** Resolved pipeline metadata read from the CodePipeline resource tags. */\nexport interface ResolvedPipeline {\n  /** Platform pipelineId (pb.pipeline-id tag); null when untagged/unregistered. */\n  pipelineId: string | null;\n  /** Platform orgId (OrgId tag); null when the pipeline carries no org tag. */\n  orgId: string | null;\n  /** Map of deploy-stage name → environment (parsed from pb.deploys). Empty when none. */\n  deploys: Map<string, string>;\n}\n\n/** Cap on commit/ref/environment fields — the ingest contract allows max 255. */\nexport const MAX_ATTR = 255;\n\n/**\n * Parse the `pb.deploys` tag value into a stage→environment map. The value is\n * `<stage>:<env>` pairs joined by `+` (CodePipeline-tag-safe; no JSON). A stage\n * present here is a deploy; its mapped environment is what the forwarder stamps on\n * that stage's STAGE/ACTION events (DORA deploy attribution). Malformed pairs are\n * skipped defensively.\n */\nfunction parseDeploys(value: string | undefined): Map<string, string> {\n  const map = new Map<string, string>();\n  if (!value) return map;\n  for (const pair of value.split('+')) {\n    const idx = pair.indexOf(':');\n    if (idx <= 0) continue;\n    const stage = pair.slice(0, idx).trim();\n    const env = pair.slice(idx + 1).trim();\n    if (stage && env) map.set(stage, env.slice(0, MAX_ATTR));\n  }\n  return map;\n}\n\nasync function pipelineClient(region: string): Promise<CodePipelineClientLike> {\n  let client = clientsByRegion.get(region);\n  if (!client) {\n    const { CodePipelineClient } = await loadCodePipeline();\n    client = new CodePipelineClient({ region });\n    clientsByRegion.set(region, client);\n  }\n  return client;\n}\n\n/**\n * Resolve a CodePipeline's tags → the platform pipelineId (pb.pipeline-id) plus the\n * deploy-stage→environment map (pb.deploys). `pipelineId` is null when the pipeline\n * has no pb.pipeline-id tag (unregistered). Throws on AccessDenied so a missing IAM\n * grant surfaces loudly instead of silently dropping every event.\n */\nexport async function resolvePipeline(arn: string, region: string): Promise<ResolvedPipeline> {\n  const cached = resolvedByArn.get(arn);\n  // Serve a hit until its TTL (short for a negative, longer for a positive),\n  // then re-resolve so tag changes land.\n  if (cached && Date.now() - cached.ts < (cached.pipelineId !== null ? POS_CACHE_TTL_MS : NEG_CACHE_TTL_MS)) {\n    return { pipelineId: cached.pipelineId, orgId: cached.orgId, deploys: cached.deploys };\n  }\n  try {\n    const client = await pipelineClient(region);\n    const { ListTagsForResourceCommand } = await loadCodePipeline();\n    const out = await client.send(new ListTagsForResourceCommand({ resourceArn: arn }));\n    const pipelineId = out.tags?.find(t => t.key === PIPELINE_ID_TAG)?.value ?? null;\n    const orgId = out.tags?.find(t => t.key === ORG_ID_TAG)?.value ?? null;\n    const deploys = parseDeploys(out.tags?.find(t => t.key === DEPLOYS_TAG)?.value);\n    if (!pipelineId) log.warn('Pipeline missing pb.pipeline-id tag — skipping (register it?)', { arn });\n    resolvedByArn.set(arn, { pipelineId, orgId, deploys, ts: Date.now() });\n    return { pipelineId, orgId, deploys };\n  } catch (err) {\n    const name = (err as { name?: string })?.name;\n    if (name === 'AccessDeniedException') {\n      // Don't cache — this is a fixable misconfig, not a property of the pipeline.\n      log.error('AccessDenied calling codepipeline:ListTagsForResource — grant it to the Lambda role', { arn, error: name });\n      throw err;\n    }\n    // Transient/infra errors (throttling, timeouts, 5xx) MUST propagate so the SQS\n    // batch is retried rather than silently dropping the event — an event dropped\n    // BEFORE it reaches the ingest is lost permanently (the ingest's partial-unique\n    // index only dedupes events that were actually POSTed). Only swallow when the\n    // failure is a definitive answer that this ARN has no usable tag.\n    const e = err as { name?: string; $retryable?: unknown; $metadata?: { httpStatusCode?: number } };\n    const status = e.$metadata?.httpStatusCode;\n    const retryable = e.$retryable != null\n      || (typeof status === 'number' && status >= 500)\n      || /throttl|timeout|toomanyrequests|serviceunavailable|econnreset|networkingerror/i.test(name ?? '');\n    if (retryable) {\n      log.error('Transient error resolving pb.pipeline-id tag — will retry the batch', { arn, error: name ?? String(err) });\n      throw err;\n    }\n    log.error('Failed to resolve pb.pipeline-id tag', { arn, error: name ?? String(err) });\n    return { pipelineId: null, orgId: null, deploys: new Map() };\n  }\n}\n\n/** @internal Test-only: forget resolved pipelines. */\nexport function _resetTagsForTests(): void {\n  resolvedByArn.clear();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tags.js","sourceRoot":"","sources":["../src/tags.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { arnRef, BoundedMap, CACHE_MAX_ENTRIES, log } from './util.js';\n\n// AWS Lambda's Node runtime provides @aws-sdk v3, so the CodePipeline client is\n// loaded lazily via dynamic import() — a static workspace dependency would\n// perturb the shared @aws-sdk version tree. Minimal local types keep the call\n// sites type-checked.\ninterface ListTagsOutput { tags?: Array<{ key?: string; value?: string }> }\ninterface CodePipelineClientLike { send(command: unknown): Promise<ListTagsOutput> }\ninterface CodePipelineModule {\n  CodePipelineClient: new (config: { region: string }) => CodePipelineClientLike;\n  ListTagsForResourceCommand: new (input: { resourceArn: string }) => unknown;\n}\nlet codepipelineMod: CodePipelineModule | undefined;\nasync function loadCodePipeline(): Promise<CodePipelineModule> {\n  if (!codepipelineMod) codepipelineMod = (await import('@aws-sdk/client-codepipeline')) as unknown as CodePipelineModule;\n  return codepipelineMod;\n}\n\n// Tag resolution: pb.pipeline-id + pb.deploys.\n// Pipelines are tagged at CDK synth with:\n//   pb.pipeline-id = <platform pipelineId>\n//   pb.deploys     = <stage>:<env> pairs joined by '+', e.g.\n//                    \"Deploy-stg:staging+Deploy-prod:production\"\n// We resolve those tags from the live CodePipeline (region-aware). The ARN/account\n// never leave AWS, and never reach a log line either: logs carry `arnRef(arn)`, a\n// short digest. Cached per ARN (warm-container) to avoid hammering the ListTags API.\n//\n// Requires the Lambda execution role to allow `codepipeline:ListTagsForResource`.\n// AccessDenied is a config error (alert loudly); a missing pb.pipeline-id tag is\n// treated as \"not yet registered\" (skip).\n\nconst PIPELINE_ID_TAG = 'pb.pipeline-id';\nconst DEPLOYS_TAG = 'pb.deploys';\n// Canonical per-pipeline org tag (applied at synth by pipeline-core). It is the\n// RESOLVED org for every event of this pipeline — used to key the per-org GitHub\n// token and to attribute ingest-health. orgId is a platform id, never an AWS\n// account id, so it is safe to read/forward.\nconst ORG_ID_TAG = 'OrgId';\nconst clientsByRegion = new Map<string, CodePipelineClientLike>();\n\n\n// `ts` lets BOTH outcomes expire: a negative (resolved-but-untagged) so a\n// pipeline tagged AFTER its first event becomes resolvable, and a positive so a\n// re-synth that changes `pb.deploys` (a stage renamed, an environment added) or\n// `OrgId` is picked up without recycling the warm container — a lifetime cache\n// would keep attributing deploys to stages that no longer exist.\nconst resolvedByArn = new BoundedMap<string, { pipelineId: string | null; orgId: string | null; deploys: Map<string, string>; ts: number }>(CACHE_MAX_ENTRIES);\nconst NEG_CACHE_TTL_MS = 5 * 60 * 1000;\nconst POS_CACHE_TTL_MS = 15 * 60 * 1000;\n\n/** Resolved pipeline metadata read from the CodePipeline resource tags. */\nexport interface ResolvedPipeline {\n  /** Platform pipelineId (pb.pipeline-id tag); null when untagged/unregistered. */\n  pipelineId: string | null;\n  /** Platform orgId (OrgId tag); null when the pipeline carries no org tag. */\n  orgId: string | null;\n  /** Map of deploy-stage name → environment (parsed from pb.deploys). Empty when none. */\n  deploys: Map<string, string>;\n}\n\n/** Cap on commit/ref/environment fields — the ingest contract allows max 255. */\nexport const MAX_ATTR = 255;\n\n/**\n * Parse the `pb.deploys` tag value into a stage→environment map. The value is\n * `<stage>:<env>` pairs joined by `+` (CodePipeline-tag-safe; no JSON). A stage\n * present here is a deploy; its mapped environment is what the forwarder stamps on\n * that stage's STAGE/ACTION events (DORA deploy attribution). Malformed pairs are\n * skipped defensively.\n */\nfunction parseDeploys(value: string | undefined): Map<string, string> {\n  const map = new Map<string, string>();\n  if (!value) return map;\n  for (const pair of value.split('+')) {\n    const idx = pair.indexOf(':');\n    if (idx <= 0) continue;\n    const stage = pair.slice(0, idx).trim();\n    const env = pair.slice(idx + 1).trim();\n    if (stage && env) map.set(stage, env.slice(0, MAX_ATTR));\n  }\n  return map;\n}\n\nasync function pipelineClient(region: string): Promise<CodePipelineClientLike> {\n  let client = clientsByRegion.get(region);\n  if (!client) {\n    const { CodePipelineClient } = await loadCodePipeline();\n    client = new CodePipelineClient({ region });\n    clientsByRegion.set(region, client);\n  }\n  return client;\n}\n\n/**\n * Resolve a CodePipeline's tags → the platform pipelineId (pb.pipeline-id) plus the\n * deploy-stage→environment map (pb.deploys). `pipelineId` is null when the pipeline\n * has no pb.pipeline-id tag (unregistered). Throws on AccessDenied so a missing IAM\n * grant surfaces loudly instead of silently dropping every event.\n */\nexport async function resolvePipeline(arn: string, region: string): Promise<ResolvedPipeline> {\n  const cached = resolvedByArn.get(arn);\n  // Serve a hit until its TTL (short for a negative, longer for a positive),\n  // then re-resolve so tag changes land.\n  if (cached && Date.now() - cached.ts < (cached.pipelineId !== null ? POS_CACHE_TTL_MS : NEG_CACHE_TTL_MS)) {\n    return { pipelineId: cached.pipelineId, orgId: cached.orgId, deploys: cached.deploys };\n  }\n  try {\n    const client = await pipelineClient(region);\n    const { ListTagsForResourceCommand } = await loadCodePipeline();\n    const out = await client.send(new ListTagsForResourceCommand({ resourceArn: arn }));\n    const pipelineId = out.tags?.find(t => t.key === PIPELINE_ID_TAG)?.value ?? null;\n    const orgId = out.tags?.find(t => t.key === ORG_ID_TAG)?.value ?? null;\n    const deploys = parseDeploys(out.tags?.find(t => t.key === DEPLOYS_TAG)?.value);\n    if (!pipelineId) log.warn('Pipeline missing pb.pipeline-id tag — skipping (register it?)', { pipeline: arnRef(arn) });\n    resolvedByArn.set(arn, { pipelineId, orgId, deploys, ts: Date.now() });\n    return { pipelineId, orgId, deploys };\n  } catch (err) {\n    const name = (err as { name?: string })?.name;\n    if (name === 'AccessDeniedException') {\n      // Don't cache — this is a fixable misconfig, not a property of the pipeline.\n      log.error('AccessDenied calling codepipeline:ListTagsForResource — grant it to the Lambda role', { pipeline: arnRef(arn), error: name });\n      throw err;\n    }\n    // Transient/infra errors (throttling, timeouts, 5xx) MUST propagate so the SQS\n    // batch is retried rather than silently dropping the event — an event dropped\n    // BEFORE it reaches the ingest is lost permanently (the ingest's partial-unique\n    // index only dedupes events that were actually POSTed). Only swallow when the\n    // failure is a definitive answer that this ARN has no usable tag.\n    const e = err as { name?: string; $retryable?: unknown; $metadata?: { httpStatusCode?: number } };\n    const status = e.$metadata?.httpStatusCode;\n    const retryable = e.$retryable != null\n      || (typeof status === 'number' && status >= 500)\n      || /throttl|timeout|toomanyrequests|serviceunavailable|econnreset|networkingerror/i.test(name ?? '');\n    if (retryable) {\n      log.error('Transient error resolving pb.pipeline-id tag — will retry the batch', { pipeline: arnRef(arn), error: name ?? String(err) });\n      throw err;\n    }\n    log.error('Failed to resolve pb.pipeline-id tag', { pipeline: arnRef(arn), error: name ?? String(err) });\n    return { pipelineId: null, orgId: null, deploys: new Map() };\n  }\n}\n\n/** @internal Test-only: forget resolved pipelines. */\nexport function _resetTagsForTests(): void {\n  resolvedByArn.clear();\n}\n"]}

package/lib/util.d.ts

@@ -16,6 +16,13 @@ export declare class BoundedMap<K, V> extends Map<K, V> {
     constructor(max: number);
     set(key: K, value: V): this;
 }
+/**
+ * A log-safe stand-in for an ARN: `arn#<12 hex of sha256>`. Every ARN embeds the
+ * AWS account id, which must never reach CloudWatch — but a stable digest still
+ * lets an operator correlate log lines for the same resource (and match it by
+ * hashing an ARN they already hold).
+ */
+export declare function arnRef(arn: string): string;
 /** Upper bound for every per-key cache below. */
 export declare const CACHE_MAX_ENTRIES = 5000;
 export declare function loadSdk<T>(pkg: string): Promise<T>;

package/lib/util.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { createHash } from 'node:crypto';
 /** Shared plumbing for the event-ingestion Lambda modules. */
 export const log = {
     info: (msg, data) => console.log(JSON.stringify({ level: 'INFO', message: msg, data, ts: new Date().toISOString() })),
@@ -31,6 +32,15 @@ export class BoundedMap extends Map {
         return super.set(key, value);
     }
 }
+/**
+ * A log-safe stand-in for an ARN: `arn#<12 hex of sha256>`. Every ARN embeds the
+ * AWS account id, which must never reach CloudWatch — but a stable digest still
+ * lets an operator correlate log lines for the same resource (and match it by
+ * hashing an ARN they already hold).
+ */
+export function arnRef(arn) {
+    return `arn#${createHash('sha256').update(arn).digest('hex').slice(0, 12)}`;
+}
 /** Upper bound for every per-key cache below. */
 export const CACHE_MAX_ENTRIES = 5000;
 // Variable-specifier loader for SDK clients that are NOT devDependencies of this
@@ -63,4 +73,4 @@ export const FETCH_TIMEOUT_MS = Number(process.env.REPORTING_FETCH_TIMEOUT_MS ??
 export function fetchWithTimeout(url, init = {}, timeoutMs = FETCH_TIMEOUT_MS) {
     return fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEMsOERBQThEO0FBRTlELE1BQU0sQ0FBQyxNQUFNLEdBQUcsR0FBRztJQUNqQixJQUFJLEVBQUUsQ0FBQyxHQUFXLEVBQUUsSUFBYyxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUN2SSxJQUFJLEVBQUUsQ0FBQyxHQUFXLEVBQUUsSUFBYyxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUN2SSxLQUFLLEVBQUUsQ0FBQyxHQUFXLEVBQUUsSUFBYyxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUMsQ0FBQztDQUM1SSxDQUFDO0FBRUY7Ozs7OztHQU1HO0FBQ0gsTUFBTSxPQUFPLFVBQWlCLFNBQVEsR0FBUztJQUNoQixHQUFHO0lBQWhDLFlBQTZCLEdBQVc7UUFBSSxLQUFLLEVBQUUsQ0FBQzttQkFBdkIsR0FBRztJQUFxQixDQUFDO0lBQzdDLEdBQUcsQ0FBQyxHQUFNLEVBQUUsS0FBUTtRQUMzQixJQUFJLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNuQixLQUFLLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsa0JBQWtCO1FBQ3ZDLENBQUM7YUFBTSxJQUFJLElBQUksQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQ2pDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxLQUFLLENBQUM7WUFDeEMsSUFBSSxNQUFNLEtBQUssU0FBUztnQkFBRSxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2pELENBQUM7UUFDRCxPQUFPLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQy9CLENBQUM7Q0FDRjtBQUVELGlEQUFpRDtBQUNqRCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLENBQUM7QUFFdEMsaUZBQWlGO0FBQ2pGLGlGQUFpRjtBQUNqRiwwRUFBMEU7QUFDMUUsNkVBQTZFO0FBQzdFLE1BQU0sQ0FBQyxLQUFLLFVBQVUsT0FBTyxDQUFJLEdBQVc7SUFDMUMsT0FBTyxDQUFDLE1BQU0sTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFNLENBQUM7QUFDbEMsQ0FBQztBQUVEOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQywwQkFBMEIsSUFBSSxJQUFJLENBQUMsSUFBSSxJQUFJLENBQUM7QUFFL0Y7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxHQUFXLEVBQUUsSUFBSSxHQUFnQixFQUFFLEVBQUUsU0FBUyxHQUFHLGdCQUFnQjtJQUNoRyxPQUFPLEtBQUssQ0FBQyxHQUFHLEVBQUUsRUFBRSxHQUFHLElBQUksRUFBRSxNQUFNLEVBQUUsV0FBVyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDekUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKiogU2hhcmVkIHBsdW1iaW5nIGZvciB0aGUgZXZlbnQtaW5nZXN0aW9uIExhbWJkYSBtb2R1bGVzLiAqL1xuXG5leHBvcnQgY29uc3QgbG9nID0ge1xuICBpbmZvOiAobXNnOiBzdHJpbmcsIGRhdGE/OiB1bmtub3duKSA9PiBjb25zb2xlLmxvZyhKU09OLnN0cmluZ2lmeSh7IGxldmVsOiAnSU5GTycsIG1lc3NhZ2U6IG1zZywgZGF0YSwgdHM6IG5ldyBEYXRlKCkudG9JU09TdHJpbmcoKSB9KSksXG4gIHdhcm46IChtc2c6IHN0cmluZywgZGF0YT86IHVua25vd24pID0+IGNvbnNvbGUubG9nKEpTT04uc3RyaW5naWZ5KHsgbGV2ZWw6ICdXQVJOJywgbWVzc2FnZTogbXNnLCBkYXRhLCB0czogbmV3IERhdGUoKS50b0lTT1N0cmluZygpIH0pKSxcbiAgZXJyb3I6IChtc2c6IHN0cmluZywgZGF0YT86IHVua25vd24pID0+IGNvbnNvbGUuZXJyb3IoSlNPTi5zdHJpbmdpZnkoeyBsZXZlbDogJ0VSUk9SJywgbWVzc2FnZTogbXNnLCBkYXRhLCB0czogbmV3IERhdGUoKS50b0lTT1N0cmluZygpIH0pKSxcbn07XG5cbi8qKlxuICogQSBNYXAgdGhhdCBob2xkcyBhdCBtb3N0IGBtYXhgIGVudHJpZXMsIGV2aWN0aW5nIHRoZSBsZWFzdCByZWNlbnRseSBTRVQgb25lLlxuICogRXZlcnkgcGVyLWtleSBjYWNoZSBpbiB0aGlzIG1vZHVsZSBpcyBrZXllZCBieSBzb21ldGhpbmcgdW5ib3VuZGVkIChwaXBlbGluZVxuICogQVJOLCBwaXBlbGluZSDDlyBjb21taXQsIG9yZyksIGFuZCBhIGZsZWV0IGZvcndhcmRlcidzIHdhcm0gY29udGFpbmVyIGNhbiBsaXZlXG4gKiBmb3IgaG91cnMgYWNyb3NzIHRob3VzYW5kcyBvZiBwaXBlbGluZXMg4oCUIGFuIHVuYm91bmRlZCBNYXAgaXMgYSBzbG93IGxlYWsgdGhhdFxuICogZW5kcyBpbiBhbiBPT00ta2lsbGVkIExhbWJkYSBhbmQgYSByZWRlbGl2ZXJlZCBiYXRjaC5cbiAqL1xuZXhwb3J0IGNsYXNzIEJvdW5kZWRNYXA8SywgVj4gZXh0ZW5kcyBNYXA8SywgVj4ge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IG1heDogbnVtYmVyKSB7IHN1cGVyKCk7IH1cbiAgb3ZlcnJpZGUgc2V0KGtleTogSywgdmFsdWU6IFYpOiB0aGlzIHtcbiAgICBpZiAoc3VwZXIuaGFzKGtleSkpIHtcbiAgICAgIHN1cGVyLmRlbGV0ZShrZXkpOyAvLyByZWZyZXNoIHJlY2VuY3lcbiAgICB9IGVsc2UgaWYgKHRoaXMuc2l6ZSA+PSB0aGlzLm1heCkge1xuICAgICAgY29uc3Qgb2xkZXN0ID0gdGhpcy5rZXlzKCkubmV4dCgpLnZhbHVlO1xuICAgICAgaWYgKG9sZGVzdCAhPT0gdW5kZWZpbmVkKSBzdXBlci5kZWxldGUob2xkZXN0KTtcbiAgICB9XG4gICAgcmV0dXJuIHN1cGVyLnNldChrZXksIHZhbHVlKTtcbiAgfVxufVxuXG4vKiogVXBwZXIgYm91bmQgZm9yIGV2ZXJ5IHBlci1rZXkgY2FjaGUgYmVsb3cuICovXG5leHBvcnQgY29uc3QgQ0FDSEVfTUFYX0VOVFJJRVMgPSA1MDAwO1xuXG4vLyBWYXJpYWJsZS1zcGVjaWZpZXIgbG9hZGVyIGZvciBTREsgY2xpZW50cyB0aGF0IGFyZSBOT1QgZGV2RGVwZW5kZW5jaWVzIG9mIHRoaXNcbi8vIHBhY2thZ2UgKGBAYXdzLXNkay9jbGllbnQtY29kZWNvbW1pdGAsIGBAYXdzLXNkay9jbGllbnQtc3FzYCDigJQgcHJlc2VudCBvbmx5IGluXG4vLyB0aGUgTGFtYmRhIHJ1bnRpbWUgLyBqZXN0IG1vY2tzKS4gQSBgc3RyaW5nYCBzcGVjaWZpZXIga2VlcHMgYHRzY2AgZnJvbVxuLy8gcmVzb2x2aW5nIHRoZW0gYXQgYnVpbGQgdGltZSwgYW5kIHRoZSBidW5kbGUgbGVhdmVzIGBAYXdzLXNkay8qYCBleHRlcm5hbC5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBsb2FkU2RrPFQ+KHBrZzogc3RyaW5nKTogUHJvbWlzZTxUPiB7XG4gIHJldHVybiAoYXdhaXQgaW1wb3J0KHBrZykpIGFzIFQ7XG59XG5cbi8qKlxuICogSG93IGxvbmcgb25lIG91dGJvdW5kIGNhbGwgdG8gdGhlIHJlcG9ydGluZyBzZXJ2aWNlIG1heSB0YWtlLlxuICpcbiAqIEEgTGFtYmRhIGhhcyBubyBzdXBlcnZpc29yIHRvIG5vdGljZSBpdCBpcyBzdHVjazogYW4gdW50aW1lZCBgZmV0Y2hgIGFnYWluc3QgYSB3ZWRnZWRcbiAqIHJlcG9ydGluZyBzZXJ2aWNlIGhvbGRzIHRoZSBpbnZvY2F0aW9uIHVudGlsIHRoZSBGVU5DVElPTidzIG93biB0aW1lb3V0LCB3aGljaCBidXJuc1xuICogdGhlIHdob2xlIGJ1ZGdldCwgcmV0dXJucyBubyBiYXRjaCByZXNwb25zZSwgYW5kIGxldHMgU1FTIHJlZGVsaXZlciB0aGUgc2FtZSByZWNvcmRzXG4gKiB0byB0aGUgc2FtZSB3ZWRnZWQgZW5kcG9pbnQuIEEgYm91bmRlZCBjYWxsIGZhaWxzIGZhc3QsIHJlcG9ydHMgdGhlIGJhdGNoIGFzIGZhaWxlZCxcbiAqIGFuZCBsZXRzIHRoZSByZXRyeSBoYXBwZW4gb24gU1FTJ3Mgc2NoZWR1bGUgcmF0aGVyIHRoYW4gYnkgZXhoYXVzdGluZyB0aGUgY2xvY2suXG4gKlxuICogRGVmYXVsdCA1cywgd2VsbCBpbnNpZGUgYSB0eXBpY2FsIDMwcyBmdW5jdGlvbiB0aW1lb3V0IGV2ZW4gd2l0aCBvbmUgYXV0aCByZXRyeS5cbiAqL1xuZXhwb3J0IGNvbnN0IEZFVENIX1RJTUVPVVRfTVMgPSBOdW1iZXIocHJvY2Vzcy5lbnYuUkVQT1JUSU5HX0ZFVENIX1RJTUVPVVRfTVMgPz8gNTAwMCkgfHwgNTAwMDtcblxuLyoqXG4gKiBgZmV0Y2hgIHdpdGggYSBkZWFkbGluZS5cbiAqXG4gKiBgQWJvcnRTaWduYWwudGltZW91dGAgcmF0aGVyIHRoYW4gYSBoYW5kLXJvbGxlZCBjb250cm9sbGVyOiBpdCBpcyBvbmUgY2FsbCwgaXQgY2Fubm90XG4gKiBsZWFrIHRoZSB0aW1lciwgYW5kIGl0IHJlamVjdHMgd2l0aCBhIGBUaW1lb3V0RXJyb3JgIHRoZSBjYWxsZXJzIGFscmVhZHkgdHJlYXQgYXMgYVxuICogZmFpbGVkIFBPU1QuIEV2ZXJ5IG91dGJvdW5kIGNhbGwgaW4gdGhpcyBwYWNrYWdlIGdvZXMgdGhyb3VnaCBoZXJlIHNvIGEgbmV3IG9uZSBjYW5ub3RcbiAqIGJlIGFkZGVkIHdpdGhvdXQgYSBkZWFkbGluZSBieSBzaW1wbHkgZm9yZ2V0dGluZy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZldGNoV2l0aFRpbWVvdXQodXJsOiBzdHJpbmcsIGluaXQ6IFJlcXVlc3RJbml0ID0ge30sIHRpbWVvdXRNcyA9IEZFVENIX1RJTUVPVVRfTVMpOiBQcm9taXNlPFJlc3BvbnNlPiB7XG4gIHJldHVybiBmZXRjaCh1cmwsIHsgLi4uaW5pdCwgc2lnbmFsOiBBYm9ydFNpZ25hbC50aW1lb3V0KHRpbWVvdXRNcykgfSk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -9,7 +9,7 @@
     "@aws-sdk/client-codepipeline": "3.1160.0",
     "@aws-sdk/client-secrets-manager": "3.1160.0",
     "@jest/globals": "30.5.2",
-    "@pipeline-builder/pipeline-core": "4.4.3",
+    "@pipeline-builder/pipeline-core": "4.4.5",
     "@stylistic/eslint-plugin": "^2",
     "@types/aws-lambda": "8.10.164",
     "@types/node": "^26",
@@ -80,9 +80,10 @@
   "homepage": "https://mwashburn160.github.io/pipeline-builder/",
   "publishConfig": {
     "access": "public",
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
   },
-  "version": "4.3.3",
+  "version": "4.3.5",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },