@pipeline-builder/pipeline-events 4.0.10 → 4.0.11

package/lib/index.js

@@ -1,968 +1,716 @@
-// Copyright 2026 Pipeline Builder Contributors
-// SPDX-License-Identifier: Apache-2.0
-/**
- * SINGLE-FILE BY DEPLOYMENT CONSTRAINT — do not split this module.
- *
- * `pipeline-manager`'s `setup-events` command deploys this Lambda by copying
- * the compiled `lib/index.js` **as one file** into the zip
- * (`commands/setup-events.ts`: `copyFileSync(handlerSrc, index.mjs)` → `zip -j`).
- * Nothing bundles it. So the moment this file gains a relative import of a
- * sibling module, the emitted `lib/index.js` references a file that is not in
- * the zip and the Lambda dies at init with "Cannot find module './…'".
- *
- * That makes the usual hygiene instinct — "973 lines and nine module-level
- * caches, split it into scm-resolvers / parse-record / dlq-health" — a
- * production outage rather than a cleanup. It is also why `_resetForTests()`
- * exists: with every cache in one module, tests have no other seam.
- *
- * If this genuinely needs splitting, add a bundling step (esbuild → one
- * `lib/index.js`) to the build FIRST, and only then break the file up.
- */
-import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
-let codepipelineMod;
-async function loadCodePipeline() {
-    if (!codepipelineMod)
-        codepipelineMod = (await import('@aws-sdk/client-codepipeline'));
-    return codepipelineMod;
-}
-// Variable-specifier loader for SDK clients that are NOT static devDependencies of
-// this package (present only in the Lambda runtime / jest mocks). Passing the
-// specifier as a `string` keeps `tsc` from resolving the module at build time.
-async function loadSdk(pkg) {
-    return (await import(pkg));
-}
-/**
- * Pipeline event ingestion Lambda handler.
- *
- * Receives CodePipeline/CodeBuild events from SQS (sourced by EventBridge),
- * parses them into a normalized format, and POSTs them to the reporting service
- * via PLATFORM_BASE_URL.
- *
- * Authentication (#N2 — service-account keys):
- * The Lambda holds an opaque SERVICE-ACCOUNT KEY (`pb_sa_…`), never a JWT, and
- * trades it at platform's `/auth/token/exchange` for a 5-minute token per batch.
- * It verifies NOTHING locally: an opaque key carries no claims to check, and the
- * exchange is the authority (a revoked key stops working within one token
- * lifetime, which is the entire point of the shape). The key is minted by
- * `pipeline-manager infra store-token` and rotated in place by the token-renew
- * Lambda, so the secret's value changes underneath a warm container — which is
- * why an auth failure re-reads the SECRET, not just the token.
- *
- * Environment variables:
- * - PLATFORM_BASE_URL — Base URL of the platform
- * - PLATFORM_ACCESS_KEY — the `pb_sa_…` key set directly (no Secrets Manager call), or
- * - PLATFORM_SECRET_NAME — Secrets Manager secret containing { password: <pb_sa_ key> }
- * - EVENT_DLQ_ARN — (optional) override for the dead-letter queue ARN used by the
- *   self-healing redrive; defaults to `<main-queue-arn>-dlq` derived from the SQS
- *   trigger's eventSourceARN.
- */
-const log = {
-    info: (msg, data) => console.log(JSON.stringify({ level: 'INFO', message: msg, data, ts: new Date().toISOString() })),
-    warn: (msg, data) => console.log(JSON.stringify({ level: 'WARN', message: msg, data, ts: new Date().toISOString() })),
-    error: (msg, data) => console.error(JSON.stringify({ level: 'ERROR', message: msg, data, ts: new Date().toISOString() })),
+// ../pipeline-core/lib/handlers/platform-credential.js
+import { GetSecretValueCommand, SecretsManagerClient } from "@aws-sdk/client-secrets-manager";
+var ACCESS_KEY_PREFIXES = ["pb_sa_", "pb_pat_"];
+function assertAccessKey(value, source) {
+  if (ACCESS_KEY_PREFIXES.some((p) => value.startsWith(p)))
+    return;
+  const looksLikeJwt = value.split(".").length === 3;
+  throw new Error(`${source} does not hold an opaque access key (expected a "pb_sa_\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 }));
+  if (!response.SecretString)
+    throw new Error(`Secret "${secretName}" is empty`);
+  return JSON.parse(response.SecretString);
+}
+async function readAccessKeyFromSecret(secretName) {
+  const secret = await readCredentialSecret(secretName);
+  const key = typeof secret.password === "string" ? secret.password : "";
+  if (!key) {
+    throw new Error(`Secret "${secretName}" missing password \u2014 run "pipeline-manager infra store-token" to provision a service-account key`);
+  }
+  assertAccessKey(key, `secret "${secretName}"`);
+  return key;
+}
+function createPlatformCredential(opts) {
+  let cached = null;
+  let fromEnv = false;
+  return {
+    async getKey() {
+      if (cached)
+        return cached;
+      const direct = opts.envKeyVar ? process.env[opts.envKeyVar] : void 0;
+      if (direct) {
+        assertAccessKey(direct, opts.envKeyVar);
+        cached = direct;
+        fromEnv = true;
+        return cached;
+      }
+      const secretName = typeof opts.secretName === "function" ? opts.secretName() : opts.secretName;
+      if (!secretName) {
+        throw new Error(`${opts.envKeyVar ? `${opts.envKeyVar} or ` : ""}PLATFORM_SECRET_NAME environment variable is required`);
+      }
+      cached = await readAccessKeyFromSecret(secretName);
+      fromEnv = false;
+      return cached;
+    },
+    invalidate() {
+      if (!fromEnv)
+        cached = null;
+    },
+    reset() {
+      cached = null;
+      fromEnv = false;
+    }
+  };
+}
+
+// src/util.ts
+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() })),
+  error: (msg, data) => console.error(JSON.stringify({ level: "ERROR", message: msg, data, ts: (/* @__PURE__ */ new Date()).toISOString() }))
 };
-// ── Tag resolution: pb.pipeline-id + pb.deploys ──────────
-// Pipelines are tagged at CDK synth with:
-//   pb.pipeline-id = <platform pipelineId>
-//   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.
-//
-// Requires the Lambda execution role to allow `codepipeline:ListTagsForResource`.
-// AccessDenied is a config error (alert loudly); a missing pb.pipeline-id tag is
-// treated as "not yet registered" (skip).
-const PIPELINE_ID_TAG = 'pb.pipeline-id';
-const DEPLOYS_TAG = 'pb.deploys';
-// Canonical per-pipeline org tag (applied at synth by pipeline-core). It is the
-// RESOLVED org for every event of this pipeline — used to key the per-org GitHub
-// token and to attribute ingest-health. orgId is a platform id, never an AWS
-// account id, so it is safe to read/forward.
-const ORG_ID_TAG = 'OrgId';
-const clientsByRegion = new Map();
-// pipelineId=null is a negative cache (resolved-but-untagged); `ts` lets negatives
-// expire so a pipeline tagged AFTER its first event becomes resolvable without
-// recycling the warm container. Positive results stay cached for the lifetime.
-const resolvedByArn = new Map();
-const NEG_CACHE_TTL_MS = 5 * 60 * 1000;
-/** Cap on commit/ref/environment fields — the ingest contract allows max 255. */
-const MAX_ATTR = 255;
-/**
- * Parse the `pb.deploys` tag value into a stage→environment map. The value is
- * `<stage>:<env>` pairs joined by `+` (CodePipeline-tag-safe; no JSON). A stage
- * present here is a deploy; its mapped environment is what the forwarder stamps on
- * that stage's STAGE/ACTION events (DORA deploy attribution). Malformed pairs are
- * skipped defensively.
- */
-function parseDeploys(value) {
-    const map = new Map();
-    if (!value)
-        return map;
-    for (const pair of value.split('+')) {
-        const idx = pair.indexOf(':');
-        if (idx <= 0)
-            continue;
-        const stage = pair.slice(0, idx).trim();
-        const env = pair.slice(idx + 1).trim();
-        if (stage && env)
-            map.set(stage, env.slice(0, MAX_ATTR));
-    }
-    return map;
+var BoundedMap = class extends Map {
+  constructor(max) {
+    super();
+    this.max = max;
+  }
+  max;
+  set(key, value) {
+    if (super.has(key)) {
+      super.delete(key);
+    } else if (this.size >= this.max) {
+      const oldest = this.keys().next().value;
+      if (oldest !== void 0) super.delete(oldest);
+    }
+    return super.set(key, value);
+  }
+};
+var CACHE_MAX_ENTRIES = 5e3;
+async function loadSdk(pkg) {
+  return await import(pkg);
+}
+
+// src/auth.ts
+var TOKEN_REFRESH_FRACTION = 0.8;
+var MIN_TOKEN_CACHE_MS = 3e4;
+var EXCHANGE_TIMEOUT_MS = 5e3;
+var credential = createPlatformCredential({
+  secretName: () => process.env.PLATFORM_SECRET_NAME,
+  envKeyVar: "PLATFORM_ACCESS_KEY"
+});
+var cachedToken = null;
+var cachedTokenExpiresAt = 0;
+async function getAuthToken() {
+  if (cachedToken && Date.now() < cachedTokenExpiresAt) return cachedToken;
+  const baseUrl = (process.env.PLATFORM_BASE_URL || "").replace(/\/+$/, "");
+  if (!baseUrl) throw new Error("PLATFORM_BASE_URL environment variable is required");
+  const key = await credential.getKey();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), EXCHANGE_TIMEOUT_MS);
+  let res;
+  try {
+    res = await fetch(`${baseUrl}/api/auth/token/exchange`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Accept": "application/json" },
+      body: JSON.stringify({ key }),
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!res.ok) {
+    if (res.status === 401 || res.status === 403) {
+      throw new Error(
+        `Access-key exchange refused (${res.status}) \u2014 the stored key is unknown, revoked, expired, its service account is disabled, or this address is outside the key\u2019s IP allowlist`
+      );
+    }
+    throw new Error(`Access-key exchange failed: ${res.status}`);
+  }
+  const body = await res.json().catch(() => ({}));
+  const accessToken = body.data?.accessToken;
+  if (!accessToken) throw new Error("Access-key exchange returned no access token");
+  const ttlMs = (typeof body.data?.expiresIn === "number" && body.data.expiresIn > 0 ? body.data.expiresIn : 300) * 1e3;
+  cachedToken = accessToken;
+  cachedTokenExpiresAt = Date.now() + Math.max(MIN_TOKEN_CACHE_MS, ttlMs * TOKEN_REFRESH_FRACTION);
+  log.info("Exchanged the stored service-account key for a platform token");
+  return accessToken;
 }
-async function pipelineClient(region) {
-    let client = clientsByRegion.get(region);
-    if (!client) {
-        const { CodePipelineClient } = await loadCodePipeline();
-        client = new CodePipelineClient({ region });
-        clientsByRegion.set(region, client);
-    }
-    return client;
-}
-/**
- * Resolve a CodePipeline's tags → the platform pipelineId (pb.pipeline-id) plus the
- * deploy-stage→environment map (pb.deploys). `pipelineId` is null when the pipeline
- * has no pb.pipeline-id tag (unregistered). Throws on AccessDenied so a missing IAM
- * grant surfaces loudly instead of silently dropping every event.
- */
-async function resolvePipeline(arn, region) {
-    const cached = resolvedByArn.get(arn);
-    // Serve a positive hit for the container lifetime; serve a negative hit only
-    // until it expires (then re-resolve, in case the pipeline was since tagged).
-    if (cached && (cached.pipelineId !== null || Date.now() - cached.ts < NEG_CACHE_TTL_MS)) {
-        return { pipelineId: cached.pipelineId, orgId: cached.orgId, deploys: cached.deploys };
-    }
-    try {
-        const client = await pipelineClient(region);
-        const { ListTagsForResourceCommand } = await loadCodePipeline();
-        const out = await client.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 — skipping (register it?)', { arn });
-        resolvedByArn.set(arn, { pipelineId, orgId, deploys, ts: Date.now() });
-        return { pipelineId, orgId, deploys };
-    }
-    catch (err) {
-        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 });
-            throw err;
-        }
-        // Transient/infra errors (throttling, timeouts, 5xx) MUST propagate so the SQS
-        // batch is retried rather than silently dropping the event — an event dropped
-        // BEFORE it reaches the ingest is lost permanently (the ingest's partial-unique
-        // index only dedupes events that were actually POSTed). Only swallow when the
-        // failure is a definitive answer that this ARN has no usable tag.
-        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 — will retry the batch', { arn, error: name ?? String(err) });
-            throw err;
-        }
-        log.error('Failed to resolve pb.pipeline-id tag', { arn, error: name ?? String(err) });
-        return { pipelineId: null, orgId: null, deploys: new Map() };
-    }
+function invalidateCredential() {
+  cachedToken = null;
+  cachedTokenExpiresAt = 0;
+  credential.invalidate();
+}
+function _resetAuthForTests() {
+  cachedToken = null;
+  cachedTokenExpiresAt = 0;
+  credential.reset();
+}
+
+// src/health.ts
+var sqsMod;
+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);
+  }
+  return client;
+}
+var forwardedByOrg = new BoundedMap(CACHE_MAX_ENTRIES);
+var lastEventAtByOrg = new BoundedMap(CACHE_MAX_ENTRIES);
+var lastHealthAt = 0;
+var lastRedriveAt = 0;
+var HEALTH_THROTTLE_MS = 60 * 1e3;
+var REDRIVE_THROTTLE_MS = 5 * 60 * 1e3;
+var MAX_DLQ_REDRIVE_AGE_SEC = 6 * 60 * 60;
+function deriveQueues(mainQueueArn) {
+  if (!mainQueueArn) return void 0;
+  const parts = mainQueueArn.split(":");
+  if (parts.length < 6 || parts[2] !== "sqs") return void 0;
+  const [, , , region, account, name] = parts;
+  const dlqArn = process.env.EVENT_DLQ_ARN || `arn:aws:sqs:${region}:${account}:${name}-dlq`;
+  const dlqName = dlqArn.split(":").pop() ?? `${name}-dlq`;
+  const dlqUrl = `https://sqs.${region}.amazonaws.com/${account}/${dlqName}`;
+  return { region, mainArn: mainQueueArn, dlqArn, dlqUrl };
 }
-// ─── Auth ───────────────────────────────────────────────
-//
-// The stored credential is an OPAQUE service-account key (`pb_sa_…`), traded at
-// platform for a short-lived JWT. Nothing is verified here: an opaque key has no
-// claims and no signature, so there is nothing a local check could tell you that
-// the exchange does not tell you better — and the exchange re-reads the account,
-// its org and the key's own state every time, which is what makes a revocation
-// take effect within one token lifetime.
-//
-// This code is deliberately self-contained (see the file header: the Lambda ships
-// as ONE file), so it does not use api-core's exchange client. It keeps the same
-// contract: cache the token in the warm container, refresh EARLY (before expiry)
-// so a batch never presents a token that dies mid-flight, and fail the batch on
-// an exchange failure rather than shipping events unauthenticated.
-/** Refresh at this fraction of the token's life — never at the last moment. */
-const TOKEN_REFRESH_FRACTION = 0.8;
-/** Floor on the cached lifetime, so a surprisingly short TTL can't cause a
- *  refresh storm (one exchange per batch at worst). */
-const MIN_TOKEN_CACHE_MS = 30_000;
-/** Per-request timeout for the exchange call. */
-const EXCHANGE_TIMEOUT_MS = 5000;
-/** Access-key prefixes platform issues. A stored JWT is NOT one of these. */
-const ACCESS_KEY_PREFIXES = ['pb_sa_', 'pb_pat_'];
-let cachedKey = null;
-let cachedToken = null;
-let cachedTokenExpiresAt = 0;
-/**
- * Read (and cache) the service-account key: `PLATFORM_ACCESS_KEY` if set,
- * otherwise the `password` field of the Secrets Manager secret named by
- * `PLATFORM_SECRET_NAME`.
- *
- * Fails CLOSED and LOUDLY on a stored JWT. After the #N2 cutover the secret holds
- * a key, and a deployment still carrying the old machine-session JWT would
- * otherwise fail later as an opaque 401 from the reporting API — three layers
- * away from the thing an operator has to fix.
- */
-async function getAccessKey() {
-    if (cachedKey)
-        return cachedKey;
-    const direct = process.env.PLATFORM_ACCESS_KEY;
-    if (direct) {
-        assertAccessKey(direct, 'PLATFORM_ACCESS_KEY');
-        cachedKey = direct;
-        log.info('Using PLATFORM_ACCESS_KEY from environment');
-        return cachedKey;
-    }
-    const secretName = process.env.PLATFORM_SECRET_NAME;
-    if (!secretName) {
-        throw new Error('PLATFORM_ACCESS_KEY or PLATFORM_SECRET_NAME environment variable is required');
-    }
-    log.info(`Fetching access key from Secrets Manager: ${secretName}`);
-    const client = new SecretsManagerClient({});
-    const response = await client.send(new GetSecretValueCommand({ SecretId: secretName }));
-    if (!response.SecretString)
-        throw new Error(`Secret "${secretName}" is empty`);
-    const secret = JSON.parse(response.SecretString);
-    // `password` stays the canonical field (CodeBuild's secretsManagerCredentials
-    // and the plugin-lookup Lambda read the same one) — only its VALUE changed,
-    // from a JWT to an opaque key.
-    const key = secret.password;
-    if (!key) {
-        throw new Error(`Secret "${secretName}" missing password — run "pipeline-manager infra store-token" to provision a service-account key`);
+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({
+    QueueUrl: dlqUrl,
+    AttributeNames: ["ApproximateNumberOfMessages", "ApproximateAgeOfOldestMessage"]
+  }));
+  const n = Number(out.Attributes?.ApproximateNumberOfMessages ?? "0");
+  const age = Number(out.Attributes?.ApproximateAgeOfOldestMessage ?? "0");
+  return {
+    depth: Number.isFinite(n) ? n : 0,
+    oldestAgeSec: Number.isFinite(age) ? age : 0
+  };
+}
+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 }));
+  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 }));
+}
+async function postIngestHealth(baseUrl, body) {
+  try {
+    const token = await getAuthToken();
+    const res = await fetch(`${baseUrl}/api/reports/ingest-health`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      log.warn("ingest-health POST returned non-2xx (ignored)", { status: res.status, orgId: body.orgId });
+      return false;
     }
-    assertAccessKey(key, `secret "${secretName}"`);
-    cachedKey = key;
-    log.info('Using stored service-account key from Secrets Manager');
-    return cachedKey;
+    return true;
+  } catch (err) {
+    log.warn("ingest-health POST failed (ignored)", { error: String(err), orgId: body.orgId });
+    return false;
+  }
 }
-/** Refuse anything that is not an opaque access key, naming where it came from. */
-function assertAccessKey(value, source) {
-    if (ACCESS_KEY_PREFIXES.some((p) => value.startsWith(p)))
-        return;
-    const looksLikeJwt = value.split('.').length === 3;
-    throw new Error(`${source} does not hold an opaque access key (expected a "pb_sa_…" value)`
-        + (looksLikeJwt
-            ? ' — it still holds a JWT from before the service-account cutover. Re-run "pipeline-manager infra store-token" to reissue it as a key.'
-            : '.'));
-}
-/**
- * Trade the stored key for a short-lived platform token, cached per warm
- * container until it is 80% through its life. Throws on any failure, which fails
- * the batch so SQS retries it — an unauthenticated ship is never an option.
- */
-async function getAuthToken() {
-    if (cachedToken && Date.now() < cachedTokenExpiresAt)
-        return cachedToken;
-    const baseUrl = (process.env.PLATFORM_BASE_URL || '').replace(/\/+$/, '');
-    if (!baseUrl)
-        throw new Error('PLATFORM_BASE_URL environment variable is required');
-    const key = await getAccessKey();
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), EXCHANGE_TIMEOUT_MS);
-    let res;
-    try {
-        res = await fetch(`${baseUrl}/api/auth/token/exchange`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
-            body: JSON.stringify({ key }),
-            signal: controller.signal,
+async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
+  const now = Date.now();
+  if (now - lastHealthAt < HEALTH_THROTTLE_MS) return;
+  lastHealthAt = now;
+  try {
+    const q = deriveQueues(mainQueueArn);
+    let depth = 0;
+    let oldestAgeSec = 0;
+    if (q) {
+      try {
+        const stats = await dlqStats(q.region, q.dlqUrl);
+        depth = stats.depth;
+        oldestAgeSec = stats.oldestAgeSec;
+      } catch (err) {
+        log.warn("DLQ stats check failed (ignored)", { error: err?.name ?? String(err) });
+      }
+    }
+    const orgKeys = /* @__PURE__ */ new Set([...forwardedByOrg.keys(), ...lastEventAtByOrg.keys()]);
+    if (orgKeys.size === 0) orgKeys.add("");
+    for (const key of orgKeys) {
+      const forwarded = forwardedByOrg.get(key) ?? 0;
+      const lastEventAt = lastEventAtByOrg.get(key);
+      const ok = await postIngestHealth(baseUrl, {
+        ...key ? { orgId: key } : {},
+        forwarded,
+        dropped: depth,
+        lastEventAt
+      });
+      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,
+          dropped: depth,
+          oldestAgeSec,
+          ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC
         });
-    }
-    finally {
-        clearTimeout(timer);
-    }
-    if (!res.ok) {
-        // A rejected key is the one failure an operator has to act on, and platform
-        // deliberately answers every refusal the same way — so say what to check
-        // rather than echoing an undifferentiated 401.
-        if (res.status === 401 || res.status === 403) {
-            throw new Error(`Access-key exchange refused (${res.status}) — the stored key is unknown, revoked, expired, `
-                + 'its service account is disabled, or this address is outside the key’s IP allowlist');
+      } else {
+        try {
+          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 });
+          }
+        } catch (err) {
+          log.warn("DLQ redrive failed (ignored)", { error: err?.name ?? String(err) });
         }
-        throw new Error(`Access-key exchange failed: ${res.status}`);
-    }
-    const body = await res.json().catch(() => ({}));
-    const accessToken = body.data?.accessToken;
-    if (!accessToken)
-        throw new Error('Access-key exchange returned no access token');
-    const ttlMs = (typeof body.data?.expiresIn === 'number' && body.data.expiresIn > 0 ? body.data.expiresIn : 300) * 1000;
-    cachedToken = accessToken;
-    cachedTokenExpiresAt = Date.now() + Math.max(MIN_TOKEN_CACHE_MS, ttlMs * TOKEN_REFRESH_FRACTION);
-    log.info('Exchanged the stored service-account key for a platform token');
-    return accessToken;
-}
-/**
- * Drop everything the container is holding about its credential after a 401/403
- * from the API. The token is dropped for the obvious reason; the KEY is dropped
- * because the token-renew Lambda rotates the secret underneath us — a warm
- * container that only re-exchanged would keep presenting the retired key
- * forever. The next call re-reads the secret and picks up the replacement.
- */
-function invalidateCredential() {
-    cachedToken = null;
-    cachedTokenExpiresAt = 0;
-    // Only the SECRET path can be refreshed; an env-provided key cannot change
-    // without a new container, so keep it rather than re-reading an env var.
-    if (!process.env.PLATFORM_ACCESS_KEY)
-        cachedKey = null;
-}
-// Per-(pipeline,sha) resolved result — computed once, reused across the many events
-// (PIPELINE/STAGE/ACTION) that share a source revision and across redeliveries.
-const commitResultCache = new Map();
-// Last sha we successfully resolved per pipeline — the exclusive lower bound for the
-// next range ("commits since the last deploy"). In-memory only: a cold start resets
-// it, so the first post-cold event resolves as a single commit (expected, defensive).
-const lastShaByPipeline = new Map();
-// Per-sha CodeCommit metadata cache (date + first-parent) for range walks.
-const commitMetaCache = new Map();
-// SCM rate-limit cooldown: after a 403/429 we stop calling the SCM for a while.
-let scmCooldownUntil = 0;
-const SCM_COOLDOWN_MS = 2 * 60 * 1000;
-// Cap the CodeCommit first-parent walk so a long range can't blow the Lambda timeout.
-const MAX_COMMIT_WALK = 50;
-// Per-request timeout for external SCM calls (defensive against slow/hung hosts).
-const SCM_FETCH_TIMEOUT_MS = 3000;
-// The forwarder is a fleet Lambda: one warm container resolves events for MANY
-// orgs, so the GitHub token MUST be keyed by the event's resolved org (not a single
-// container-global token). Each org's token lives at `<prefix>/<orgId>/github-token`,
-// derived from PLATFORM_SECRET_NAME (`<prefix>/<containerOrg>/platform`). null caches
-// a definitive miss (no secret / read failed) → unauthenticated best-effort.
-const githubTokenByOrg = new Map();
-/**
- * Derive a specific org's github-token secret name from PLATFORM_SECRET_NAME
- * (`<prefix>/<containerOrg>/platform`). With an `orgId` we swap the org segment
- * (`<prefix>/<orgId>/github-token`); without one (pipeline carried no OrgId tag) we
- * fall back to the container's own sibling secret. Returns undefined when
- * PLATFORM_SECRET_NAME isn't the expected `.../platform` shape.
- */
+      }
+    }
+  } catch (err) {
+    log.warn("health/redrive step failed (ignored)", { error: String(err) });
+  }
+}
+function recordForwarded(events) {
+  for (const e of events) {
+    const key = e.orgId ?? "";
+    forwardedByOrg.set(key, (forwardedByOrg.get(key) ?? 0) + 1);
+    const at = e.completedAt || e.startedAt;
+    if (at) {
+      const prev = lastEventAtByOrg.get(key);
+      if (!prev || at > prev) lastEventAtByOrg.set(key, at);
+    }
+  }
+}
+function _resetHealthForTests() {
+  forwardedByOrg.clear();
+  lastEventAtByOrg.clear();
+  lastHealthAt = 0;
+  lastRedriveAt = 0;
+}
+
+// src/scm.ts
+import { GetSecretValueCommand as GetSecretValueCommand2, SecretsManagerClient as SecretsManagerClient2 } from "@aws-sdk/client-secrets-manager";
+var commitResultCache = new BoundedMap(CACHE_MAX_ENTRIES);
+var lastShaByPipeline = new BoundedMap(CACHE_MAX_ENTRIES);
+var commitMetaCache = new BoundedMap(CACHE_MAX_ENTRIES);
+var scmCooldownUntil = 0;
+var SCM_COOLDOWN_MS = 2 * 60 * 1e3;
+var MAX_COMMIT_WALK = 50;
+var SCM_FETCH_TIMEOUT_MS = 3e3;
+var githubTokenByOrg = new BoundedMap(CACHE_MAX_ENTRIES);
 function githubTokenSecretName(orgId) {
-    const name = process.env.PLATFORM_SECRET_NAME;
-    if (!name || !name.endsWith('/platform'))
-        return undefined;
-    const base = name.slice(0, -'/platform'.length); // <prefix>/<containerOrg>
-    if (orgId) {
-        const slash = base.lastIndexOf('/');
-        const prefix = slash > 0 ? base.slice(0, slash) : base;
-        return `${prefix}/${orgId}/github-token`;
-    }
-    return `${base}/github-token`;
+  const name = process.env.PLATFORM_SECRET_NAME;
+  if (!name || !name.endsWith("/platform")) return void 0;
+  const base = name.slice(0, -"/platform".length);
+  if (orgId) {
+    const slash = base.lastIndexOf("/");
+    const prefix = slash > 0 ? base.slice(0, slash) : base;
+    return `${prefix}/${orgId}/github-token`;
+  }
+  return `${base}/github-token`;
 }
-/** Read (and cache, per org) the org github token; null → unauthenticated best-effort. */
 async function getGitHubToken(orgId) {
-    const key = orgId ?? '';
-    const cached = githubTokenByOrg.get(key);
-    if (cached !== undefined)
-        return cached;
-    const secretName = githubTokenSecretName(orgId);
-    if (!secretName) {
-        githubTokenByOrg.set(key, null);
-        return null;
-    }
-    let token;
-    try {
-        const client = new SecretsManagerClient({});
-        const res = await client.send(new GetSecretValueCommand({ SecretId: secretName }));
-        // The github-token secret is a RAW token string (not JSON — CDK resolves it via
-        // the default SecretString with no key).
-        token = res.SecretString && res.SecretString.length > 0 ? res.SecretString.trim() : null;
-    }
-    catch (err) {
-        log.warn('No github-token secret — GitHub commit resolution will be unauthenticated', { orgId, error: err?.name });
-        token = null;
-    }
-    githubTokenByOrg.set(key, token);
-    return token;
+  const key = orgId ?? "";
+  const cached = githubTokenByOrg.get(key);
+  if (cached !== void 0) return cached;
+  const secretName = githubTokenSecretName(orgId);
+  if (!secretName) {
+    githubTokenByOrg.set(key, null);
+    return null;
+  }
+  let token;
+  try {
+    const client = new SecretsManagerClient2({});
+    const res = await client.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 });
+    token = null;
+  }
+  githubTokenByOrg.set(key, token);
+  return token;
 }
 async function fetchWithTimeout(url, opts) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), SCM_FETCH_TIMEOUT_MS);
-    try {
-        return await fetch(url, { ...opts, signal: controller.signal });
-    }
-    finally {
-        clearTimeout(timer);
-    }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), SCM_FETCH_TIMEOUT_MS);
+  try {
+    return await fetch(url, { ...opts, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
 }
-/** Normalize a commit date to ISO 8601. Accepts ISO strings and CodeCommit's
- *  "<epoch-seconds> +ZZZZ" form. Returns undefined when unparseable. */
 function toIso(value) {
-    if (typeof value !== 'string' || value.length === 0)
-        return undefined;
-    const epoch = /^(\d{9,})\b/.exec(value.trim());
-    if (epoch) {
-        const d = new Date(Number(epoch[1]) * 1000);
-        return Number.isNaN(d.getTime()) ? undefined : d.toISOString();
-    }
-    const d = new Date(value);
-    return Number.isNaN(d.getTime()) ? undefined : d.toISOString();
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  const epoch = /^(\d{9,})\b/.exec(value.trim());
+  if (epoch) {
+    const d2 = new Date(Number(epoch[1]) * 1e3);
+    return Number.isNaN(d2.getTime()) ? void 0 : d2.toISOString();
+  }
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? void 0 : d.toISOString();
 }
-/** Classify a source-revision URL into a provider + repo coordinates. */
 function classifySource(url) {
-    if (!url)
-        return { provider: 'unknown' };
-    try {
-        const u = new URL(url);
-        const host = u.hostname.toLowerCase();
-        if (host === 'github.com' || host.endsWith('.github.com')) {
-            const parts = u.pathname.split('/').filter(Boolean);
-            if (parts.length >= 2)
-                return { provider: 'github', owner: parts[0], repo: parts[1].replace(/\.git$/, '') };
-        }
-        if (host === 'bitbucket.org') {
-            const parts = u.pathname.split('/').filter(Boolean);
-            if (parts.length >= 2)
-                return { provider: 'bitbucket', owner: parts[0], repo: parts[1].replace(/\.git$/, '') };
-        }
-        if (u.pathname.toLowerCase().includes('codecommit') || u.hash.toLowerCase().includes('codecommit') || u.pathname.includes('/repositories/')) {
-            const m = /repositor(?:y|ies)\/([^/#?]+)/.exec(u.pathname + u.hash);
-            if (m)
-                return { provider: 'codecommit', repositoryName: decodeURIComponent(m[1]) };
-        }
-    }
-    catch {
-        // not a URL → unknown
-    }
-    return { provider: 'unknown' };
-}
-let codecommitClientsByRegion;
-let codecommitMod;
+  if (!url) return { provider: "unknown" };
+  try {
+    const u = new URL(url);
+    const host = u.hostname.toLowerCase();
+    if (host === "github.com" || host.endsWith(".github.com")) {
+      const parts = u.pathname.split("/").filter(Boolean);
+      if (parts.length >= 2) return { provider: "github", owner: parts[0], repo: parts[1].replace(/\.git$/, "") };
+    }
+    if (host === "bitbucket.org") {
+      const parts = u.pathname.split("/").filter(Boolean);
+      if (parts.length >= 2) return { provider: "bitbucket", owner: parts[0], repo: parts[1].replace(/\.git$/, "") };
+    }
+    if (u.pathname.toLowerCase().includes("codecommit") || u.hash.toLowerCase().includes("codecommit") || u.pathname.includes("/repositories/")) {
+      const m = /repositor(?:y|ies)\/([^/#?]+)/.exec(u.pathname + u.hash);
+      if (m) return { provider: "codecommit", repositoryName: decodeURIComponent(m[1]) };
+    }
+  } catch {
+  }
+  return { provider: "unknown" };
+}
+var codecommitClientsByRegion;
+var codecommitMod;
 async function codeCommitClient(region) {
-    if (!codecommitMod)
-        codecommitMod = await loadSdk('@aws-sdk/client-codecommit');
-    if (!codecommitClientsByRegion)
-        codecommitClientsByRegion = new Map();
-    let client = codecommitClientsByRegion.get(region);
-    if (!client) {
-        client = new codecommitMod.CodeCommitClient({ region });
-        codecommitClientsByRegion.set(region, client);
-    }
-    return client;
+  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);
+  }
+  return client;
 }
-/** Fetch (cached) a single CodeCommit commit's date + first parents via GetCommit. */
 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 commit = out.commit;
-    const meta = { date: toIso(commit?.committer?.date ?? commit?.author?.date), parents: commit?.parents };
-    commitMetaCache.set(commitId, meta);
-    return meta;
+  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 commit = out.commit;
+  const meta = { date: toIso(commit?.committer?.date ?? commit?.author?.date), parents: commit?.parents };
+  commitMetaCache.set(commitId, meta);
+  return meta;
 }
 async function resolveCodeCommit(region, repositoryName, sha, sinceSha) {
-    let cur = sha;
-    let count = 0;
-    let oldest;
-    let truncated = false;
-    for (let i = 0;; i++) {
-        if (!cur)
-            break; // reached history root — the whole range is covered
-        if (sinceSha && cur === sinceSha)
-            break; // reached the exclusive lower bound
-        if (i >= MAX_COMMIT_WALK) {
-            truncated = true;
-            break;
-        } // hit the cap before the boundary
-        const meta = await codeCommitMeta(region, repositoryName, cur);
-        if (!meta?.date)
-            break;
-        count++;
-        oldest = meta.date;
-        if (!sinceSha)
-            break; // no range → single commit
-        cur = meta.parents?.[0];
-    }
-    // A truncated walk yields a commit NEWER than the true oldest-unshipped commit,
-    // which would UNDERSTATE lead time — omit the fields entirely rather than report a
-    // wrong (too-small) value. Reporting falls back to `unknown`.
-    if (truncated)
-        return {};
-    return oldest ? { commitTimestamp: oldest, commitCount: count } : {};
+  let cur = sha;
+  let count = 0;
+  let oldest;
+  let truncated = false;
+  for (let i = 0; ; i++) {
+    if (!cur) break;
+    if (sinceSha && cur === sinceSha) break;
+    if (i >= MAX_COMMIT_WALK) {
+      truncated = true;
+      break;
+    }
+    const meta = await codeCommitMeta(region, repositoryName, cur);
+    if (!meta?.date) break;
+    count++;
+    oldest = meta.date;
+    if (!sinceSha) break;
+    cur = meta.parents?.[0];
+  }
+  if (truncated) return {};
+  return oldest ? { commitTimestamp: oldest, commitCount: count } : {};
 }
 async function resolveGitHub(owner, repo, sha, sinceSha, orgId) {
-    const token = await getGitHubToken(orgId);
-    const headers = {
-        'Accept': 'application/vnd.github+json',
-        'User-Agent': 'pipeline-builder-forwarder',
-        'X-GitHub-Api-Version': '2022-11-28',
-    };
-    if (token)
-        headers.Authorization = `Bearer ${token}`;
-    const rateLimited = (r) => r.status === 403 || r.status === 429;
-    if (sinceSha) {
-        const r = await fetchWithTimeout(`https://api.github.com/repos/${owner}/${repo}/compare/${sinceSha}...${sha}`, { headers });
-        if (rateLimited(r)) {
-            scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
-            return {};
-        }
-        if (r.ok) {
-            const j = await r.json();
-            const commits = Array.isArray(j.commits) ? j.commits : [];
-            if (commits.length > 0) {
-                const oldest = toIso(commits[0]?.commit?.committer?.date ?? commits[0]?.commit?.author?.date);
-                if (oldest)
-                    return { commitTimestamp: oldest, commitCount: commits.length };
-            }
-        }
-        // fall through to single-commit resolution
-    }
-    const r2 = await fetchWithTimeout(`https://api.github.com/repos/${owner}/${repo}/commits/${sha}`, { headers });
-    if (rateLimited(r2)) {
-        scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
-        return {};
-    }
-    if (r2.ok) {
-        const j = await r2.json();
-        const d = toIso(j.commit?.committer?.date ?? j.commit?.author?.date);
-        if (d)
-            return { commitTimestamp: d, commitCount: 1 };
+  const token = await getGitHubToken(orgId);
+  const headers = {
+    "Accept": "application/vnd.github+json",
+    "User-Agent": "pipeline-builder-forwarder",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const rateLimited = (r) => r.status === 403 || r.status === 429;
+  if (sinceSha) {
+    const r = await fetchWithTimeout(`https://api.github.com/repos/${owner}/${repo}/compare/${sinceSha}...${sha}`, { headers });
+    if (rateLimited(r)) {
+      scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
+      return {};
     }
+    if (r.ok) {
+      const j = await r.json();
+      const commits = Array.isArray(j.commits) ? j.commits : [];
+      if (commits.length > 0) {
+        const oldest = toIso(commits[0]?.commit?.committer?.date ?? commits[0]?.commit?.author?.date);
+        if (oldest) return { commitTimestamp: oldest, commitCount: commits.length };
+      }
+    }
+  }
+  const r2 = await fetchWithTimeout(`https://api.github.com/repos/${owner}/${repo}/commits/${sha}`, { headers });
+  if (rateLimited(r2)) {
+    scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
     return {};
+  }
+  if (r2.ok) {
+    const j = await r2.json();
+    const d = toIso(j.commit?.committer?.date ?? j.commit?.author?.date);
+    if (d) return { commitTimestamp: d, commitCount: 1 };
+  }
+  return {};
 }
 async function resolveBitbucket(owner, repo, sha) {
-    const r = await fetchWithTimeout(`https://api.bitbucket.org/2.0/repositories/${owner}/${repo}/commit/${sha}`, {
-        headers: { 'User-Agent': 'pipeline-builder-forwarder', 'Accept': 'application/json' },
-    });
-    if (r.status === 429) {
-        scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
-        return {};
-    }
-    if (r.ok) {
-        const j = await r.json();
-        const d = toIso(j.date);
-        if (d)
-            return { commitTimestamp: d, commitCount: 1 };
-    }
+  const r = await fetchWithTimeout(`https://api.bitbucket.org/2.0/repositories/${owner}/${repo}/commit/${sha}`, {
+    headers: { "User-Agent": "pipeline-builder-forwarder", "Accept": "application/json" }
+  });
+  if (r.status === 429) {
+    scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
     return {};
+  }
+  if (r.ok) {
+    const j = await r.json();
+    const d = toIso(j.date);
+    if (d) return { commitTimestamp: d, commitCount: 1 };
+  }
+  return {};
 }
-/**
- * Resolve `commitTimestamp` + `commitCount` for a source/deploy event, in-account,
- * best-effort. Computed once per (pipelineId, sha); advances the pipeline's range
- * boundary only on success. Never throws — returns {} on any failure.
- */
 async function resolveCommitInfo(pipelineId, orgId, region, src) {
-    if (src.provider === 'unknown')
-        return {};
-    const rkey = `${pipelineId}|${src.sha}`;
-    const cached = commitResultCache.get(rkey);
-    if (cached)
-        return cached;
-    const prev = lastShaByPipeline.get(pipelineId);
-    const sinceSha = prev && prev !== src.sha ? prev : undefined;
-    let info = {};
-    try {
-        if (src.provider === 'codecommit' && src.repositoryName) {
-            info = await resolveCodeCommit(region, src.repositoryName, src.sha, sinceSha);
-        }
-        else if (src.provider === 'github' && src.owner && src.repo) {
-            if (Date.now() >= scmCooldownUntil)
-                info = await resolveGitHub(src.owner, src.repo, src.sha, sinceSha, orgId);
-        }
-        else if (src.provider === 'bitbucket' && src.owner && src.repo) {
-            if (Date.now() >= scmCooldownUntil)
-                info = await resolveBitbucket(src.owner, src.repo, src.sha);
-        }
-    }
-    catch (err) {
-        log.warn('Commit resolution failed (omitting commitTimestamp/commitCount)', { provider: src.provider, error: err?.name ?? String(err) });
-        info = {};
-    }
+  if (src.provider === "unknown") return {};
+  const rkey = `${pipelineId}|${src.sha}`;
+  const cached = commitResultCache.get(rkey);
+  if (cached) return cached;
+  const prev = lastShaByPipeline.get(pipelineId);
+  const sinceSha = prev && prev !== src.sha ? prev : void 0;
+  let info = {};
+  try {
+    if (src.provider === "codecommit" && src.repositoryName) {
+      info = await resolveCodeCommit(region, src.repositoryName, src.sha, sinceSha);
+    } else if (src.provider === "github" && src.owner && src.repo) {
+      if (Date.now() >= scmCooldownUntil) info = await resolveGitHub(src.owner, src.repo, src.sha, sinceSha, orgId);
+    } else if (src.provider === "bitbucket" && src.owner && src.repo) {
+      if (Date.now() >= scmCooldownUntil) info = await resolveBitbucket(src.owner, src.repo, src.sha);
+    }
+  } catch (err) {
+    log.warn("Commit resolution failed (omitting commitTimestamp/commitCount)", { provider: src.provider, error: err?.name ?? String(err) });
+    info = {};
+  }
+  if (info.commitTimestamp) {
     commitResultCache.set(rkey, info);
-    if (info.commitTimestamp)
-        lastShaByPipeline.set(pipelineId, src.sha);
-    return info;
+    lastShaByPipeline.set(pipelineId, src.sha);
+  }
+  return info;
+}
+function _resetScmForTests() {
+  commitResultCache.clear();
+  lastShaByPipeline.clear();
+  commitMetaCache.clear();
+  scmCooldownUntil = 0;
+  githubTokenByOrg.clear();
+}
+
+// src/tags.ts
+var codepipelineMod;
+async function loadCodePipeline() {
+  if (!codepipelineMod) codepipelineMod = await import("@aws-sdk/client-codepipeline");
+  return codepipelineMod;
+}
+var PIPELINE_ID_TAG = "pb.pipeline-id";
+var DEPLOYS_TAG = "pb.deploys";
+var ORG_ID_TAG = "OrgId";
+var clientsByRegion = /* @__PURE__ */ new Map();
+var resolvedByArn = new BoundedMap(CACHE_MAX_ENTRIES);
+var NEG_CACHE_TTL_MS = 5 * 60 * 1e3;
+var POS_CACHE_TTL_MS = 15 * 60 * 1e3;
+var MAX_ATTR = 255;
+function parseDeploys(value) {
+  const map = /* @__PURE__ */ new Map();
+  if (!value) return map;
+  for (const pair of value.split("+")) {
+    const idx = pair.indexOf(":");
+    if (idx <= 0) continue;
+    const stage = pair.slice(0, idx).trim();
+    const env = pair.slice(idx + 1).trim();
+    if (stage && env) map.set(stage, env.slice(0, MAX_ATTR));
+  }
+  return map;
+}
+async function pipelineClient(region) {
+  let client = clientsByRegion.get(region);
+  if (!client) {
+    const { CodePipelineClient } = await loadCodePipeline();
+    client = new CodePipelineClient({ region });
+    clientsByRegion.set(region, client);
+  }
+  return client;
 }
-/** Cap on the stored failure summary — CodeBuild/Deploy summaries can be long. */
-const MAX_ERROR_MESSAGE = 4000;
-/** First non-empty string among the candidates, capped to the ingest max. */
+async function resolvePipeline(arn, region) {
+  const cached = resolvedByArn.get(arn);
+  if (cached && Date.now() - cached.ts < (cached.pipelineId !== null ? POS_CACHE_TTL_MS : NEG_CACHE_TTL_MS)) {
+    return { pipelineId: cached.pipelineId, orgId: cached.orgId, deploys: cached.deploys };
+  }
+  try {
+    const client = await pipelineClient(region);
+    const { ListTagsForResourceCommand } = await loadCodePipeline();
+    const out = await client.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 });
+    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 });
+      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) });
+      throw err;
+    }
+    log.error("Failed to resolve pb.pipeline-id tag", { arn, error: name ?? String(err) });
+    return { pipelineId: null, orgId: null, deploys: /* @__PURE__ */ new Map() };
+  }
+}
+function _resetTagsForTests() {
+  resolvedByArn.clear();
+}
+
+// src/parse.ts
+var MAX_ERROR_MESSAGE = 4e3;
 function firstAttr(...vals) {
-    for (const v of vals) {
-        if (typeof v === 'string' && v.length > 0)
-            return v.slice(0, MAX_ATTR);
-    }
-    return undefined;
-}
-/**
- * Best-effort extraction of the source commit id + ref (and the revision URL, used
- * only in-account to classify the source type for commit-range resolution) from a
- * CodePipeline event detail. CodePipeline surfaces the source revision under a few
- * shapes depending on the event type / source-action; we check the known ones and
- * leave the fields undefined when none are present (NULL downstream). Never pulls an
- * ARN/account id: only revision/branch/url string fields are read; the revisionUrl
- * is consumed in-account (source classification) and never forwarded on its own.
- */
+  for (const v of vals) {
+    if (typeof v === "string" && v.length > 0) return v.slice(0, MAX_ATTR);
+  }
+  return void 0;
+}
 function extractCommit(detail) {
-    // `source-revisions` (kebab, EventBridge) / `sourceRevisions` (camel) — first entry.
-    const revs = (detail['source-revisions'] ?? detail.sourceRevisions);
-    const firstRev = Array.isArray(revs) ? revs[0] : undefined;
-    // On source actions the revision id can also ride on `execution-result`.
-    const execResult = detail['execution-result'];
-    const commitSha = firstAttr(detail.commitId, detail.revisionId, firstRev?.revisionId, execResult?.revisionId);
-    const commitRef = firstAttr(detail.commitRef, detail.branch, detail.sourceBranch, firstRev?.branchName, firstRev?.branch);
-    const revisionUrl = typeof firstRev?.revisionUrl === 'string' ? firstRev.revisionUrl : undefined;
-    return { ...(commitSha && { commitSha }), ...(commitRef && { commitRef }), ...(revisionUrl && { revisionUrl }) };
+  const revs = detail["source-revisions"] ?? detail.sourceRevisions;
+  const firstRev = Array.isArray(revs) ? revs[0] : void 0;
+  const execResult = detail["execution-result"];
+  const commitSha = firstAttr(
+    detail.commitId,
+    detail.revisionId,
+    firstRev?.revisionId,
+    execResult?.revisionId
+  );
+  const commitRef = firstAttr(
+    detail.commitRef,
+    detail.branch,
+    detail.sourceBranch,
+    firstRev?.branchName,
+    firstRev?.branch
+  );
+  const revisionUrl = typeof firstRev?.revisionUrl === "string" ? firstRev.revisionUrl : void 0;
+  return { ...commitSha && { commitSha }, ...commitRef && { commitRef }, ...revisionUrl && { revisionUrl } };
 }
 function classifyEvent(detailType) {
-    if (detailType.includes('Pipeline Execution'))
-        return { eventType: 'PIPELINE', eventSource: 'codepipeline' };
-    if (detailType.includes('Stage Execution'))
-        return { eventType: 'STAGE', eventSource: 'codepipeline' };
-    if (detailType.includes('Action Execution'))
-        return { eventType: 'ACTION', eventSource: 'codepipeline' };
-    // CodeBuild "Build State" events identify a build *project*, not a pipeline, so
-    // parseRecord drops them on the `eventSource !== 'codepipeline'` check below —
-    // the 'BUILD' eventType is never persisted here (plugin BUILD events are
-    // recorded directly by the plugin service). The 'codebuild' source is what
-    // routes the drop; keep this branch only for that.
-    if (detailType.includes('Build State'))
-        return { eventType: 'BUILD', eventSource: 'codebuild' };
-    return { eventType: 'PIPELINE', eventSource: 'codepipeline' };
-}
-/** Parse + resolve one record to a reportable event, or null to skip it. */
-async function parseRecord(record) {
-    let event;
-    // A malformed body is a dead message (retrying won't help) — log + skip it so
-    // it can't fail the whole batch. Resolution errors below (e.g. AccessDenied)
-    // are NOT caught here: those are transient/infra and must propagate to retry.
-    try {
-        event = JSON.parse(record.body);
-    }
-    catch (err) {
-        log.warn('Skipping SQS record with unparseable body', { messageId: record.messageId, error: String(err) });
-        return null;
-    }
-    const { eventType, eventSource } = classifyEvent(event['detail-type']);
-    const detail = { ...event.detail };
-    // The raw account never needs to leave AWS now — drop it from the payload.
-    delete detail.account;
-    // CodeBuild "Build State" events identify a build *project*, not a pipeline,
-    // and a project can be shared across pipelines — there's no clean 1:1 mapping
-    // to a pipeline id, so skip them.
-    if (eventSource !== 'codepipeline') {
-        log.warn('Skipping non-CodePipeline event (no pipeline tag to resolve)', { detailType: event['detail-type'] });
-        return null;
-    }
-    const pipelineName = detail.pipeline;
-    if (!pipelineName) {
-        log.warn('CodePipeline event missing pipeline name — skipping');
-        return null;
-    }
-    // Resolve the pipeline's pb.pipeline-id (= platform pipelineId) + pb.deploys map.
-    // The ARN is only a transient handle for the tag lookup; it is never stored.
-    const arn = `arn:aws:codepipeline:${event.region}:${event.account}:${pipelineName}`;
-    const { pipelineId, orgId, deploys } = await resolvePipeline(arn, event.region);
-    if (!pipelineId)
-        return null; // untagged / unregistered → skip
-    const startedAt = detail['start-time'] || event.time;
-    const state = detail.state;
-    let durationMs;
-    let completedAt;
-    if (['SUCCEEDED', 'FAILED', 'CANCELED', 'STOPPED'].includes(state)) {
-        completedAt = event.time;
-        if (startedAt && completedAt) {
-            const ms = new Date(completedAt).getTime() - new Date(startedAt).getTime();
-            if (ms >= 0)
-                durationMs = ms;
-        }
-    }
-    // Promote the failure reason to a typed field. On Action events AWS puts the
-    // human-readable summary (and a log URL + error-code, which stay in `detail`)
-    // under `execution-result`.
-    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)
-        : undefined;
-    // DORA deploy attribution — all optional: omitted (undefined) when the
-    // event/pipeline doesn't carry them.
-    const { commitSha, commitRef, revisionUrl } = extractCommit(detail);
-    const executionId = detail['execution-id'];
-    const stageName = detail.stage;
-    const actionName = detail.action;
-    // Environment (⇒ isDeploy) is set ONLY when this event's stage is listed in the
-    // pipeline's pb.deploys tag. PIPELINE events have no stage → never a deploy.
-    const environment = stageName ? deploys.get(stageName) : undefined;
-    // Phase 4 — resolve the commit range (oldest-unshipped timestamp + count) for any
-    // event carrying a commit. Best-effort/in-account; omitted on any failure.
-    // GATED on `DORA_ENABLED` (set by `setup-events --with-dora`): DORA lead time is an
-    // advanced_reporting add-on, so orgs without it skip the SCM/secret cost entirely —
-    // standard reporting (commitSha + all other fields) still forwards regardless.
-    let commitTimestamp;
-    let commitCount;
-    if (commitSha && process.env.DORA_ENABLED === 'true') {
-        const src = classifySource(revisionUrl);
-        const info = await resolveCommitInfo(pipelineId, orgId, event.region, { sha: commitSha, ...src });
-        commitTimestamp = info.commitTimestamp;
-        commitCount = info.commitCount;
-    }
-    return {
-        orgId,
-        pipelineId,
-        eventSource,
-        eventType,
-        status: state,
-        executionId,
-        stageName,
-        actionName,
-        errorMessage,
-        startedAt,
-        completedAt,
-        durationMs,
-        ...(commitSha && { commitSha }),
-        ...(commitRef && { commitRef }),
-        ...(commitTimestamp && { commitTimestamp }),
-        ...(commitCount && { commitCount }),
-        ...(environment && { environment }),
-        detail,
-    };
-}
-let sqsMod;
-let sqsClientsByRegion;
-async function sqsClient(region) {
-    if (!sqsMod)
-        sqsMod = await loadSdk('@aws-sdk/client-sqs');
-    if (!sqsClientsByRegion)
-        sqsClientsByRegion = new Map();
-    let client = sqsClientsByRegion.get(region);
-    if (!client) {
-        client = new sqsMod.SQSClient({ region });
-        sqsClientsByRegion.set(region, client);
-    }
-    return client;
-}
-// Delivery-health counters are attributed PER RESOLVED ORG (the forwarder is a fleet
-// Lambda serving many orgs; a single global counter would mis-attribute one org's
-// throughput to another). Keyed by orgId ('' bucket = pipeline with no OrgId tag).
-// The DLQ depth (`dropped`) is genuinely fleet-global — one shared DLQ — so it is a
-// single snapshot posted alongside each org's health, documented as the shared depth.
-const forwardedByOrg = new Map();
-const lastEventAtByOrg = new Map();
-let lastHealthAt = 0;
-let lastRedriveAt = 0;
-const HEALTH_THROTTLE_MS = 60 * 1000;
-const REDRIVE_THROTTLE_MS = 5 * 60 * 1000;
-// Poison-message ceiling: if the oldest DLQ message is older than this, we STOP
-// redriving it (DLQ→main→fail→DLQ would loop forever). Such messages are left for an
-// alarm / manual inspection instead of churning the fleet indefinitely.
-const MAX_DLQ_REDRIVE_AGE_SEC = 6 * 60 * 60; // 6 hours
-/** Parse the SQS trigger ARN and derive the main + DLQ ARNs and the DLQ URL. */
-function deriveQueues(mainQueueArn) {
-    if (!mainQueueArn)
-        return undefined;
-    // arn:aws:sqs:{region}:{account}:{name}
-    const parts = mainQueueArn.split(':');
-    if (parts.length < 6 || parts[2] !== 'sqs')
-        return undefined;
-    const [, , , region, account, name] = parts;
-    const dlqArn = process.env.EVENT_DLQ_ARN || `arn:aws:sqs:${region}:${account}:${name}-dlq`;
-    const dlqName = dlqArn.split(':').pop() ?? `${name}-dlq`;
-    const dlqUrl = `https://sqs.${region}.amazonaws.com/${account}/${dlqName}`;
-    return { region, mainArn: mainQueueArn, dlqArn, dlqUrl };
-}
-/** Snapshot the DLQ depth + the age (seconds) of its oldest message (for the
- *  poison-message redrive ceiling). Missing/NaN attributes fall back to 0. */
-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({
-        QueueUrl: dlqUrl,
-        AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateAgeOfOldestMessage'],
-    }));
-    const n = Number(out.Attributes?.ApproximateNumberOfMessages ?? '0');
-    const age = Number(out.Attributes?.ApproximateAgeOfOldestMessage ?? '0');
-    return {
-        depth: Number.isFinite(n) ? n : 0,
-        oldestAgeSec: Number.isFinite(age) ? age : 0,
-    };
-}
-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 }));
-    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 }));
-}
-/** 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) {
-    try {
-        const token = await getAuthToken();
-        const res = await fetch(`${baseUrl}/api/reports/ingest-health`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
-            body: JSON.stringify(body),
-        });
-        if (!res.ok) {
-            log.warn('ingest-health POST returned non-2xx (ignored)', { status: res.status, orgId: body.orgId });
-            return false;
-        }
-        return true;
-    }
-    catch (err) {
-        log.warn('ingest-health POST failed (ignored)', { error: String(err), orgId: body.orgId });
-        return false;
-    }
-}
-/**
- * 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.
- */
-async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
-    const now = Date.now();
-    if (now - lastHealthAt < HEALTH_THROTTLE_MS)
-        return;
-    lastHealthAt = now;
-    try {
-        const q = deriveQueues(mainQueueArn);
-        let depth = 0;
-        let oldestAgeSec = 0;
-        if (q) {
-            try {
-                const stats = await dlqStats(q.region, q.dlqUrl);
-                depth = stats.depth;
-                oldestAgeSec = stats.oldestAgeSec;
-            }
-            catch (err) {
-                log.warn('DLQ stats check failed (ignored)', { error: err?.name ?? String(err) });
-            }
-        }
-        // Post one health signal per resolved org, attributing its own forwarded count +
-        // last event time. `dropped` (the shared fleet DLQ depth) rides along on each.
-        // Snapshot the keys first so we don't mutate the map while iterating.
-        const orgKeys = new Set([...forwardedByOrg.keys(), ...lastEventAtByOrg.keys()]);
-        if (orgKeys.size === 0)
-            orgKeys.add(''); // nothing forwarded yet → still report depth
-        for (const key of orgKeys) {
-            const forwarded = forwardedByOrg.get(key) ?? 0;
-            const lastEventAt = lastEventAtByOrg.get(key);
-            const ok = await postIngestHealth(baseUrl, {
-                ...(key ? { orgId: key } : {}),
-                forwarded,
-                dropped: depth,
-                lastEventAt,
-            });
-            // 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)
-                forwardedByOrg.set(key, 0);
-        }
-        if (q && depth > 0 && now - lastRedriveAt >= REDRIVE_THROTTLE_MS) {
-            // Poison-message ceiling: never redrive a DLQ whose oldest message has aged
-            // 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,
-                });
-            }
-            else {
-                try {
-                    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 });
-                    }
-                }
-                catch (err) {
-                    log.warn('DLQ redrive failed (ignored)', { error: err?.name ?? String(err) });
-                }
-            }
-        }
-    }
-    catch (err) {
-        log.warn('health/redrive step failed (ignored)', { error: String(err) });
-    }
+  if (detailType.includes("Pipeline Execution")) return { eventType: "PIPELINE", eventSource: "codepipeline" };
+  if (detailType.includes("Stage Execution")) return { eventType: "STAGE", eventSource: "codepipeline" };
+  if (detailType.includes("Action Execution")) return { eventType: "ACTION", eventSource: "codepipeline" };
+  if (detailType.includes("Build State")) return { eventType: "BUILD", eventSource: "codebuild" };
+  return { eventType: "PIPELINE", eventSource: "codepipeline" };
 }
-// ─── Handler ────────────────────────────────────────────
-export const handler = async (event) => {
-    const baseUrl = process.env.PLATFORM_BASE_URL;
-    if (!baseUrl)
-        throw new Error('PLATFORM_BASE_URL environment variable is required');
-    // Parse + resolve all records (tag + commit lookups run concurrently); drop
-    // intentional skips (null). A malformed record BODY is handled inside parseRecord
-    // (logged + skipped) so one bad message can't fail the whole batch — while genuine
-    // infra errors (e.g. AccessDenied on the tag lookup) still propagate so a missing
-    // IAM grant surfaces and SQS retries the batch.
-    const events = (await Promise.all(event.Records.map(parseRecord)))
-        .filter((e) => e !== null);
-    if (events.length === 0) {
-        log.info('No resolvable CodePipeline events in batch');
-        return;
-    }
-    // POST batch to reporting service. On a 401/403 the credential this container
-    // holds is stale — most often because the token-renew Lambda rotated the key in
-    // Secrets Manager — so drop BOTH the cached token and the cached key, re-read,
-    // and retry ONCE. `orgId` is INTERNAL (token/health keying) — strip it here so
-    // it never rides the wire; the ingest resolves org from the pipeline registry,
-    // not the body.
-    const payloadEvents = events.map(({ orgId: _orgId, ...rest }) => rest);
-    const post = (token) => fetch(`${baseUrl}/api/reports/events`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
-        body: JSON.stringify({ events: payloadEvents }),
-    });
-    let res = await post(await getAuthToken());
-    if (res.status === 401 || res.status === 403) {
-        log.warn('Reporting API auth failed; re-reading the stored key and retrying once', { status: res.status });
-        invalidateCredential();
-        res = await post(await getAuthToken());
-    }
-    if (!res.ok) {
-        const body = await res.text().catch(() => '');
-        log.error(`Reporting API returned ${res.status}`, { body });
-        throw new Error(`Reporting API failed: ${res.status}`);
-    }
-    // The insert already succeeded (2xx). The parsed body is only used for a log
-    // line, so a non-JSON/empty body must not throw and fail the whole batch —
-    // that would trigger an SQS redelivery and re-POST (duplicate) already-inserted
-    // events. The ingest's partial-unique index dedupes, but avoid the churn anyway.
-    const result = await res.json().catch(() => ({}));
-    log.info(`Ingested ${events.length} events`, { inserted: result.data });
-    // Accumulate delivery-health counters PER RESOLVED ORG, then run the throttled
-    // post-success health + self-healing DLQ redrive (best-effort, never fails batch).
-    for (const e of events) {
-        const key = e.orgId ?? '';
-        forwardedByOrg.set(key, (forwardedByOrg.get(key) ?? 0) + 1);
-        const at = e.completedAt || e.startedAt;
-        if (at) {
-            const prev = lastEventAtByOrg.get(key);
-            if (!prev || at > prev)
-                lastEventAtByOrg.set(key, at);
-        }
-    }
-    await reportHealthAndRedrive(baseUrl, event.Records[0]?.eventSourceARN);
+async function parseRecord(record) {
+  let event;
+  try {
+    event = JSON.parse(record.body);
+  } catch (err) {
+    log.warn("Skipping SQS record with unparseable body", { messageId: record.messageId, error: String(err) });
+    return null;
+  }
+  const { eventType, eventSource } = classifyEvent(event["detail-type"]);
+  const detail = { ...event.detail };
+  delete detail.account;
+  if (eventSource !== "codepipeline") {
+    log.warn("Skipping non-CodePipeline event (no pipeline tag to resolve)", { detailType: event["detail-type"] });
+    return null;
+  }
+  const pipelineName = detail.pipeline;
+  if (!pipelineName) {
+    log.warn("CodePipeline event missing pipeline name \u2014 skipping");
+    return null;
+  }
+  const arn = `arn:aws:codepipeline:${event.region}:${event.account}:${pipelineName}`;
+  const { pipelineId, orgId, deploys } = await resolvePipeline(arn, event.region);
+  if (!pipelineId) return null;
+  const startedAt = detail["start-time"] || event.time;
+  const state = detail.state;
+  let durationMs;
+  let completedAt;
+  if (["SUCCEEDED", "FAILED", "CANCELED", "STOPPED"].includes(state)) {
+    completedAt = event.time;
+    if (startedAt && completedAt) {
+      const ms = new Date(completedAt).getTime() - new Date(startedAt).getTime();
+      if (ms >= 0) durationMs = ms;
+    }
+  }
+  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;
+  const { commitSha, commitRef, revisionUrl } = extractCommit(detail);
+  const executionId = detail["execution-id"];
+  const stageName = detail.stage;
+  const actionName = detail.action;
+  const environment = stageName ? deploys.get(stageName) : void 0;
+  let commitTimestamp;
+  let commitCount;
+  if (commitSha && process.env.DORA_ENABLED === "true") {
+    const src = classifySource(revisionUrl);
+    const info = await resolveCommitInfo(pipelineId, orgId, event.region, { sha: commitSha, ...src });
+    commitTimestamp = info.commitTimestamp;
+    commitCount = info.commitCount;
+  }
+  return {
+    orgId,
+    pipelineId,
+    eventSource,
+    eventType,
+    status: state,
+    executionId,
+    stageName,
+    actionName,
+    errorMessage,
+    startedAt,
+    completedAt,
+    durationMs,
+    ...commitSha && { commitSha },
+    ...commitRef && { commitRef },
+    ...commitTimestamp && { commitTimestamp },
+    ...commitCount && { commitCount },
+    ...environment && { environment },
+    detail
+  };
+}
+
+// src/index.ts
+var handler = async (event) => {
+  const baseUrl = process.env.PLATFORM_BASE_URL;
+  if (!baseUrl) throw new Error("PLATFORM_BASE_URL environment variable is required");
+  const events = (await Promise.all(event.Records.map(parseRecord))).filter((e) => e !== null);
+  if (events.length === 0) {
+    log.info("No resolvable CodePipeline events in batch");
+    return;
+  }
+  const payloadEvents = events.map(({ orgId: _orgId, ...rest }) => rest);
+  const post = (token) => fetch(`${baseUrl}/api/reports/events`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+    body: JSON.stringify({ events: payloadEvents })
+  });
+  let res = await post(await getAuthToken());
+  if (res.status === 401 || res.status === 403) {
+    log.warn("Reporting API auth failed; re-reading the stored key and retrying once", { status: res.status });
+    invalidateCredential();
+    res = await post(await getAuthToken());
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    log.error(`Reporting API returned ${res.status}`, { body });
+    throw new Error(`Reporting API failed: ${res.status}`);
+  }
+  const result = await res.json().catch(() => ({}));
+  log.info(`Ingested ${events.length} events`, { inserted: result.data });
+  recordForwarded(events);
+  await reportHealthAndRedrive(baseUrl, event.Records[0]?.eventSourceARN);
+};
+function _resetForTests() {
+  _resetTagsForTests();
+  _resetScmForTests();
+  _resetHealthForTests();
+  _resetAuthForTests();
+}
+export {
+  _resetForTests,
+  handler
 };
-/**
- * @internal Test-only: reset all module-level caches/throttle state so tests are
- * isolated from one another. Stripped from the published .d.ts (stripInternal).
- */
-export function _resetForTests() {
-    resolvedByArn.clear();
-    commitResultCache.clear();
-    lastShaByPipeline.clear();
-    commitMetaCache.clear();
-    scmCooldownUntil = 0;
-    githubTokenByOrg.clear();
-    forwardedByOrg.clear();
-    lastEventAtByOrg.clear();
-    lastHealthAt = 0;
-    lastRedriveAt = 0;
-    cachedKey = null;
-    cachedToken = null;
-    cachedTokenExpiresAt = 0;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * SINGLE-FILE BY DEPLOYMENT CONSTRAINT — do not split this module.\n *\n * `pipeline-manager`'s `setup-events` command deploys this Lambda by copying\n * the compiled `lib/index.js` **as one file** into the zip\n * (`commands/setup-events.ts`: `copyFileSync(handlerSrc, index.mjs)` → `zip -j`).\n * Nothing bundles it. So the moment this file gains a relative import of a\n * sibling module, the emitted `lib/index.js` references a file that is not in\n * the zip and the Lambda dies at init with \"Cannot find module './…'\".\n *\n * That makes the usual hygiene instinct — \"973 lines and nine module-level\n * caches, split it into scm-resolvers / parse-record / dlq-health\" — a\n * production outage rather than a cleanup. It is also why `_resetForTests()`\n * exists: with every cache in one module, tests have no other seam.\n *\n * If this genuinely needs splitting, add a bundling step (esbuild → one\n * `lib/index.js`) to the build FIRST, and only then break the file up.\n */\n\nimport { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';\nimport type { SQSEvent, SQSRecord } from 'aws-lambda';\n\n// AWS Lambda's Node runtime bundles @aws-sdk v3, so the CodePipeline/CodeCommit/SQS\n// clients are loaded lazily via dynamic import() — a static workspace dependency on\n// them would perturb the shared @aws-sdk version tree and break other packages'\n// typings. The dynamic import keeps them out of the static graph while staying\n// ESM-correct (no `require` in a type:module package) and mockable. Minimal local\n// types keep the call sites type-checked. `@aws-sdk/client-codecommit` and\n// `@aws-sdk/client-sqs` are NOT devDependencies of this package (they resolve only\n// inside the Lambda runtime / jest mocks), so they are imported through a\n// variable-specifier helper below so `tsc` does not try to resolve them.\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// Variable-specifier loader for SDK clients that are NOT static devDependencies of\n// this package (present only in the Lambda runtime / jest mocks). Passing the\n// specifier as a `string` keeps `tsc` from resolving the module at build time.\nasync function loadSdk<T>(pkg: string): Promise<T> {\n  return (await import(pkg)) as T;\n}\n\n/**\n * Pipeline event ingestion Lambda handler.\n *\n * Receives CodePipeline/CodeBuild events from SQS (sourced by EventBridge),\n * parses them into a normalized format, and POSTs them to the reporting service\n * via PLATFORM_BASE_URL.\n *\n * Authentication (#N2 — service-account keys):\n * The Lambda holds an opaque SERVICE-ACCOUNT KEY (`pb_sa_…`), never a JWT, and\n * trades it at platform's `/auth/token/exchange` for a 5-minute token per batch.\n * It verifies NOTHING locally: an opaque key carries no claims to check, and the\n * exchange is the authority (a revoked key stops working within one token\n * lifetime, which is the entire point of the shape). The key is minted by\n * `pipeline-manager infra store-token` and rotated in place by the token-renew\n * Lambda, so the secret's value changes underneath a warm container — which is\n * why an auth failure re-reads the SECRET, not just the token.\n *\n * Environment variables:\n * - PLATFORM_BASE_URL — Base URL of the platform\n * - PLATFORM_ACCESS_KEY — the `pb_sa_…` key set directly (no Secrets Manager call), or\n * - PLATFORM_SECRET_NAME — Secrets Manager secret containing { password: <pb_sa_ key> }\n * - EVENT_DLQ_ARN — (optional) override for the dead-letter queue ARN used by the\n *   self-healing redrive; defaults to `<main-queue-arn>-dlq` derived from the SQS\n *   trigger's eventSourceARN.\n */\n\nconst log = {\n  info: (msg: string, data?: unknown) => console.log(JSON.stringify({ level: 'INFO', message: msg, data, ts: new Date().toISOString() })),\n  warn: (msg: string, data?: unknown) => console.log(JSON.stringify({ level: 'WARN', message: msg, data, ts: new Date().toISOString() })),\n  error: (msg: string, data?: unknown) => console.error(JSON.stringify({ level: 'ERROR', message: msg, data, ts: new Date().toISOString() })),\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// pipelineId=null is a negative cache (resolved-but-untagged); `ts` lets negatives\n// expire so a pipeline tagged AFTER its first event becomes resolvable without\n// recycling the warm container. Positive results stay cached for the lifetime.\nconst resolvedByArn = new Map<string, { pipelineId: string | null; orgId: string | null; deploys: Map<string, string>; ts: number }>();\nconst NEG_CACHE_TTL_MS = 5 * 60 * 1000;\n\n/** Resolved pipeline metadata read from the CodePipeline resource tags. */\ninterface 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. */\nconst 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 */\nasync function resolvePipeline(arn: string, region: string): Promise<ResolvedPipeline> {\n  const cached = resolvedByArn.get(arn);\n  // Serve a positive hit for the container lifetime; serve a negative hit only\n  // until it expires (then re-resolve, in case the pipeline was since tagged).\n  if (cached && (cached.pipelineId !== null || Date.now() - cached.ts < 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// ─── Auth ───────────────────────────────────────────────\n//\n// The stored credential is an OPAQUE service-account key (`pb_sa_…`), traded at\n// platform for a short-lived JWT. Nothing is verified here: an opaque key has no\n// claims and no signature, so there is nothing a local check could tell you that\n// the exchange does not tell you better — and the exchange re-reads the account,\n// its org and the key's own state every time, which is what makes a revocation\n// take effect within one token lifetime.\n//\n// This code is deliberately self-contained (see the file header: the Lambda ships\n// as ONE file), so it does not use api-core's exchange client. It keeps the same\n// contract: cache the token in the warm container, refresh EARLY (before expiry)\n// so a batch never presents a token that dies mid-flight, and fail the batch on\n// an exchange failure rather than shipping events unauthenticated.\n\n/** Refresh at this fraction of the token's life — never at the last moment. */\nconst TOKEN_REFRESH_FRACTION = 0.8;\n/** Floor on the cached lifetime, so a surprisingly short TTL can't cause a\n *  refresh storm (one exchange per batch at worst). */\nconst MIN_TOKEN_CACHE_MS = 30_000;\n/** Per-request timeout for the exchange call. */\nconst EXCHANGE_TIMEOUT_MS = 5000;\n\n/** Access-key prefixes platform issues. A stored JWT is NOT one of these. */\nconst ACCESS_KEY_PREFIXES = ['pb_sa_', 'pb_pat_'];\n\nlet cachedKey: string | null = null;\nlet cachedToken: string | null = null;\nlet cachedTokenExpiresAt = 0;\n\n/**\n * Read (and cache) the service-account key: `PLATFORM_ACCESS_KEY` if set,\n * otherwise the `password` field of the Secrets Manager secret named by\n * `PLATFORM_SECRET_NAME`.\n *\n * Fails CLOSED and LOUDLY on a stored JWT. After the #N2 cutover the secret holds\n * a key, and a deployment still carrying the old machine-session JWT would\n * otherwise fail later as an opaque 401 from the reporting API — three layers\n * away from the thing an operator has to fix.\n */\nasync function getAccessKey(): Promise<string> {\n  if (cachedKey) return cachedKey;\n\n  const direct = process.env.PLATFORM_ACCESS_KEY;\n  if (direct) {\n    assertAccessKey(direct, 'PLATFORM_ACCESS_KEY');\n    cachedKey = direct;\n    log.info('Using PLATFORM_ACCESS_KEY from environment');\n    return cachedKey;\n  }\n\n  const secretName = process.env.PLATFORM_SECRET_NAME;\n  if (!secretName) {\n    throw new Error('PLATFORM_ACCESS_KEY or PLATFORM_SECRET_NAME environment variable is required');\n  }\n\n  log.info(`Fetching access key from Secrets Manager: ${secretName}`);\n  const client = new SecretsManagerClient({});\n  const response = await client.send(new GetSecretValueCommand({ SecretId: secretName }));\n  if (!response.SecretString) throw new Error(`Secret \"${secretName}\" is empty`);\n\n  const secret = JSON.parse(response.SecretString) as Record<string, string>;\n  // `password` stays the canonical field (CodeBuild's secretsManagerCredentials\n  // and the plugin-lookup Lambda read the same one) — only its VALUE changed,\n  // from a JWT to an opaque key.\n  const key = secret.password;\n  if (!key) {\n    throw new Error(`Secret \"${secretName}\" missing password — run \"pipeline-manager infra store-token\" to provision a service-account key`);\n  }\n  assertAccessKey(key, `secret \"${secretName}\"`);\n\n  cachedKey = key;\n  log.info('Using stored service-account key from Secrets Manager');\n  return cachedKey;\n}\n\n/** Refuse anything that is not an opaque access key, naming where it came from. */\nfunction assertAccessKey(value: string, source: string): void {\n  if (ACCESS_KEY_PREFIXES.some((p) => value.startsWith(p))) return;\n  const looksLikeJwt = value.split('.').length === 3;\n  throw new Error(\n    `${source} does not hold an opaque access key (expected a \"pb_sa_…\" value)`\n    + (looksLikeJwt\n      ? ' — it still holds a JWT from before the service-account cutover. Re-run \"pipeline-manager infra store-token\" to reissue it as a key.'\n      : '.'),\n  );\n}\n\n/**\n * Trade the stored key for a short-lived platform token, cached per warm\n * container until it is 80% through its life. Throws on any failure, which fails\n * the batch so SQS retries it — an unauthenticated ship is never an option.\n */\nasync function getAuthToken(): Promise<string> {\n  if (cachedToken && Date.now() < cachedTokenExpiresAt) return cachedToken;\n\n  const baseUrl = (process.env.PLATFORM_BASE_URL || '').replace(/\\/+$/, '');\n  if (!baseUrl) throw new Error('PLATFORM_BASE_URL environment variable is required');\n  const key = await getAccessKey();\n\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), EXCHANGE_TIMEOUT_MS);\n  let res: Response;\n  try {\n    res = await fetch(`${baseUrl}/api/auth/token/exchange`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },\n      body: JSON.stringify({ key }),\n      signal: controller.signal,\n    });\n  } finally {\n    clearTimeout(timer);\n  }\n\n  if (!res.ok) {\n    // A rejected key is the one failure an operator has to act on, and platform\n    // deliberately answers every refusal the same way — so say what to check\n    // rather than echoing an undifferentiated 401.\n    if (res.status === 401 || res.status === 403) {\n      throw new Error(\n        `Access-key exchange refused (${res.status}) — the stored key is unknown, revoked, expired, `\n        + 'its service account is disabled, or this address is outside the key’s IP allowlist',\n      );\n    }\n    throw new Error(`Access-key exchange failed: ${res.status}`);\n  }\n\n  const body = await res.json().catch(() => ({})) as { data?: { accessToken?: string; expiresIn?: number } };\n  const accessToken = body.data?.accessToken;\n  if (!accessToken) throw new Error('Access-key exchange returned no access token');\n\n  const ttlMs = (typeof body.data?.expiresIn === 'number' && body.data.expiresIn > 0 ? body.data.expiresIn : 300) * 1000;\n  cachedToken = accessToken;\n  cachedTokenExpiresAt = Date.now() + Math.max(MIN_TOKEN_CACHE_MS, ttlMs * TOKEN_REFRESH_FRACTION);\n  log.info('Exchanged the stored service-account key for a platform token');\n  return accessToken;\n}\n\n/**\n * Drop everything the container is holding about its credential after a 401/403\n * from the API. The token is dropped for the obvious reason; the KEY is dropped\n * because the token-renew Lambda rotates the secret underneath us — a warm\n * container that only re-exchanged would keep presenting the retired key\n * forever. The next call re-reads the secret and picks up the replacement.\n */\nfunction invalidateCredential(): void {\n  cachedToken = null;\n  cachedTokenExpiresAt = 0;\n  // Only the SECRET path can be refreshed; an env-provided key cannot change\n  // without a new container, so keep it rather than re-reading an env var.\n  if (!process.env.PLATFORM_ACCESS_KEY) cachedKey = null;\n}\n\n// ─── Phase 4: in-account commit-range resolution ─────────\n// For a source/deploy event carrying a commitSha we resolve the commit timestamp\n// (and how many commits shipped) for the range since the last resolved sha of the\n// same pipeline — entirely IN-ACCOUNT, per source type:\n//   • CodeCommit  → AWS SDK GetCommit (walk first-parents back to the boundary).\n//   • GitHub/CodeConnections-GitHub → GitHub REST compare/commits API. Authenticated\n//     with the org's `pipeline-builder/{orgId}/github-token` secret when present\n//     (derived from PLATFORM_SECRET_NAME), otherwise best-effort unauthenticated.\n//   • Bitbucket   → Bitbucket REST commit API (single-commit; range walk omitted).\n// The oldest unshipped commit's timestamp → `commitTimestamp`; the number of commits\n// in the range → `commitCount`. Everything here is BEST-EFFORT: on any failure the\n// fields are simply omitted (reporting falls back to `unknown`). It must NEVER fail\n// the batch.\n//\n// IAM required by this path (document only — granted on the events stack):\n//   • codecommit:GetCommit            (CodeCommit sources)\n//   • secretsmanager:GetSecretValue on `pipeline-builder/*/github-token` (token SCM sources)\n\ntype SourceProvider = 'github' | 'bitbucket' | 'codecommit' | 'unknown';\ninterface SourceRef {\n  sha: string;\n  provider: SourceProvider;\n  owner?: string;\n  repo?: string;\n  repositoryName?: string;\n}\ninterface CommitInfo { commitTimestamp?: string; commitCount?: number }\n\n// Per-(pipeline,sha) resolved result — computed once, reused across the many events\n// (PIPELINE/STAGE/ACTION) that share a source revision and across redeliveries.\nconst commitResultCache = new Map<string, CommitInfo>();\n// Last sha we successfully resolved per pipeline — the exclusive lower bound for the\n// next range (\"commits since the last deploy\"). In-memory only: a cold start resets\n// it, so the first post-cold event resolves as a single commit (expected, defensive).\nconst lastShaByPipeline = new Map<string, string>();\n// Per-sha CodeCommit metadata cache (date + first-parent) for range walks.\nconst commitMetaCache = new Map<string, { date?: string; parents?: string[] }>();\n// SCM rate-limit cooldown: after a 403/429 we stop calling the SCM for a while.\nlet scmCooldownUntil = 0;\nconst SCM_COOLDOWN_MS = 2 * 60 * 1000;\n// Cap the CodeCommit first-parent walk so a long range can't blow the Lambda timeout.\nconst MAX_COMMIT_WALK = 50;\n// Per-request timeout for external SCM calls (defensive against slow/hung hosts).\nconst SCM_FETCH_TIMEOUT_MS = 3000;\n\n// The forwarder is a fleet Lambda: one warm container resolves events for MANY\n// orgs, so the GitHub token MUST be keyed by the event's resolved org (not a single\n// container-global token). Each org's token lives at `<prefix>/<orgId>/github-token`,\n// derived from PLATFORM_SECRET_NAME (`<prefix>/<containerOrg>/platform`). null caches\n// a definitive miss (no secret / read failed) → unauthenticated best-effort.\nconst githubTokenByOrg = new Map<string, string | null>();\n\n/**\n * Derive a specific org's github-token secret name from PLATFORM_SECRET_NAME\n * (`<prefix>/<containerOrg>/platform`). With an `orgId` we swap the org segment\n * (`<prefix>/<orgId>/github-token`); without one (pipeline carried no OrgId tag) we\n * fall back to the container's own sibling secret. Returns undefined when\n * PLATFORM_SECRET_NAME isn't the expected `.../platform` shape.\n */\nfunction githubTokenSecretName(orgId: string | null): string | undefined {\n  const name = process.env.PLATFORM_SECRET_NAME;\n  if (!name || !name.endsWith('/platform')) return undefined;\n  const base = name.slice(0, -'/platform'.length); // <prefix>/<containerOrg>\n  if (orgId) {\n    const slash = base.lastIndexOf('/');\n    const prefix = slash > 0 ? base.slice(0, slash) : base;\n    return `${prefix}/${orgId}/github-token`;\n  }\n  return `${base}/github-token`;\n}\n\n/** Read (and cache, per org) the org github token; null → unauthenticated best-effort. */\nasync function getGitHubToken(orgId: string | null): Promise<string | null> {\n  const key = orgId ?? '';\n  const cached = githubTokenByOrg.get(key);\n  if (cached !== undefined) return cached;\n  const secretName = githubTokenSecretName(orgId);\n  if (!secretName) { githubTokenByOrg.set(key, null); return null; }\n  let token: string | null;\n  try {\n    const client = new SecretsManagerClient({});\n    const res = await client.send(new GetSecretValueCommand({ SecretId: secretName }));\n    // The github-token secret is a RAW token string (not JSON — CDK resolves it via\n    // the default SecretString with no key).\n    token = res.SecretString && res.SecretString.length > 0 ? res.SecretString.trim() : null;\n  } catch (err) {\n    log.warn('No github-token secret — GitHub commit resolution will be unauthenticated', { orgId, error: (err as { name?: string })?.name });\n    token = null;\n  }\n  githubTokenByOrg.set(key, token);\n  return token;\n}\n\nasync function fetchWithTimeout(url: string, opts: Record<string, unknown>): Promise<Response> {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), SCM_FETCH_TIMEOUT_MS);\n  try {\n    return await fetch(url, { ...opts, signal: controller.signal });\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\n/** Normalize a commit date to ISO 8601. Accepts ISO strings and CodeCommit's\n *  \"<epoch-seconds> +ZZZZ\" form. Returns undefined when unparseable. */\nfunction toIso(value: unknown): string | undefined {\n  if (typeof value !== 'string' || value.length === 0) return undefined;\n  const epoch = /^(\\d{9,})\\b/.exec(value.trim());\n  if (epoch) {\n    const d = new Date(Number(epoch[1]) * 1000);\n    return Number.isNaN(d.getTime()) ? undefined : d.toISOString();\n  }\n  const d = new Date(value);\n  return Number.isNaN(d.getTime()) ? undefined : d.toISOString();\n}\n\n/** Classify a source-revision URL into a provider + repo coordinates. */\nfunction classifySource(url: string | undefined): Omit<SourceRef, 'sha'> {\n  if (!url) return { provider: 'unknown' };\n  try {\n    const u = new URL(url);\n    const host = u.hostname.toLowerCase();\n    if (host === 'github.com' || host.endsWith('.github.com')) {\n      const parts = u.pathname.split('/').filter(Boolean);\n      if (parts.length >= 2) return { provider: 'github', owner: parts[0], repo: parts[1].replace(/\\.git$/, '') };\n    }\n    if (host === 'bitbucket.org') {\n      const parts = u.pathname.split('/').filter(Boolean);\n      if (parts.length >= 2) return { provider: 'bitbucket', owner: parts[0], repo: parts[1].replace(/\\.git$/, '') };\n    }\n    if (u.pathname.toLowerCase().includes('codecommit') || u.hash.toLowerCase().includes('codecommit') || u.pathname.includes('/repositories/')) {\n      const m = /repositor(?:y|ies)\\/([^/#?]+)/.exec(u.pathname + u.hash);\n      if (m) return { provider: 'codecommit', repositoryName: decodeURIComponent(m[1]) };\n    }\n  } catch {\n    // not a URL → unknown\n  }\n  return { provider: 'unknown' };\n}\n\nlet codecommitClientsByRegion: Map<string, { send(command: unknown): Promise<unknown> }> | undefined;\ninterface CodeCommitModule {\n  CodeCommitClient: new (config: { region: string }) => { send(command: unknown): Promise<unknown> };\n  GetCommitCommand: new (input: { repositoryName: string; commitId: string }) => unknown;\n}\nlet codecommitMod: CodeCommitModule | undefined;\nasync function codeCommitClient(region: string): Promise<{ send(command: unknown): Promise<unknown> }> {\n  if (!codecommitMod) codecommitMod = await loadSdk<CodeCommitModule>('@aws-sdk/client-codecommit');\n  if (!codecommitClientsByRegion) codecommitClientsByRegion = new Map();\n  let client = codecommitClientsByRegion.get(region);\n  if (!client) {\n    client = new codecommitMod.CodeCommitClient({ region });\n    codecommitClientsByRegion.set(region, client);\n  }\n  return client;\n}\n\n/** Fetch (cached) a single CodeCommit commit's date + first parents via GetCommit. */\nasync function codeCommitMeta(region: string, repositoryName: string, commitId: string): Promise<{ date?: string; parents?: string[] } | undefined> {\n  const cached = commitMetaCache.get(commitId);\n  if (cached) return cached;\n  if (!codecommitMod) codecommitMod = await loadSdk<CodeCommitModule>('@aws-sdk/client-codecommit');\n  const client = await codeCommitClient(region);\n  const out = await client.send(new codecommitMod.GetCommitCommand({ repositoryName, commitId })) as {\n    commit?: { committer?: { date?: string }; author?: { date?: string }; parents?: string[] };\n  };\n  const commit = out.commit;\n  const meta = { date: toIso(commit?.committer?.date ?? commit?.author?.date), parents: commit?.parents };\n  commitMetaCache.set(commitId, meta);\n  return meta;\n}\n\nasync function resolveCodeCommit(region: string, repositoryName: string, sha: string, sinceSha?: string): Promise<CommitInfo> {\n  let cur: string | undefined = sha;\n  let count = 0;\n  let oldest: string | undefined;\n  let truncated = false;\n  for (let i = 0; ; i++) {\n    if (!cur) break; // reached history root — the whole range is covered\n    if (sinceSha && cur === sinceSha) break; // reached the exclusive lower bound\n    if (i >= MAX_COMMIT_WALK) { truncated = true; break; } // hit the cap before the boundary\n    const meta = await codeCommitMeta(region, repositoryName, cur);\n    if (!meta?.date) break;\n    count++;\n    oldest = meta.date;\n    if (!sinceSha) break; // no range → single commit\n    cur = meta.parents?.[0];\n  }\n  // A truncated walk yields a commit NEWER than the true oldest-unshipped commit,\n  // which would UNDERSTATE lead time — omit the fields entirely rather than report a\n  // wrong (too-small) value. Reporting falls back to `unknown`.\n  if (truncated) return {};\n  return oldest ? { commitTimestamp: oldest, commitCount: count } : {};\n}\n\nasync function resolveGitHub(owner: string, repo: string, sha: string, sinceSha: string | undefined, orgId: string | null): Promise<CommitInfo> {\n  const token = await getGitHubToken(orgId);\n  const headers: Record<string, string> = {\n    'Accept': 'application/vnd.github+json',\n    'User-Agent': 'pipeline-builder-forwarder',\n    'X-GitHub-Api-Version': '2022-11-28',\n  };\n  if (token) headers.Authorization = `Bearer ${token}`;\n  const rateLimited = (r: Response) => r.status === 403 || r.status === 429;\n\n  if (sinceSha) {\n    const r = await fetchWithTimeout(`https://api.github.com/repos/${owner}/${repo}/compare/${sinceSha}...${sha}`, { headers });\n    if (rateLimited(r)) { scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS; return {}; }\n    if (r.ok) {\n      const j = await r.json() as { commits?: Array<{ commit?: { committer?: { date?: string }; author?: { date?: string } } }> };\n      const commits = Array.isArray(j.commits) ? j.commits : [];\n      if (commits.length > 0) {\n        const oldest = toIso(commits[0]?.commit?.committer?.date ?? commits[0]?.commit?.author?.date);\n        if (oldest) return { commitTimestamp: oldest, commitCount: commits.length };\n      }\n    }\n    // fall through to single-commit resolution\n  }\n  const r2 = await fetchWithTimeout(`https://api.github.com/repos/${owner}/${repo}/commits/${sha}`, { headers });\n  if (rateLimited(r2)) { scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS; return {}; }\n  if (r2.ok) {\n    const j = await r2.json() as { commit?: { committer?: { date?: string }; author?: { date?: string } } };\n    const d = toIso(j.commit?.committer?.date ?? j.commit?.author?.date);\n    if (d) return { commitTimestamp: d, commitCount: 1 };\n  }\n  return {};\n}\n\nasync function resolveBitbucket(owner: string, repo: string, sha: string): Promise<CommitInfo> {\n  const r = await fetchWithTimeout(`https://api.bitbucket.org/2.0/repositories/${owner}/${repo}/commit/${sha}`, {\n    headers: { 'User-Agent': 'pipeline-builder-forwarder', 'Accept': 'application/json' },\n  });\n  if (r.status === 429) { scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS; return {}; }\n  if (r.ok) {\n    const j = await r.json() as { date?: string };\n    const d = toIso(j.date);\n    if (d) return { commitTimestamp: d, commitCount: 1 };\n  }\n  return {};\n}\n\n/**\n * Resolve `commitTimestamp` + `commitCount` for a source/deploy event, in-account,\n * best-effort. Computed once per (pipelineId, sha); advances the pipeline's range\n * boundary only on success. Never throws — returns {} on any failure.\n */\nasync function resolveCommitInfo(pipelineId: string, orgId: string | null, region: string, src: SourceRef): Promise<CommitInfo> {\n  if (src.provider === 'unknown') return {};\n  const rkey = `${pipelineId}|${src.sha}`;\n  const cached = commitResultCache.get(rkey);\n  if (cached) return cached;\n\n  const prev = lastShaByPipeline.get(pipelineId);\n  const sinceSha = prev && prev !== src.sha ? prev : undefined;\n\n  let info: CommitInfo = {};\n  try {\n    if (src.provider === 'codecommit' && src.repositoryName) {\n      info = await resolveCodeCommit(region, src.repositoryName, src.sha, sinceSha);\n    } else if (src.provider === 'github' && src.owner && src.repo) {\n      if (Date.now() >= scmCooldownUntil) info = await resolveGitHub(src.owner, src.repo, src.sha, sinceSha, orgId);\n    } else if (src.provider === 'bitbucket' && src.owner && src.repo) {\n      if (Date.now() >= scmCooldownUntil) info = await resolveBitbucket(src.owner, src.repo, src.sha);\n    }\n  } catch (err) {\n    log.warn('Commit resolution failed (omitting commitTimestamp/commitCount)', { provider: src.provider, error: (err as { name?: string })?.name ?? String(err) });\n    info = {};\n  }\n\n  commitResultCache.set(rkey, info);\n  if (info.commitTimestamp) lastShaByPipeline.set(pipelineId, src.sha);\n  return info;\n}\n\n// ─── Event Parsing ──────────────────────────────────────\n\ninterface 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 (Phase 4). 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. */\nasync 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  const startedAt = (detail['start-time'] as string) || 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    if (startedAt && completedAt) {\n      const ms = new Date(completedAt).getTime() - new Date(startedAt).getTime();\n      if (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  // Phase 4 — 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\n// ─── Phase 3: 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 Map<string, number>();\nconst lastEventAtByOrg = new Map<string, string>();\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 fetch(`${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 */\nasync 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// ─── Handler ────────────────────────────────────────────\n\nexport const handler = async (event: SQSEvent): Promise<void> => {\n  const baseUrl = process.env.PLATFORM_BASE_URL;\n  if (!baseUrl) throw new Error('PLATFORM_BASE_URL environment variable is required');\n\n  // Parse + resolve all records (tag + commit lookups run concurrently); drop\n  // intentional skips (null). A malformed record BODY is handled inside parseRecord\n  // (logged + skipped) so one bad message can't fail the whole batch — while genuine\n  // infra errors (e.g. AccessDenied on the tag lookup) still propagate so a missing\n  // IAM grant surfaces and SQS retries the batch.\n  const events = (await Promise.all(event.Records.map(parseRecord)))\n    .filter((e): e is ParsedEvent => e !== null);\n  if (events.length === 0) {\n    log.info('No resolvable CodePipeline events in batch');\n    return;\n  }\n\n  // POST batch to reporting service. On a 401/403 the credential this container\n  // holds is stale — most often because the token-renew Lambda rotated the key in\n  // Secrets Manager — so drop BOTH the cached token and the cached key, re-read,\n  // and retry ONCE. `orgId` is INTERNAL (token/health keying) — strip it here so\n  // it never rides the wire; the ingest resolves org from the pipeline registry,\n  // not the body.\n  const payloadEvents = events.map(({ orgId: _orgId, ...rest }) => rest);\n  const post = (token: string) => fetch(`${baseUrl}/api/reports/events`, {\n    method: 'POST',\n    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },\n    body: JSON.stringify({ events: payloadEvents }),\n  });\n  let res = await post(await getAuthToken());\n  if (res.status === 401 || res.status === 403) {\n    log.warn('Reporting API auth failed; re-reading the stored key and retrying once', { status: res.status });\n    invalidateCredential();\n    res = await post(await getAuthToken());\n  }\n\n  if (!res.ok) {\n    const body = await res.text().catch(() => '');\n    log.error(`Reporting API returned ${res.status}`, { body });\n    throw new Error(`Reporting API failed: ${res.status}`);\n  }\n\n  // The insert already succeeded (2xx). The parsed body is only used for a log\n  // line, so a non-JSON/empty body must not throw and fail the whole batch —\n  // that would trigger an SQS redelivery and re-POST (duplicate) already-inserted\n  // events. The ingest's partial-unique index dedupes, but avoid the churn anyway.\n  const result = await res.json().catch(() => ({})) as Record<string, unknown>;\n  log.info(`Ingested ${events.length} events`, { inserted: result.data });\n\n  // Accumulate delivery-health counters PER RESOLVED ORG, then run the throttled\n  // post-success health + self-healing DLQ redrive (best-effort, never fails batch).\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  await reportHealthAndRedrive(baseUrl, event.Records[0]?.eventSourceARN);\n};\n\n/**\n * @internal Test-only: reset all module-level caches/throttle state so tests are\n * isolated from one another. Stripped from the published .d.ts (stripInternal).\n */\nexport function _resetForTests(): void {\n  resolvedByArn.clear();\n  commitResultCache.clear();\n  lastShaByPipeline.clear();\n  commitMetaCache.clear();\n  scmCooldownUntil = 0;\n  githubTokenByOrg.clear();\n  forwardedByOrg.clear();\n  lastEventAtByOrg.clear();\n  lastHealthAt = 0;\n  lastRedriveAt = 0;\n  cachedKey = null;\n  cachedToken = null;\n  cachedTokenExpiresAt = 0;\n}\n"]}