@pipeline-builder/pipeline-events 4.0.3 → 4.0.5

package/lib/index.js

@@ -1,5 +1,23 @@
 // 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() {
@@ -20,14 +38,20 @@ async function loadSdk(pkg) {
  * parses them into a normalized format, and POSTs them to the reporting service
  * via PLATFORM_BASE_URL.
  *
- * Authentication:
- * - PLATFORM_TOKEN env var (preferred — no Secrets Manager call)
- * - PLATFORM_SECRET_NAME env var → reads the JWT (password) from Secrets Manager
+ * 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_TOKEN — JWT token (set directly, or)
- * - PLATFORM_SECRET_NAME — Secrets Manager secret containing { password: <JWT> }
+ * - 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.
@@ -146,36 +170,143 @@ async function resolvePipeline(arn, region) {
     }
 }
 // ─── 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;
-async function getAuthToken() {
-    if (cachedToken)
-        return cachedToken;
-    // Path 1: PLATFORM_TOKEN env var (no Secrets Manager call)
-    if (process.env.PLATFORM_TOKEN) {
-        cachedToken = process.env.PLATFORM_TOKEN;
-        log.info('Using PLATFORM_TOKEN from environment');
-        return cachedToken;
+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;
     }
-    // Path 2: PLATFORM_SECRET_NAME → read from Secrets Manager
     const secretName = process.env.PLATFORM_SECRET_NAME;
     if (!secretName) {
-        throw new Error('PLATFORM_TOKEN or PLATFORM_SECRET_NAME environment variable is required');
+        throw new Error('PLATFORM_ACCESS_KEY or PLATFORM_SECRET_NAME environment variable is required');
     }
-    log.info(`Fetching token from Secrets Manager: ${secretName}`);
+    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);
-    // infra store-token writes the JWT in `password` (the canonical field — also used by
-    // CodeBuild secretsManagerCredentials, the plugin-lookup Lambda, and token-renew).
-    const token = secret.password;
-    if (!token) {
-        throw new Error('Secret missing JWT (password) — run "pipeline-manager infra store-token" to generate');
+    // `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`);
+    }
+    assertAccessKey(key, `secret "${secretName}"`);
+    cachedKey = key;
+    log.info('Using stored service-account key from Secrets Manager');
+    return cachedKey;
+}
+/** 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,
+        });
     }
-    cachedToken = token;
-    log.info('Using stored JWT token from Secrets Manager');
-    return cachedToken;
+    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');
+        }
+        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.
@@ -772,11 +903,12 @@ export const handler = async (event) => {
         log.info('No resolvable CodePipeline events in batch');
         return;
     }
-    // POST batch to reporting service. On a 401/403 the cached JWT has likely
-    // expired — drop it, re-fetch, and retry ONCE so an expired token doesn't
-    // permanently brick a warm container. `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.
+    // 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',
@@ -785,8 +917,8 @@ export const handler = async (event) => {
     });
     let res = await post(await getAuthToken());
     if (res.status === 401 || res.status === 403) {
-        log.warn('Reporting API auth failed; refreshing token and retrying once', { status: res.status });
-        cachedToken = null;
+        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) {
@@ -829,6 +961,8 @@ export function _resetForTests() {
     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":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAkB9F,IAAI,eAA+C,CAAC;AACpD,KAAK,UAAU,gBAAgB;IAC7B,IAAI,CAAC,eAAe;QAAE,eAAe,GAAG,CAAC,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAkC,CAAC;IACxH,OAAO,eAAe,CAAC;AACzB,CAAC;AAED,mFAAmF;AACnF,8EAA8E;AAC9E,+EAA+E;AAC/E,KAAK,UAAU,OAAO,CAAI,GAAW;IACnC,OAAO,CAAC,MAAM,MAAM,CAAC,GAAG,CAAC,CAAM,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,GAAG,GAAG;IACV,IAAI,EAAE,CAAC,GAAW,EAAE,IAAc,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IACvI,IAAI,EAAE,CAAC,GAAW,EAAE,IAAc,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IACvI,KAAK,EAAE,CAAC,GAAW,EAAE,IAAc,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;CAC5I,CAAC;AAEF,4DAA4D;AAC5D,0CAA0C;AAC1C,2CAA2C;AAC3C,6DAA6D;AAC7D,iEAAiE;AACjE,mFAAmF;AACnF,mFAAmF;AACnF,8BAA8B;AAC9B,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AACjF,0CAA0C;AAE1C,MAAM,eAAe,GAAG,gBAAgB,CAAC;AACzC,MAAM,WAAW,GAAG,YAAY,CAAC;AACjC,gFAAgF;AAChF,iFAAiF;AACjF,6EAA6E;AAC7E,6CAA6C;AAC7C,MAAM,UAAU,GAAG,OAAO,CAAC;AAC3B,MAAM,eAAe,GAAG,IAAI,GAAG,EAAkC,CAAC;AAClE,mFAAmF;AACnF,+EAA+E;AAC/E,+EAA+E;AAC/E,MAAM,aAAa,GAAG,IAAI,GAAG,EAAyG,CAAC;AACvI,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAYvC,iFAAiF;AACjF,MAAM,QAAQ,GAAG,GAAG,CAAC;AAErB;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,KAAyB;IAC7C,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtC,IAAI,CAAC,KAAK;QAAE,OAAO,GAAG,CAAC;IACvB,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,GAAG,IAAI,CAAC;YAAE,SAAS;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACvC,IAAI,KAAK,IAAI,GAAG;YAAE,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,KAAK,UAAU,cAAc,CAAC,MAAc;IAC1C,IAAI,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,EAAE,kBAAkB,EAAE,GAAG,MAAM,gBAAgB,EAAE,CAAC;QACxD,MAAM,GAAG,IAAI,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QAC5C,eAAe,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,eAAe,CAAC,GAAW,EAAE,MAAc;IACxD,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,6EAA6E;IAC7E,6EAA6E;IAC7E,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,KAAK,IAAI,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,EAAE,GAAG,gBAAgB,CAAC,EAAE,CAAC;QACxF,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;IACzF,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,EAAE,0BAA0B,EAAE,GAAG,MAAM,gBAAgB,EAAE,CAAC;QAChE,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,0BAA0B,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;QACpF,MAAM,UAAU,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,eAAe,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC;QACjF,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,UAAU,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC;QACvE,MAAM,OAAO,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,WAAW,CAAC,EAAE,KAAK,CAAC,CAAC;QAChF,IAAI,CAAC,UAAU;YAAE,GAAG,CAAC,IAAI,CAAC,+DAA+D,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;QACpG,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACvE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IACxC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,GAAI,GAAyB,EAAE,IAAI,CAAC;QAC9C,IAAI,IAAI,KAAK,uBAAuB,EAAE,CAAC;YACrC,6EAA6E;YAC7E,GAAG,CAAC,KAAK,CAAC,qFAAqF,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YACvH,MAAM,GAAG,CAAC;QACZ,CAAC;QACD,+EAA+E;QAC/E,8EAA8E;QAC9E,gFAAgF;QAChF,8EAA8E;QAC9E,kEAAkE;QAClE,MAAM,CAAC,GAAG,GAAuF,CAAC;QAClG,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,EAAE,cAAc,CAAC;QAC3C,MAAM,SAAS,GAAG,CAAC,CAAC,UAAU,IAAI,IAAI;eACjC,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,IAAI,GAAG,CAAC;eAC7C,gFAAgF,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QACvG,IAAI,SAAS,EAAE,CAAC;YACd,GAAG,CAAC,KAAK,CAAC,qEAAqE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACtH,MAAM,GAAG,CAAC;QACZ,CAAC;QACD,GAAG,CAAC,KAAK,CAAC,sCAAsC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACvF,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;IAC/D,CAAC;AACH,CAAC;AAED,2DAA2D;AAE3D,IAAI,WAAW,GAAkB,IAAI,CAAC;AAEtC,KAAK,UAAU,YAAY;IACzB,IAAI,WAAW;QAAE,OAAO,WAAW,CAAC;IAEpC,2DAA2D;IAC3D,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;QAC/B,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;QACzC,GAAG,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;QAClD,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,2DAA2D;IAC3D,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;IACpD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;IAC7F,CAAC;IAED,GAAG,CAAC,IAAI,CAAC,wCAAwC,UAAU,EAAE,CAAC,CAAC;IAC/D,MAAM,MAAM,GAAG,IAAI,oBAAoB,CAAC,EAAE,CAAC,CAAC;IAC5C,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,qBAAqB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IAExF,IAAI,CAAC,QAAQ,CAAC,YAAY;QAAE,MAAM,IAAI,KAAK,CAAC,WAAW,UAAU,YAAY,CAAC,CAAC;IAE/E,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,YAAY,CAA2B,CAAC;IAC3E,qFAAqF;IACrF,mFAAmF;IACnF,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC;IAC9B,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,sFAAsF,CAAC,CAAC;IAC1G,CAAC;IAED,WAAW,GAAG,KAAK,CAAC;IACpB,GAAG,CAAC,IAAI,CAAC,6CAA6C,CAAC,CAAC;IACxD,OAAO,WAAW,CAAC;AACrB,CAAC;AA8BD,oFAAoF;AACpF,gFAAgF;AAChF,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAsB,CAAC;AACxD,qFAAqF;AACrF,oFAAoF;AACpF,sFAAsF;AACtF,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAkB,CAAC;AACpD,2EAA2E;AAC3E,MAAM,eAAe,GAAG,IAAI,GAAG,EAAiD,CAAC;AACjF,gFAAgF;AAChF,IAAI,gBAAgB,GAAG,CAAC,CAAC;AACzB,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AACtC,sFAAsF;AACtF,MAAM,eAAe,GAAG,EAAE,CAAC;AAC3B,kFAAkF;AAClF,MAAM,oBAAoB,GAAG,IAAI,CAAC;AAElC,+EAA+E;AAC/E,oFAAoF;AACpF,sFAAsF;AACtF,sFAAsF;AACtF,6EAA6E;AAC7E,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAyB,CAAC;AAE1D;;;;;;GAMG;AACH,SAAS,qBAAqB,CAAC,KAAoB;IACjD,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;IAC9C,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;QAAE,OAAO,SAAS,CAAC;IAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,0BAA0B;IAC3E,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACpC,MAAM,MAAM,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACvD,OAAO,GAAG,MAAM,IAAI,KAAK,eAAe,CAAC;IAC3C,CAAC;IACD,OAAO,GAAG,IAAI,eAAe,CAAC;AAChC,CAAC;AAED,0FAA0F;AAC1F,KAAK,UAAU,cAAc,CAAC,KAAoB;IAChD,MAAM,GAAG,GAAG,KAAK,IAAI,EAAE,CAAC;IACxB,MAAM,MAAM,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACzC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,MAAM,UAAU,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAChD,IAAI,CAAC,UAAU,EAAE,CAAC;QAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAAC,OAAO,IAAI,CAAC;IAAC,CAAC;IAClE,IAAI,KAAoB,CAAC;IACzB,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,oBAAoB,CAAC,EAAE,CAAC,CAAC;QAC5C,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,qBAAqB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;QACnF,gFAAgF;QAChF,yCAAyC;QACzC,KAAK,GAAG,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3F,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CAAC,2EAA2E,EAAE,EAAE,KAAK,EAAE,KAAK,EAAG,GAAyB,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1I,KAAK,GAAG,IAAI,CAAC;IACf,CAAC;IACD,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACjC,OAAO,KAAK,CAAC;AACf,CAAC;AAED,KAAK,UAAU,gBAAgB,CAAC,GAAW,EAAE,IAA6B;IACxE,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,oBAAoB,CAAC,CAAC;IACzE,IAAI,CAAC;QACH,OAAO,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;IAClE,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;AACH,CAAC;AAED;wEACwE;AACxE,SAAS,KAAK,CAAC,KAAc;IAC3B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACtE,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAC/C,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QAC5C,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;IACjE,CAAC;IACD,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;AACjE,CAAC;AAED,yEAAyE;AACzE,SAAS,cAAc,CAAC,GAAuB;IAC7C,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IACzC,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;QACvB,MAAM,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QACtC,IAAI,IAAI,KAAK,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;YAC1D,MAAM,KAAK,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACpD,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;gBAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC;QAC9G,CAAC;QACD,IAAI,IAAI,KAAK,eAAe,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACpD,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;gBAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC;QACjH,CAAC;QACD,IAAI,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAC5I,MAAM,CAAC,GAAG,+BAA+B,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;YACpE,IAAI,CAAC;gBAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACrF,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,sBAAsB;IACxB,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AACjC,CAAC;AAED,IAAI,yBAAgG,CAAC;AAKrG,IAAI,aAA2C,CAAC;AAChD,KAAK,UAAU,gBAAgB,CAAC,MAAc;IAC5C,IAAI,CAAC,aAAa;QAAE,aAAa,GAAG,MAAM,OAAO,CAAmB,4BAA4B,CAAC,CAAC;IAClG,IAAI,CAAC,yBAAyB;QAAE,yBAAyB,GAAG,IAAI,GAAG,EAAE,CAAC;IACtE,IAAI,MAAM,GAAG,yBAAyB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACnD,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,GAAG,IAAI,aAAa,CAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QACxD,yBAAyB,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,sFAAsF;AACtF,KAAK,UAAU,cAAc,CAAC,MAAc,EAAE,cAAsB,EAAE,QAAgB;IACpF,MAAM,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC7C,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAC1B,IAAI,CAAC,aAAa;QAAE,aAAa,GAAG,MAAM,OAAO,CAAmB,4BAA4B,CAAC,CAAC;IAClG,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC9C,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,gBAAgB,CAAC,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,CAE7F,CAAC;IACF,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAC1B,MAAM,IAAI,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IACxG,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACpC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,KAAK,UAAU,iBAAiB,CAAC,MAAc,EAAE,cAAsB,EAAE,GAAW,EAAE,QAAiB;IACrG,IAAI,GAAG,GAAuB,GAAG,CAAC;IAClC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,MAA0B,CAAC;IAC/B,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,KAAK,IAAI,CAAC,GAAG,CAAC,GAAI,CAAC,EAAE,EAAE,CAAC;QACtB,IAAI,CAAC,GAAG;YAAE,MAAM,CAAC,oDAAoD;QACrE,IAAI,QAAQ,IAAI,GAAG,KAAK,QAAQ;YAAE,MAAM,CAAC,oCAAoC;QAC7E,IAAI,CAAC,IAAI,eAAe,EAAE,CAAC;YAAC,SAAS,GAAG,IAAI,CAAC;YAAC,MAAM;QAAC,CAAC,CAAC,kCAAkC;QACzF,MAAM,IAAI,GAAG,MAAM,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,CAAC,CAAC;QAC/D,IAAI,CAAC,IAAI,EAAE,IAAI;YAAE,MAAM;QACvB,KAAK,EAAE,CAAC;QACR,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC;QACnB,IAAI,CAAC,QAAQ;YAAE,MAAM,CAAC,2BAA2B;QACjD,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;IAC1B,CAAC;IACD,gFAAgF;IAChF,mFAAmF;IACnF,8DAA8D;IAC9D,IAAI,SAAS;QAAE,OAAO,EAAE,CAAC;IACzB,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AACvE,CAAC;AAED,KAAK,UAAU,aAAa,CAAC,KAAa,EAAE,IAAY,EAAE,GAAW,EAAE,QAA4B,EAAE,KAAoB;IACvH,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,OAAO,GAA2B;QACtC,QAAQ,EAAE,6BAA6B;QACvC,YAAY,EAAE,4BAA4B;QAC1C,sBAAsB,EAAE,YAAY;KACrC,CAAC;IACF,IAAI,KAAK;QAAE,OAAO,CAAC,aAAa,GAAG,UAAU,KAAK,EAAE,CAAC;IACrD,MAAM,WAAW,GAAG,CAAC,CAAW,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,MAAM,KAAK,GAAG,CAAC;IAE1E,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,CAAC,GAAG,MAAM,gBAAgB,CAAC,gCAAgC,KAAK,IAAI,IAAI,YAAY,QAAQ,MAAM,GAAG,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;QAC5H,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;YAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,CAAC;YAAC,OAAO,EAAE,CAAC;QAAC,CAAC;QACnF,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC;YACT,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,EAAqG,CAAC;YAC5H,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1D,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;gBAC9F,IAAI,MAAM;oBAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;YAC9E,CAAC;QACH,CAAC;QACD,2CAA2C;IAC7C,CAAC;IACD,MAAM,EAAE,GAAG,MAAM,gBAAgB,CAAC,gCAAgC,KAAK,IAAI,IAAI,YAAY,GAAG,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAC/G,IAAI,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC;QAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,CAAC;QAAC,OAAO,EAAE,CAAC;IAAC,CAAC;IACpF,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;QACV,MAAM,CAAC,GAAG,MAAM,EAAE,CAAC,IAAI,EAAgF,CAAC;QACxG,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;QACrE,IAAI,CAAC;YAAE,OAAO,EAAE,eAAe,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;IACvD,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,KAAK,UAAU,gBAAgB,CAAC,KAAa,EAAE,IAAY,EAAE,GAAW;IACtE,MAAM,CAAC,GAAG,MAAM,gBAAgB,CAAC,8CAA8C,KAAK,IAAI,IAAI,WAAW,GAAG,EAAE,EAAE;QAC5G,OAAO,EAAE,EAAE,YAAY,EAAE,4BAA4B,EAAE,QAAQ,EAAE,kBAAkB,EAAE;KACtF,CAAC,CAAC;IACH,IAAI,CAAC,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;QAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,CAAC;QAAC,OAAO,EAAE,CAAC;IAAC,CAAC;IACrF,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC;QACT,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,EAAuB,CAAC;QAC9C,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC;YAAE,OAAO,EAAE,eAAe,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;IACvD,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,iBAAiB,CAAC,UAAkB,EAAE,KAAoB,EAAE,MAAc,EAAE,GAAc;IACvG,IAAI,GAAG,CAAC,QAAQ,KAAK,SAAS;QAAE,OAAO,EAAE,CAAC;IAC1C,MAAM,IAAI,GAAG,GAAG,UAAU,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC;IACxC,MAAM,MAAM,GAAG,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC3C,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAE1B,MAAM,IAAI,GAAG,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC/C,MAAM,QAAQ,GAAG,IAAI,IAAI,IAAI,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IAE7D,IAAI,IAAI,GAAe,EAAE,CAAC;IAC1B,IAAI,CAAC;QACH,IAAI,GAAG,CAAC,QAAQ,KAAK,YAAY,IAAI,GAAG,CAAC,cAAc,EAAE,CAAC;YACxD,IAAI,GAAG,MAAM,iBAAiB,CAAC,MAAM,EAAE,GAAG,CAAC,cAAc,EAAE,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAChF,CAAC;aAAM,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,IAAI,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;YAC9D,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,gBAAgB;gBAAE,IAAI,GAAG,MAAM,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QAChH,CAAC;aAAM,IAAI,GAAG,CAAC,QAAQ,KAAK,WAAW,IAAI,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;YACjE,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,gBAAgB;gBAAE,IAAI,GAAG,MAAM,gBAAgB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;QAClG,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CAAC,iEAAiE,EAAE,EAAE,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,EAAG,GAAyB,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAChK,IAAI,GAAG,EAAE,CAAC;IACZ,CAAC;IAED,iBAAiB,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAClC,IAAI,IAAI,CAAC,eAAe;QAAE,iBAAiB,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACrE,OAAO,IAAI,CAAC;AACd,CAAC;AA0CD,kFAAkF;AAClF,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAE/B,6EAA6E;AAC7E,SAAS,SAAS,CAAC,GAAG,IAAe;IACnC,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACrB,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,aAAa,CAAC,MAA+B;IACpD,qFAAqF;IACrF,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,kBAAkB,CAAC,IAAI,MAAM,CAAC,eAAe,CACpB,CAAC;IAC/C,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3D,yEAAyE;IACzE,MAAM,UAAU,GAAG,MAAM,CAAC,kBAAkB,CAAwC,CAAC;IAErF,MAAM,SAAS,GAAG,SAAS,CACzB,MAAM,CAAC,QAAQ,EACf,MAAM,CAAC,UAAU,EACjB,QAAQ,EAAE,UAAU,EACpB,UAAU,EAAE,UAAU,CACvB,CAAC;IACF,MAAM,SAAS,GAAG,SAAS,CACzB,MAAM,CAAC,SAAS,EAChB,MAAM,CAAC,MAAM,EACb,MAAM,CAAC,YAAY,EACnB,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,MAAM,CACjB,CAAC;IACF,MAAM,WAAW,GAAG,OAAO,QAAQ,EAAE,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IAEjG,OAAO,EAAE,GAAG,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,WAAW,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;AACnH,CAAC;AAED,SAAS,aAAa,CAAC,UAAkB;IACvC,IAAI,UAAU,CAAC,QAAQ,CAAC,oBAAoB,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;IAC7G,IAAI,UAAU,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;IACvG,IAAI,UAAU,CAAC,QAAQ,CAAC,kBAAkB,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;IACzG,gFAAgF;IAChF,+EAA+E;IAC/E,yEAAyE;IACzE,2EAA2E;IAC3E,mDAAmD;IACnD,IAAI,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;IAChG,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;AAChE,CAAC;AAED,4EAA4E;AAC5E,KAAK,UAAU,WAAW,CAAC,MAAiB;IAC1C,IAAI,KAOH,CAAC;IACF,8EAA8E;IAC9E,6EAA6E;IAC7E,8EAA8E;IAC9E,IAAI,CAAC;QACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CAAC,2CAA2C,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC3G,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,aAAa,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;IACvE,MAAM,MAAM,GAAG,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;IACnC,2EAA2E;IAC3E,OAAO,MAAM,CAAC,OAAO,CAAC;IAEtB,6EAA6E;IAC7E,8EAA8E;IAC9E,kCAAkC;IAClC,IAAI,WAAW,KAAK,cAAc,EAAE,CAAC;QACnC,GAAG,CAAC,IAAI,CAAC,8DAA8D,EAAE,EAAE,UAAU,EAAE,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;QAC/G,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,YAAY,GAAG,MAAM,CAAC,QAA8B,CAAC;IAC3D,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,GAAG,CAAC,IAAI,CAAC,qDAAqD,CAAC,CAAC;QAChE,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kFAAkF;IAClF,6EAA6E;IAC7E,MAAM,GAAG,GAAG,wBAAwB,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,OAAO,IAAI,YAAY,EAAE,CAAC;IACpF,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,eAAe,CAAC,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAChF,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC,CAAC,iCAAiC;IAE/D,MAAM,SAAS,GAAI,MAAM,CAAC,YAAY,CAAY,IAAI,KAAK,CAAC,IAAI,CAAC;IACjE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAe,CAAC;IAErC,IAAI,UAA8B,CAAC;IACnC,IAAI,WAA+B,CAAC;IAEpC,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACnE,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC;QACzB,IAAI,SAAS,IAAI,WAAW,EAAE,CAAC;YAC7B,MAAM,EAAE,GAAG,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;YAC3E,IAAI,EAAE,IAAI,CAAC;gBAAE,UAAU,GAAG,EAAE,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,6EAA6E;IAC7E,8EAA8E;IAC9E,4BAA4B;IAC5B,MAAM,MAAM,GAAG,MAAM,CAAC,kBAAkB,CAA2D,CAAC;IACpG,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,4BAA4B,CAAC,CAAC;IACvD,MAAM,YAAY,GAAG,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;QACpE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,iBAAiB,CAAC;QACrC,CAAC,CAAC,SAAS,CAAC;IAEd,uEAAuE;IACvE,qCAAqC;IACrC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IAEpE,MAAM,WAAW,GAAG,MAAM,CAAC,cAAc,CAAuB,CAAC;IACjE,MAAM,SAAS,GAAG,MAAM,CAAC,KAA2B,CAAC;IACrD,MAAM,UAAU,GAAG,MAAM,CAAC,MAA4B,CAAC;IAEvD,gFAAgF;IAChF,6EAA6E;IAC7E,MAAM,WAAW,GAAG,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAEnE,kFAAkF;IAClF,2EAA2E;IAC3E,oFAAoF;IACpF,oFAAoF;IACpF,+EAA+E;IAC/E,IAAI,eAAmC,CAAC;IACxC,IAAI,WAA+B,CAAC;IACpC,IAAI,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY,KAAK,MAAM,EAAE,CAAC;QACrD,MAAM,GAAG,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC;QACxC,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC;QAClG,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QACvC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;IACjC,CAAC;IAED,OAAO;QACL,KAAK;QACL,UAAU;QACV,WAAW;QACX,SAAS;QACT,MAAM,EAAE,KAAK;QACb,WAAW;QACX,SAAS;QACT,UAAU;QACV,YAAY;QACZ,SAAS;QACT,WAAW;QACX,UAAU;QACV,GAAG,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC;QAC/B,GAAG,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC;QAC/B,GAAG,CAAC,eAAe,IAAI,EAAE,eAAe,EAAE,CAAC;QAC3C,GAAG,CAAC,WAAW,IAAI,EAAE,WAAW,EAAE,CAAC;QACnC,GAAG,CAAC,WAAW,IAAI,EAAE,WAAW,EAAE,CAAC;QACnC,MAAM;KACP,CAAC;AACJ,CAAC;AAyBD,IAAI,MAA6B,CAAC;AAClC,IAAI,kBAA0D,CAAC;AAC/D,KAAK,UAAU,SAAS,CAAC,MAAc;IACrC,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,MAAM,OAAO,CAAY,qBAAqB,CAAC,CAAC;IACtE,IAAI,CAAC,kBAAkB;QAAE,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAC;IACxD,IAAI,MAAM,GAAG,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QAC1C,kBAAkB,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,qFAAqF;AACrF,kFAAkF;AAClF,mFAAmF;AACnF,oFAAoF;AACpF,sFAAsF;AACtF,MAAM,cAAc,GAAG,IAAI,GAAG,EAAkB,CAAC;AACjD,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAkB,CAAC;AACnD,IAAI,YAAY,GAAG,CAAC,CAAC;AACrB,IAAI,aAAa,GAAG,CAAC,CAAC;AACtB,MAAM,kBAAkB,GAAG,EAAE,GAAG,IAAI,CAAC;AACrC,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAC1C,gFAAgF;AAChF,qFAAqF;AACrF,wEAAwE;AACxE,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU;AAEvD,gFAAgF;AAChF,SAAS,YAAY,CAAC,YAAgC;IACpD,IAAI,CAAC,YAAY;QAAE,OAAO,SAAS,CAAC;IACpC,wCAAwC;IACxC,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACtC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7D,MAAM,CAAC,EAAE,AAAD,EAAG,AAAD,EAAG,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC;IAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,eAAe,MAAM,IAAI,OAAO,IAAI,IAAI,MAAM,CAAC;IAC3F,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,MAAM,CAAC;IACzD,MAAM,MAAM,GAAG,eAAe,MAAM,kBAAkB,OAAO,IAAI,OAAO,EAAE,CAAC;IAC3E,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AAC3D,CAAC;AAED;8EAC8E;AAC9E,KAAK,UAAU,QAAQ,CAAC,MAAc,EAAE,MAAc;IACpD,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,MAAM,OAAO,CAAY,qBAAqB,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,yBAAyB,CAAC;QACjE,QAAQ,EAAE,MAAM;QAChB,cAAc,EAAE,CAAC,6BAA6B,EAAE,+BAA+B,CAAC;KACjF,CAAC,CAAsG,CAAC;IACzG,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,2BAA2B,IAAI,GAAG,CAAC,CAAC;IACrE,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,6BAA6B,IAAI,GAAG,CAAC,CAAC;IACzE,OAAO;QACL,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjC,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC7C,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,iBAAiB,CAAC,MAAc,EAAE,MAAc;IAC7D,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,MAAM,OAAO,CAAY,qBAAqB,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,2BAA2B,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAE1F,CAAC;IACF,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC;AAC/D,CAAC;AAED,KAAK,UAAU,aAAa,CAAC,MAAc,EAAE,MAAc,EAAE,OAAe;IAC1E,IAAI,CAAC,MAAM;QAAE,MAAM,GAAG,MAAM,OAAO,CAAY,qBAAqB,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,2BAA2B,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AAC5G,CAAC;AAED;;4EAE4E;AAC5E,KAAK,UAAU,gBAAgB,CAAC,OAAe,EAAE,IAAkF;IACjI,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,YAAY,EAAE,CAAC;QACnC,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,OAAO,4BAA4B,EAAE;YAC9D,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,eAAe,EAAE,UAAU,KAAK,EAAE,EAAE;YACnF,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SAC3B,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,GAAG,CAAC,IAAI,CAAC,+CAA+C,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;YACrG,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CAAC,qCAAqC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAC3F,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,sBAAsB,CAAC,OAAe,EAAE,YAAgC;IACrF,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,IAAI,GAAG,GAAG,YAAY,GAAG,kBAAkB;QAAE,OAAO;IACpD,YAAY,GAAG,GAAG,CAAC;IACnB,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;QACrC,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,EAAE,CAAC;YACN,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;gBACjD,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;gBACpB,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;YACpC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,GAAG,CAAC,IAAI,CAAC,kCAAkC,EAAE,EAAE,KAAK,EAAG,GAAyB,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC3G,CAAC;QACH,CAAC;QAED,iFAAiF;QACjF,+EAA+E;QAC/E,sEAAsE;QACtE,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,cAAc,CAAC,IAAI,EAAE,EAAE,GAAG,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAChF,IAAI,OAAO,CAAC,IAAI,KAAK,CAAC;YAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,6CAA6C;QACtF,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,MAAM,SAAS,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC/C,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC9C,MAAM,EAAE,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE;gBACzC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC9B,SAAS;gBACT,OAAO,EAAE,KAAK;gBACd,WAAW;aACZ,CAAC,CAAC;YACH,8EAA8E;YAC9E,uEAAuE;YACvE,IAAI,EAAE;gBAAE,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACrC,CAAC;QAED,IAAI,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,GAAG,GAAG,aAAa,IAAI,mBAAmB,EAAE,CAAC;YACjE,4EAA4E;YAC5E,6EAA6E;YAC7E,IAAI,YAAY,GAAG,uBAAuB,EAAE,CAAC;gBAC3C,GAAG,CAAC,IAAI,CAAC,2FAA2F,EAAE;oBACpG,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,uBAAuB;iBACpF,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC;oBACH,IAAI,CAAC,CAAC,MAAM,iBAAiB,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;wBACnD,aAAa,GAAG,GAAG,CAAC;wBACpB,MAAM,aAAa,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;wBACnD,GAAG,CAAC,IAAI,CAAC,uCAAuC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;oBACxG,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,GAAG,CAAC,IAAI,CAAC,8BAA8B,EAAE,EAAE,KAAK,EAAG,GAAyB,EAAE,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACvG,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CAAC,sCAAsC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;AACH,CAAC;AAED,2DAA2D;AAE3D,MAAM,CAAC,MAAM,OAAO,GAAG,KAAK,EAAE,KAAe,EAAiB,EAAE;IAC9D,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC;IAC9C,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IAEpF,4EAA4E;IAC5E,kFAAkF;IAClF,mFAAmF;IACnF,kFAAkF;IAClF,gDAAgD;IAChD,MAAM,MAAM,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;SAC/D,MAAM,CAAC,CAAC,CAAC,EAAoB,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;IAC/C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,GAAG,CAAC,IAAI,CAAC,4CAA4C,CAAC,CAAC;QACvD,OAAO;IACT,CAAC;IAED,0EAA0E;IAC1E,0EAA0E;IAC1E,kFAAkF;IAClF,6EAA6E;IAC7E,mCAAmC;IACnC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;IACvE,MAAM,IAAI,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,qBAAqB,EAAE;QACrE,MAAM,EAAE,MAAM;QACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,eAAe,EAAE,UAAU,KAAK,EAAE,EAAE;QACnF,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;KAChD,CAAC,CAAC;IACH,IAAI,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,YAAY,EAAE,CAAC,CAAC;IAC3C,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;QAC7C,GAAG,CAAC,IAAI,CAAC,+DAA+D,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;QAClG,WAAW,GAAG,IAAI,CAAC;QACnB,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,YAAY,EAAE,CAAC,CAAC;IACzC,CAAC;IAED,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QACZ,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;QAC9C,GAAG,CAAC,KAAK,CAAC,0BAA0B,GAAG,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5D,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;IACzD,CAAC;IAED,6EAA6E;IAC7E,2EAA2E;IAC3E,gFAAgF;IAChF,iFAAiF;IACjF,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAA4B,CAAC;IAC7E,GAAG,CAAC,IAAI,CAAC,YAAY,MAAM,CAAC,MAAM,SAAS,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAExE,+EAA+E;IAC/E,mFAAmF;IACnF,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;QAC1B,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5D,MAAM,EAAE,GAAG,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,SAAS,CAAC;QACxC,IAAI,EAAE,EAAE,CAAC;YACP,MAAM,IAAI,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACvC,IAAI,CAAC,IAAI,IAAI,EAAE,GAAG,IAAI;gBAAE,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IACD,MAAM,sBAAsB,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,cAAc;IAC5B,aAAa,CAAC,KAAK,EAAE,CAAC;IACtB,iBAAiB,CAAC,KAAK,EAAE,CAAC;IAC1B,iBAAiB,CAAC,KAAK,EAAE,CAAC;IAC1B,eAAe,CAAC,KAAK,EAAE,CAAC;IACxB,gBAAgB,GAAG,CAAC,CAAC;IACrB,gBAAgB,CAAC,KAAK,EAAE,CAAC;IACzB,cAAc,CAAC,KAAK,EAAE,CAAC;IACvB,gBAAgB,CAAC,KAAK,EAAE,CAAC;IACzB,YAAY,GAAG,CAAC,CAAC;IACjB,aAAa,GAAG,CAAC,CAAC;IAClB,WAAW,GAAG,IAAI,CAAC;AACrB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';\nimport type { 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:\n * - PLATFORM_TOKEN env var (preferred — no Secrets Manager call)\n * - PLATFORM_SECRET_NAME env var → reads the JWT (password) from Secrets Manager\n *\n * Environment variables:\n * - PLATFORM_BASE_URL — Base URL of the platform\n * - PLATFORM_TOKEN — JWT token (set directly, or)\n * - PLATFORM_SECRET_NAME — Secrets Manager secret containing { password: <JWT> }\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\nlet cachedToken: string | null = null;\n\nasync function getAuthToken(): Promise<string> {\n  if (cachedToken) return cachedToken;\n\n  // Path 1: PLATFORM_TOKEN env var (no Secrets Manager call)\n  if (process.env.PLATFORM_TOKEN) {\n    cachedToken = process.env.PLATFORM_TOKEN;\n    log.info('Using PLATFORM_TOKEN from environment');\n    return cachedToken;\n  }\n\n  // Path 2: PLATFORM_SECRET_NAME → read from Secrets Manager\n  const secretName = process.env.PLATFORM_SECRET_NAME;\n  if (!secretName) {\n    throw new Error('PLATFORM_TOKEN or PLATFORM_SECRET_NAME environment variable is required');\n  }\n\n  log.info(`Fetching token from Secrets Manager: ${secretName}`);\n  const client = new SecretsManagerClient({});\n  const response = await client.send(new GetSecretValueCommand({ SecretId: secretName }));\n\n  if (!response.SecretString) throw new Error(`Secret \"${secretName}\" is empty`);\n\n  const secret = JSON.parse(response.SecretString) as Record<string, string>;\n  // infra store-token writes the JWT in `password` (the canonical field — also used by\n  // CodeBuild secretsManagerCredentials, the plugin-lookup Lambda, and token-renew).\n  const token = secret.password;\n  if (!token) {\n    throw new Error('Secret missing JWT (password) — run \"pipeline-manager infra store-token\" to generate');\n  }\n\n  cachedToken = token;\n  log.info('Using stored JWT token from Secrets Manager');\n  return cachedToken;\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 cached JWT has likely\n  // expired — drop it, re-fetch, and retry ONCE so an expired token doesn't\n  // permanently brick a warm container. `orgId` is INTERNAL (token/health keying) —\n  // strip it here so it never rides the wire; the ingest resolves org from the\n  // pipeline registry, 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; refreshing token and retrying once', { status: res.status });\n    cachedToken = null;\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  cachedToken = null;\n}\n"]}
+//# 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"]}

package/package.json

@@ -77,7 +77,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "4.0.3",
+  "version": "4.0.5",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },