@pipeline-builder/pipeline-events 0.0.1

package/lib/index.js

@@ -0,0 +1,834 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+let codepipelineMod;
+async function loadCodePipeline() {
+    if (!codepipelineMod)
+        codepipelineMod = (await import('@aws-sdk/client-codepipeline'));
+    return codepipelineMod;
+}
+// Variable-specifier loader for SDK clients that are NOT static devDependencies of
+// this package (present only in the Lambda runtime / jest mocks). Passing the
+// specifier as a `string` keeps `tsc` from resolving the module at build time.
+async function loadSdk(pkg) {
+    return (await import(pkg));
+}
+/**
+ * Pipeline event ingestion Lambda handler.
+ *
+ * Receives CodePipeline/CodeBuild events from SQS (sourced by EventBridge),
+ * parses them into a normalized format, and POSTs them to the reporting service
+ * via PLATFORM_BASE_URL.
+ *
+ * Authentication:
+ * - PLATFORM_TOKEN env var (preferred — no Secrets Manager call)
+ * - PLATFORM_SECRET_NAME env var → reads the JWT (password) from Secrets Manager
+ *
+ * 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> }
+ * - EVENT_DLQ_ARN — (optional) override for the dead-letter queue ARN used by the
+ *   self-healing redrive; defaults to `<main-queue-arn>-dlq` derived from the SQS
+ *   trigger's eventSourceARN.
+ */
+const log = {
+    info: (msg, data) => console.log(JSON.stringify({ level: 'INFO', message: msg, data, ts: new Date().toISOString() })),
+    warn: (msg, data) => console.log(JSON.stringify({ level: 'WARN', message: msg, data, ts: new Date().toISOString() })),
+    error: (msg, data) => console.error(JSON.stringify({ level: 'ERROR', message: msg, data, ts: new Date().toISOString() })),
+};
+// ── Tag resolution: pb.pipeline-id + pb.deploys ──────────
+// Pipelines are tagged at CDK synth with:
+//   pb.pipeline-id = <platform pipelineId>
+//   pb.deploys     = <stage>:<env> pairs joined by '+', e.g.
+//                    "Deploy-stg:staging+Deploy-prod:production"
+// We resolve those tags from the live CodePipeline (region-aware). The ARN/account
+// never leave AWS, so there's no masking. Cached per ARN (warm-container) to avoid
+// hammering the ListTags API.
+//
+// Requires the Lambda execution role to allow `codepipeline:ListTagsForResource`.
+// AccessDenied is a config error (alert loudly); a missing pb.pipeline-id tag is
+// treated as "not yet registered" (skip).
+const PIPELINE_ID_TAG = 'pb.pipeline-id';
+const DEPLOYS_TAG = 'pb.deploys';
+// Canonical per-pipeline org tag (applied at synth by pipeline-core). It is the
+// RESOLVED org for every event of this pipeline — used to key the per-org GitHub
+// token and to attribute ingest-health. orgId is a platform id, never an AWS
+// account id, so it is safe to read/forward.
+const ORG_ID_TAG = 'OrgId';
+const clientsByRegion = new Map();
+// pipelineId=null is a negative cache (resolved-but-untagged); `ts` lets negatives
+// expire so a pipeline tagged AFTER its first event becomes resolvable without
+// recycling the warm container. Positive results stay cached for the lifetime.
+const resolvedByArn = new Map();
+const NEG_CACHE_TTL_MS = 5 * 60 * 1000;
+/** Cap on commit/ref/environment fields — the ingest contract allows max 255. */
+const MAX_ATTR = 255;
+/**
+ * Parse the `pb.deploys` tag value into a stage→environment map. The value is
+ * `<stage>:<env>` pairs joined by `+` (CodePipeline-tag-safe; no JSON). A stage
+ * present here is a deploy; its mapped environment is what the forwarder stamps on
+ * that stage's STAGE/ACTION events (DORA deploy attribution). Malformed pairs are
+ * skipped defensively.
+ */
+function parseDeploys(value) {
+    const map = new Map();
+    if (!value)
+        return map;
+    for (const pair of value.split('+')) {
+        const idx = pair.indexOf(':');
+        if (idx <= 0)
+            continue;
+        const stage = pair.slice(0, idx).trim();
+        const env = pair.slice(idx + 1).trim();
+        if (stage && env)
+            map.set(stage, env.slice(0, MAX_ATTR));
+    }
+    return map;
+}
+async function pipelineClient(region) {
+    let client = clientsByRegion.get(region);
+    if (!client) {
+        const { CodePipelineClient } = await loadCodePipeline();
+        client = new CodePipelineClient({ region });
+        clientsByRegion.set(region, client);
+    }
+    return client;
+}
+/**
+ * Resolve a CodePipeline's tags → the platform pipelineId (pb.pipeline-id) plus the
+ * deploy-stage→environment map (pb.deploys). `pipelineId` is null when the pipeline
+ * has no pb.pipeline-id tag (unregistered). Throws on AccessDenied so a missing IAM
+ * grant surfaces loudly instead of silently dropping every event.
+ */
+async function resolvePipeline(arn, region) {
+    const cached = resolvedByArn.get(arn);
+    // Serve a positive hit for the container lifetime; serve a negative hit only
+    // until it expires (then re-resolve, in case the pipeline was since tagged).
+    if (cached && (cached.pipelineId !== null || Date.now() - cached.ts < NEG_CACHE_TTL_MS)) {
+        return { pipelineId: cached.pipelineId, orgId: cached.orgId, deploys: cached.deploys };
+    }
+    try {
+        const client = await pipelineClient(region);
+        const { ListTagsForResourceCommand } = await loadCodePipeline();
+        const out = await client.send(new ListTagsForResourceCommand({ resourceArn: arn }));
+        const pipelineId = out.tags?.find(t => t.key === PIPELINE_ID_TAG)?.value ?? null;
+        const orgId = out.tags?.find(t => t.key === ORG_ID_TAG)?.value ?? null;
+        const deploys = parseDeploys(out.tags?.find(t => t.key === DEPLOYS_TAG)?.value);
+        if (!pipelineId)
+            log.warn('Pipeline missing pb.pipeline-id tag — skipping (register it?)', { arn });
+        resolvedByArn.set(arn, { pipelineId, orgId, deploys, ts: Date.now() });
+        return { pipelineId, orgId, deploys };
+    }
+    catch (err) {
+        const name = err?.name;
+        if (name === 'AccessDeniedException') {
+            // Don't cache — this is a fixable misconfig, not a property of the pipeline.
+            log.error('AccessDenied calling codepipeline:ListTagsForResource — grant it to the Lambda role', { arn, error: name });
+            throw err;
+        }
+        // Transient/infra errors (throttling, timeouts, 5xx) MUST propagate so the SQS
+        // batch is retried rather than silently dropping the event — an event dropped
+        // BEFORE it reaches the ingest is lost permanently (the ingest's partial-unique
+        // index only dedupes events that were actually POSTed). Only swallow when the
+        // failure is a definitive answer that this ARN has no usable tag.
+        const e = err;
+        const status = e.$metadata?.httpStatusCode;
+        const retryable = e.$retryable != null
+            || (typeof status === 'number' && status >= 500)
+            || /throttl|timeout|toomanyrequests|serviceunavailable|econnreset|networkingerror/i.test(name ?? '');
+        if (retryable) {
+            log.error('Transient error resolving pb.pipeline-id tag — will retry the batch', { arn, error: name ?? String(err) });
+            throw err;
+        }
+        log.error('Failed to resolve pb.pipeline-id tag', { arn, error: name ?? String(err) });
+        return { pipelineId: null, orgId: null, deploys: new Map() };
+    }
+}
+// ─── Auth ───────────────────────────────────────────────
+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;
+    }
+    // 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');
+    }
+    log.info(`Fetching token 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');
+    }
+    cachedToken = token;
+    log.info('Using stored JWT token from Secrets Manager');
+    return cachedToken;
+}
+// Per-(pipeline,sha) resolved result — computed once, reused across the many events
+// (PIPELINE/STAGE/ACTION) that share a source revision and across redeliveries.
+const commitResultCache = new Map();
+// Last sha we successfully resolved per pipeline — the exclusive lower bound for the
+// next range ("commits since the last deploy"). In-memory only: a cold start resets
+// it, so the first post-cold event resolves as a single commit (expected, defensive).
+const lastShaByPipeline = new Map();
+// Per-sha CodeCommit metadata cache (date + first-parent) for range walks.
+const commitMetaCache = new Map();
+// SCM rate-limit cooldown: after a 403/429 we stop calling the SCM for a while.
+let scmCooldownUntil = 0;
+const SCM_COOLDOWN_MS = 2 * 60 * 1000;
+// Cap the CodeCommit first-parent walk so a long range can't blow the Lambda timeout.
+const MAX_COMMIT_WALK = 50;
+// Per-request timeout for external SCM calls (defensive against slow/hung hosts).
+const SCM_FETCH_TIMEOUT_MS = 3000;
+// The forwarder is a fleet Lambda: one warm container resolves events for MANY
+// orgs, so the GitHub token MUST be keyed by the event's resolved org (not a single
+// container-global token). Each org's token lives at `<prefix>/<orgId>/github-token`,
+// derived from PLATFORM_SECRET_NAME (`<prefix>/<containerOrg>/platform`). null caches
+// a definitive miss (no secret / read failed) → unauthenticated best-effort.
+const githubTokenByOrg = new Map();
+/**
+ * Derive a specific org's github-token secret name from PLATFORM_SECRET_NAME
+ * (`<prefix>/<containerOrg>/platform`). With an `orgId` we swap the org segment
+ * (`<prefix>/<orgId>/github-token`); without one (pipeline carried no OrgId tag) we
+ * fall back to the container's own sibling secret. Returns undefined when
+ * PLATFORM_SECRET_NAME isn't the expected `.../platform` shape.
+ */
+function githubTokenSecretName(orgId) {
+    const name = process.env.PLATFORM_SECRET_NAME;
+    if (!name || !name.endsWith('/platform'))
+        return undefined;
+    const base = name.slice(0, -'/platform'.length); // <prefix>/<containerOrg>
+    if (orgId) {
+        const slash = base.lastIndexOf('/');
+        const prefix = slash > 0 ? base.slice(0, slash) : base;
+        return `${prefix}/${orgId}/github-token`;
+    }
+    return `${base}/github-token`;
+}
+/** Read (and cache, per org) the org github token; null → unauthenticated best-effort. */
+async function getGitHubToken(orgId) {
+    const key = orgId ?? '';
+    const cached = githubTokenByOrg.get(key);
+    if (cached !== undefined)
+        return cached;
+    const secretName = githubTokenSecretName(orgId);
+    if (!secretName) {
+        githubTokenByOrg.set(key, null);
+        return null;
+    }
+    let token;
+    try {
+        const client = new SecretsManagerClient({});
+        const res = await client.send(new GetSecretValueCommand({ SecretId: secretName }));
+        // The github-token secret is a RAW token string (not JSON — CDK resolves it via
+        // the default SecretString with no key).
+        token = res.SecretString && res.SecretString.length > 0 ? res.SecretString.trim() : null;
+    }
+    catch (err) {
+        log.warn('No github-token secret — GitHub commit resolution will be unauthenticated', { orgId, error: err?.name });
+        token = null;
+    }
+    githubTokenByOrg.set(key, token);
+    return token;
+}
+async function fetchWithTimeout(url, opts) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), SCM_FETCH_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...opts, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Normalize a commit date to ISO 8601. Accepts ISO strings and CodeCommit's
+ *  "<epoch-seconds> +ZZZZ" form. Returns undefined when unparseable. */
+function toIso(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return undefined;
+    const epoch = /^(\d{9,})\b/.exec(value.trim());
+    if (epoch) {
+        const d = new Date(Number(epoch[1]) * 1000);
+        return Number.isNaN(d.getTime()) ? undefined : d.toISOString();
+    }
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? undefined : d.toISOString();
+}
+/** Classify a source-revision URL into a provider + repo coordinates. */
+function classifySource(url) {
+    if (!url)
+        return { provider: 'unknown' };
+    try {
+        const u = new URL(url);
+        const host = u.hostname.toLowerCase();
+        if (host === 'github.com' || host.endsWith('.github.com')) {
+            const parts = u.pathname.split('/').filter(Boolean);
+            if (parts.length >= 2)
+                return { provider: 'github', owner: parts[0], repo: parts[1].replace(/\.git$/, '') };
+        }
+        if (host === 'bitbucket.org') {
+            const parts = u.pathname.split('/').filter(Boolean);
+            if (parts.length >= 2)
+                return { provider: 'bitbucket', owner: parts[0], repo: parts[1].replace(/\.git$/, '') };
+        }
+        if (u.pathname.toLowerCase().includes('codecommit') || u.hash.toLowerCase().includes('codecommit') || u.pathname.includes('/repositories/')) {
+            const m = /repositor(?:y|ies)\/([^/#?]+)/.exec(u.pathname + u.hash);
+            if (m)
+                return { provider: 'codecommit', repositoryName: decodeURIComponent(m[1]) };
+        }
+    }
+    catch {
+        // not a URL → unknown
+    }
+    return { provider: 'unknown' };
+}
+let codecommitClientsByRegion;
+let codecommitMod;
+async function codeCommitClient(region) {
+    if (!codecommitMod)
+        codecommitMod = await loadSdk('@aws-sdk/client-codecommit');
+    if (!codecommitClientsByRegion)
+        codecommitClientsByRegion = new Map();
+    let client = codecommitClientsByRegion.get(region);
+    if (!client) {
+        client = new codecommitMod.CodeCommitClient({ region });
+        codecommitClientsByRegion.set(region, client);
+    }
+    return client;
+}
+/** Fetch (cached) a single CodeCommit commit's date + first parents via GetCommit. */
+async function codeCommitMeta(region, repositoryName, commitId) {
+    const cached = commitMetaCache.get(commitId);
+    if (cached)
+        return cached;
+    if (!codecommitMod)
+        codecommitMod = await loadSdk('@aws-sdk/client-codecommit');
+    const client = await codeCommitClient(region);
+    const out = await client.send(new codecommitMod.GetCommitCommand({ repositoryName, commitId }));
+    const commit = out.commit;
+    const meta = { date: toIso(commit?.committer?.date ?? commit?.author?.date), parents: commit?.parents };
+    commitMetaCache.set(commitId, meta);
+    return meta;
+}
+async function resolveCodeCommit(region, repositoryName, sha, sinceSha) {
+    let cur = sha;
+    let count = 0;
+    let oldest;
+    let truncated = false;
+    for (let i = 0;; i++) {
+        if (!cur)
+            break; // reached history root — the whole range is covered
+        if (sinceSha && cur === sinceSha)
+            break; // reached the exclusive lower bound
+        if (i >= MAX_COMMIT_WALK) {
+            truncated = true;
+            break;
+        } // hit the cap before the boundary
+        const meta = await codeCommitMeta(region, repositoryName, cur);
+        if (!meta?.date)
+            break;
+        count++;
+        oldest = meta.date;
+        if (!sinceSha)
+            break; // no range → single commit
+        cur = meta.parents?.[0];
+    }
+    // A truncated walk yields a commit NEWER than the true oldest-unshipped commit,
+    // which would UNDERSTATE lead time — omit the fields entirely rather than report a
+    // wrong (too-small) value. Reporting falls back to `unknown`.
+    if (truncated)
+        return {};
+    return oldest ? { commitTimestamp: oldest, commitCount: count } : {};
+}
+async function resolveGitHub(owner, repo, sha, sinceSha, orgId) {
+    const token = await getGitHubToken(orgId);
+    const headers = {
+        'Accept': 'application/vnd.github+json',
+        'User-Agent': 'pipeline-builder-forwarder',
+        'X-GitHub-Api-Version': '2022-11-28',
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const rateLimited = (r) => r.status === 403 || r.status === 429;
+    if (sinceSha) {
+        const r = await fetchWithTimeout(`https://api.github.com/repos/${owner}/${repo}/compare/${sinceSha}...${sha}`, { headers });
+        if (rateLimited(r)) {
+            scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
+            return {};
+        }
+        if (r.ok) {
+            const j = await r.json();
+            const commits = Array.isArray(j.commits) ? j.commits : [];
+            if (commits.length > 0) {
+                const oldest = toIso(commits[0]?.commit?.committer?.date ?? commits[0]?.commit?.author?.date);
+                if (oldest)
+                    return { commitTimestamp: oldest, commitCount: commits.length };
+            }
+        }
+        // fall through to single-commit resolution
+    }
+    const r2 = await fetchWithTimeout(`https://api.github.com/repos/${owner}/${repo}/commits/${sha}`, { headers });
+    if (rateLimited(r2)) {
+        scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
+        return {};
+    }
+    if (r2.ok) {
+        const j = await r2.json();
+        const d = toIso(j.commit?.committer?.date ?? j.commit?.author?.date);
+        if (d)
+            return { commitTimestamp: d, commitCount: 1 };
+    }
+    return {};
+}
+async function resolveBitbucket(owner, repo, sha) {
+    const r = await fetchWithTimeout(`https://api.bitbucket.org/2.0/repositories/${owner}/${repo}/commit/${sha}`, {
+        headers: { 'User-Agent': 'pipeline-builder-forwarder', 'Accept': 'application/json' },
+    });
+    if (r.status === 429) {
+        scmCooldownUntil = Date.now() + SCM_COOLDOWN_MS;
+        return {};
+    }
+    if (r.ok) {
+        const j = await r.json();
+        const d = toIso(j.date);
+        if (d)
+            return { commitTimestamp: d, commitCount: 1 };
+    }
+    return {};
+}
+/**
+ * Resolve `commitTimestamp` + `commitCount` for a source/deploy event, in-account,
+ * best-effort. Computed once per (pipelineId, sha); advances the pipeline's range
+ * boundary only on success. Never throws — returns {} on any failure.
+ */
+async function resolveCommitInfo(pipelineId, orgId, region, src) {
+    if (src.provider === 'unknown')
+        return {};
+    const rkey = `${pipelineId}|${src.sha}`;
+    const cached = commitResultCache.get(rkey);
+    if (cached)
+        return cached;
+    const prev = lastShaByPipeline.get(pipelineId);
+    const sinceSha = prev && prev !== src.sha ? prev : undefined;
+    let info = {};
+    try {
+        if (src.provider === 'codecommit' && src.repositoryName) {
+            info = await resolveCodeCommit(region, src.repositoryName, src.sha, sinceSha);
+        }
+        else if (src.provider === 'github' && src.owner && src.repo) {
+            if (Date.now() >= scmCooldownUntil)
+                info = await resolveGitHub(src.owner, src.repo, src.sha, sinceSha, orgId);
+        }
+        else if (src.provider === 'bitbucket' && src.owner && src.repo) {
+            if (Date.now() >= scmCooldownUntil)
+                info = await resolveBitbucket(src.owner, src.repo, src.sha);
+        }
+    }
+    catch (err) {
+        log.warn('Commit resolution failed (omitting commitTimestamp/commitCount)', { provider: src.provider, error: err?.name ?? String(err) });
+        info = {};
+    }
+    commitResultCache.set(rkey, info);
+    if (info.commitTimestamp)
+        lastShaByPipeline.set(pipelineId, src.sha);
+    return info;
+}
+/** Cap on the stored failure summary — CodeBuild/Deploy summaries can be long. */
+const MAX_ERROR_MESSAGE = 4000;
+/** First non-empty string among the candidates, capped to the ingest max. */
+function firstAttr(...vals) {
+    for (const v of vals) {
+        if (typeof v === 'string' && v.length > 0)
+            return v.slice(0, MAX_ATTR);
+    }
+    return undefined;
+}
+/**
+ * Best-effort extraction of the source commit id + ref (and the revision URL, used
+ * only in-account to classify the source type for commit-range resolution) from a
+ * CodePipeline event detail. CodePipeline surfaces the source revision under a few
+ * shapes depending on the event type / source-action; we check the known ones and
+ * leave the fields undefined when none are present (NULL downstream). Never pulls an
+ * ARN/account id: only revision/branch/url string fields are read; the revisionUrl
+ * is consumed in-account (source classification) and never forwarded on its own.
+ */
+function extractCommit(detail) {
+    // `source-revisions` (kebab, EventBridge) / `sourceRevisions` (camel) — first entry.
+    const revs = (detail['source-revisions'] ?? detail.sourceRevisions);
+    const firstRev = Array.isArray(revs) ? revs[0] : undefined;
+    // On source actions the revision id can also ride on `execution-result`.
+    const execResult = detail['execution-result'];
+    const commitSha = firstAttr(detail.commitId, detail.revisionId, firstRev?.revisionId, execResult?.revisionId);
+    const commitRef = firstAttr(detail.commitRef, detail.branch, detail.sourceBranch, firstRev?.branchName, firstRev?.branch);
+    const revisionUrl = typeof firstRev?.revisionUrl === 'string' ? firstRev.revisionUrl : undefined;
+    return { ...(commitSha && { commitSha }), ...(commitRef && { commitRef }), ...(revisionUrl && { revisionUrl }) };
+}
+function classifyEvent(detailType) {
+    if (detailType.includes('Pipeline Execution'))
+        return { eventType: 'PIPELINE', eventSource: 'codepipeline' };
+    if (detailType.includes('Stage Execution'))
+        return { eventType: 'STAGE', eventSource: 'codepipeline' };
+    if (detailType.includes('Action Execution'))
+        return { eventType: 'ACTION', eventSource: 'codepipeline' };
+    // CodeBuild "Build State" events identify a build *project*, not a pipeline, so
+    // parseRecord drops them on the `eventSource !== 'codepipeline'` check below —
+    // the 'BUILD' eventType is never persisted here (plugin BUILD events are
+    // recorded directly by the plugin service). The 'codebuild' source is what
+    // routes the drop; keep this branch only for that.
+    if (detailType.includes('Build State'))
+        return { eventType: 'BUILD', eventSource: 'codebuild' };
+    return { eventType: 'PIPELINE', eventSource: 'codepipeline' };
+}
+/** Parse + resolve one record to a reportable event, or null to skip it. */
+async function parseRecord(record) {
+    let event;
+    // A malformed body is a dead message (retrying won't help) — log + skip it so
+    // it can't fail the whole batch. Resolution errors below (e.g. AccessDenied)
+    // are NOT caught here: those are transient/infra and must propagate to retry.
+    try {
+        event = JSON.parse(record.body);
+    }
+    catch (err) {
+        log.warn('Skipping SQS record with unparseable body', { messageId: record.messageId, error: String(err) });
+        return null;
+    }
+    const { eventType, eventSource } = classifyEvent(event['detail-type']);
+    const detail = { ...event.detail };
+    // The raw account never needs to leave AWS now — drop it from the payload.
+    delete detail.account;
+    // CodeBuild "Build State" events identify a build *project*, not a pipeline,
+    // and a project can be shared across pipelines — there's no clean 1:1 mapping
+    // to a pipeline id, so skip them.
+    if (eventSource !== 'codepipeline') {
+        log.warn('Skipping non-CodePipeline event (no pipeline tag to resolve)', { detailType: event['detail-type'] });
+        return null;
+    }
+    const pipelineName = detail.pipeline;
+    if (!pipelineName) {
+        log.warn('CodePipeline event missing pipeline name — skipping');
+        return null;
+    }
+    // Resolve the pipeline's pb.pipeline-id (= platform pipelineId) + pb.deploys map.
+    // The ARN is only a transient handle for the tag lookup; it is never stored.
+    const arn = `arn:aws:codepipeline:${event.region}:${event.account}:${pipelineName}`;
+    const { pipelineId, orgId, deploys } = await resolvePipeline(arn, event.region);
+    if (!pipelineId)
+        return null; // untagged / unregistered → skip
+    const startedAt = detail['start-time'] || event.time;
+    const state = detail.state;
+    let durationMs;
+    let completedAt;
+    if (['SUCCEEDED', 'FAILED', 'CANCELED', 'STOPPED'].includes(state)) {
+        completedAt = event.time;
+        if (startedAt && completedAt) {
+            const ms = new Date(completedAt).getTime() - new Date(startedAt).getTime();
+            if (ms >= 0)
+                durationMs = ms;
+        }
+    }
+    // Promote the failure reason to a typed field. On Action events AWS puts the
+    // human-readable summary (and a log URL + error-code, which stay in `detail`)
+    // under `execution-result`.
+    const result = detail['execution-result'];
+    const summary = result?.['external-execution-summary'];
+    const errorMessage = typeof summary === 'string' && summary.length > 0
+        ? summary.slice(0, MAX_ERROR_MESSAGE)
+        : undefined;
+    // DORA deploy attribution — all optional: omitted (undefined) when the
+    // event/pipeline doesn't carry them.
+    const { commitSha, commitRef, revisionUrl } = extractCommit(detail);
+    const executionId = detail['execution-id'];
+    const stageName = detail.stage;
+    const actionName = detail.action;
+    // Environment (⇒ isDeploy) is set ONLY when this event's stage is listed in the
+    // pipeline's pb.deploys tag. PIPELINE events have no stage → never a deploy.
+    const environment = stageName ? deploys.get(stageName) : undefined;
+    // Phase 4 — resolve the commit range (oldest-unshipped timestamp + count) for any
+    // event carrying a commit. Best-effort/in-account; omitted on any failure.
+    // GATED on `DORA_ENABLED` (set by `setup-events --with-dora`): DORA lead time is an
+    // advanced_reporting add-on, so orgs without it skip the SCM/secret cost entirely —
+    // standard reporting (commitSha + all other fields) still forwards regardless.
+    let commitTimestamp;
+    let commitCount;
+    if (commitSha && process.env.DORA_ENABLED === 'true') {
+        const src = classifySource(revisionUrl);
+        const info = await resolveCommitInfo(pipelineId, orgId, event.region, { sha: commitSha, ...src });
+        commitTimestamp = info.commitTimestamp;
+        commitCount = info.commitCount;
+    }
+    return {
+        orgId,
+        pipelineId,
+        eventSource,
+        eventType,
+        status: state,
+        executionId,
+        stageName,
+        actionName,
+        errorMessage,
+        startedAt,
+        completedAt,
+        durationMs,
+        ...(commitSha && { commitSha }),
+        ...(commitRef && { commitRef }),
+        ...(commitTimestamp && { commitTimestamp }),
+        ...(commitCount && { commitCount }),
+        ...(environment && { environment }),
+        detail,
+    };
+}
+let sqsMod;
+let sqsClientsByRegion;
+async function sqsClient(region) {
+    if (!sqsMod)
+        sqsMod = await loadSdk('@aws-sdk/client-sqs');
+    if (!sqsClientsByRegion)
+        sqsClientsByRegion = new Map();
+    let client = sqsClientsByRegion.get(region);
+    if (!client) {
+        client = new sqsMod.SQSClient({ region });
+        sqsClientsByRegion.set(region, client);
+    }
+    return client;
+}
+// Delivery-health counters are attributed PER RESOLVED ORG (the forwarder is a fleet
+// Lambda serving many orgs; a single global counter would mis-attribute one org's
+// throughput to another). Keyed by orgId ('' bucket = pipeline with no OrgId tag).
+// The DLQ depth (`dropped`) is genuinely fleet-global — one shared DLQ — so it is a
+// single snapshot posted alongside each org's health, documented as the shared depth.
+const forwardedByOrg = new Map();
+const lastEventAtByOrg = new Map();
+let lastHealthAt = 0;
+let lastRedriveAt = 0;
+const HEALTH_THROTTLE_MS = 60 * 1000;
+const REDRIVE_THROTTLE_MS = 5 * 60 * 1000;
+// Poison-message ceiling: if the oldest DLQ message is older than this, we STOP
+// redriving it (DLQ→main→fail→DLQ would loop forever). Such messages are left for an
+// alarm / manual inspection instead of churning the fleet indefinitely.
+const MAX_DLQ_REDRIVE_AGE_SEC = 6 * 60 * 60; // 6 hours
+/** Parse the SQS trigger ARN and derive the main + DLQ ARNs and the DLQ URL. */
+function deriveQueues(mainQueueArn) {
+    if (!mainQueueArn)
+        return undefined;
+    // arn:aws:sqs:{region}:{account}:{name}
+    const parts = mainQueueArn.split(':');
+    if (parts.length < 6 || parts[2] !== 'sqs')
+        return undefined;
+    const [, , , region, account, name] = parts;
+    const dlqArn = process.env.EVENT_DLQ_ARN || `arn:aws:sqs:${region}:${account}:${name}-dlq`;
+    const dlqName = dlqArn.split(':').pop() ?? `${name}-dlq`;
+    const dlqUrl = `https://sqs.${region}.amazonaws.com/${account}/${dlqName}`;
+    return { region, mainArn: mainQueueArn, dlqArn, dlqUrl };
+}
+/** Snapshot the DLQ depth + the age (seconds) of its oldest message (for the
+ *  poison-message redrive ceiling). Missing/NaN attributes fall back to 0. */
+async function dlqStats(region, dlqUrl) {
+    if (!sqsMod)
+        sqsMod = await loadSdk('@aws-sdk/client-sqs');
+    const client = await sqsClient(region);
+    const out = await client.send(new sqsMod.GetQueueAttributesCommand({
+        QueueUrl: dlqUrl,
+        AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateAgeOfOldestMessage'],
+    }));
+    const n = Number(out.Attributes?.ApproximateNumberOfMessages ?? '0');
+    const age = Number(out.Attributes?.ApproximateAgeOfOldestMessage ?? '0');
+    return {
+        depth: Number.isFinite(n) ? n : 0,
+        oldestAgeSec: Number.isFinite(age) ? age : 0,
+    };
+}
+async function hasActiveMoveTask(region, dlqArn) {
+    if (!sqsMod)
+        sqsMod = await loadSdk('@aws-sdk/client-sqs');
+    const client = await sqsClient(region);
+    const out = await client.send(new sqsMod.ListMessageMoveTasksCommand({ SourceArn: dlqArn }));
+    return (out.Results ?? []).some(t => t.Status === 'RUNNING');
+}
+async function startMoveTask(region, dlqArn, mainArn) {
+    if (!sqsMod)
+        sqsMod = await loadSdk('@aws-sdk/client-sqs');
+    const client = await sqsClient(region);
+    await client.send(new sqsMod.StartMessageMoveTaskCommand({ SourceArn: dlqArn, DestinationArn: mainArn }));
+}
+/** POST one org's ingest-health signal. Returns true only on a confirmed 2xx so the
+ *  caller resets that org's `forwarded` counter ONLY when the signal was accepted
+ *  (a dropped/failed POST must not silently zero the accumulated count). */
+async function postIngestHealth(baseUrl, body) {
+    try {
+        const token = await getAuthToken();
+        const res = await fetch(`${baseUrl}/api/reports/ingest-health`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            log.warn('ingest-health POST returned non-2xx (ignored)', { status: res.status, orgId: body.orgId });
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        log.warn('ingest-health POST failed (ignored)', { error: String(err), orgId: body.orgId });
+        return false;
+    }
+}
+/**
+ * Throttled, best-effort post-success work: emit per-org ingest-health and self-heal
+ * the DLQ. Never throws. `forwarded`/`lastEventAt` accumulate PER ORG across batches
+ * between health posts; `dropped` is the shared fleet DLQ depth snapshot. A per-org
+ * counter is zeroed only after that org's health POST is confirmed 2xx.
+ */
+async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
+    const now = Date.now();
+    if (now - lastHealthAt < HEALTH_THROTTLE_MS)
+        return;
+    lastHealthAt = now;
+    try {
+        const q = deriveQueues(mainQueueArn);
+        let depth = 0;
+        let oldestAgeSec = 0;
+        if (q) {
+            try {
+                const stats = await dlqStats(q.region, q.dlqUrl);
+                depth = stats.depth;
+                oldestAgeSec = stats.oldestAgeSec;
+            }
+            catch (err) {
+                log.warn('DLQ stats check failed (ignored)', { error: err?.name ?? String(err) });
+            }
+        }
+        // Post one health signal per resolved org, attributing its own forwarded count +
+        // last event time. `dropped` (the shared fleet DLQ depth) rides along on each.
+        // Snapshot the keys first so we don't mutate the map while iterating.
+        const orgKeys = new Set([...forwardedByOrg.keys(), ...lastEventAtByOrg.keys()]);
+        if (orgKeys.size === 0)
+            orgKeys.add(''); // nothing forwarded yet → still report depth
+        for (const key of orgKeys) {
+            const forwarded = forwardedByOrg.get(key) ?? 0;
+            const lastEventAt = lastEventAtByOrg.get(key);
+            const ok = await postIngestHealth(baseUrl, {
+                ...(key ? { orgId: key } : {}),
+                forwarded,
+                dropped: depth,
+                lastEventAt,
+            });
+            // Reset the forwarded counter ONLY on a confirmed 2xx — a failed/dropped POST
+            // keeps the count so the next tick re-reports it instead of losing it.
+            if (ok)
+                forwardedByOrg.set(key, 0);
+        }
+        if (q && depth > 0 && now - lastRedriveAt >= REDRIVE_THROTTLE_MS) {
+            // Poison-message ceiling: never redrive a DLQ whose oldest message has aged
+            // past the ceiling — that message keeps failing and would loop DLQ→main→DLQ.
+            if (oldestAgeSec > MAX_DLQ_REDRIVE_AGE_SEC) {
+                log.warn('DLQ oldest message exceeds poison-age ceiling — skipping redrive (needs manual attention)', {
+                    dlqArn: q.dlqArn, dropped: depth, oldestAgeSec, ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC,
+                });
+            }
+            else {
+                try {
+                    if (!(await hasActiveMoveTask(q.region, q.dlqArn))) {
+                        lastRedriveAt = now;
+                        await startMoveTask(q.region, q.dlqArn, q.mainArn);
+                        log.info('Started self-healing DLQ→main redrive', { dlqArn: q.dlqArn, dropped: depth, oldestAgeSec });
+                    }
+                }
+                catch (err) {
+                    log.warn('DLQ redrive failed (ignored)', { error: err?.name ?? String(err) });
+                }
+            }
+        }
+    }
+    catch (err) {
+        log.warn('health/redrive step failed (ignored)', { error: String(err) });
+    }
+}
+// ─── Handler ────────────────────────────────────────────
+export const handler = async (event) => {
+    const baseUrl = process.env.PLATFORM_BASE_URL;
+    if (!baseUrl)
+        throw new Error('PLATFORM_BASE_URL environment variable is required');
+    // Parse + resolve all records (tag + commit lookups run concurrently); drop
+    // intentional skips (null). A malformed record BODY is handled inside parseRecord
+    // (logged + skipped) so one bad message can't fail the whole batch — while genuine
+    // infra errors (e.g. AccessDenied on the tag lookup) still propagate so a missing
+    // IAM grant surfaces and SQS retries the batch.
+    const events = (await Promise.all(event.Records.map(parseRecord)))
+        .filter((e) => e !== null);
+    if (events.length === 0) {
+        log.info('No resolvable CodePipeline events in batch');
+        return;
+    }
+    // POST batch to reporting service. On a 401/403 the 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.
+    const payloadEvents = events.map(({ orgId: _orgId, ...rest }) => rest);
+    const post = (token) => fetch(`${baseUrl}/api/reports/events`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
+        body: JSON.stringify({ events: payloadEvents }),
+    });
+    let res = await post(await getAuthToken());
+    if (res.status === 401 || res.status === 403) {
+        log.warn('Reporting API auth failed; refreshing token and retrying once', { status: res.status });
+        cachedToken = null;
+        res = await post(await getAuthToken());
+    }
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        log.error(`Reporting API returned ${res.status}`, { body });
+        throw new Error(`Reporting API failed: ${res.status}`);
+    }
+    // The insert already succeeded (2xx). The parsed body is only used for a log
+    // line, so a non-JSON/empty body must not throw and fail the whole batch —
+    // that would trigger an SQS redelivery and re-POST (duplicate) already-inserted
+    // events. The ingest's partial-unique index dedupes, but avoid the churn anyway.
+    const result = await res.json().catch(() => ({}));
+    log.info(`Ingested ${events.length} events`, { inserted: result.data });
+    // Accumulate delivery-health counters PER RESOLVED ORG, then run the throttled
+    // post-success health + self-healing DLQ redrive (best-effort, never fails batch).
+    for (const e of events) {
+        const key = e.orgId ?? '';
+        forwardedByOrg.set(key, (forwardedByOrg.get(key) ?? 0) + 1);
+        const at = e.completedAt || e.startedAt;
+        if (at) {
+            const prev = lastEventAtByOrg.get(key);
+            if (!prev || at > prev)
+                lastEventAtByOrg.set(key, at);
+        }
+    }
+    await reportHealthAndRedrive(baseUrl, event.Records[0]?.eventSourceARN);
+};
+/**
+ * @internal Test-only: reset all module-level caches/throttle state so tests are
+ * isolated from one another. Stripped from the published .d.ts (stripInternal).
+ */
+export function _resetForTests() {
+    resolvedByArn.clear();
+    commitResultCache.clear();
+    lastShaByPipeline.clear();
+    commitMetaCache.clear();
+    scmCooldownUntil = 0;
+    githubTokenByOrg.clear();
+    forwardedByOrg.clear();
+    lastEventAtByOrg.clear();
+    lastHealthAt = 0;
+    lastRedriveAt = 0;
+    cachedToken = null;
+}
+//# 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"]}