@telora/daemon 0.22.85 → 0.22.87

package/dist/queries/incident-correlation.d.ts

@@ -0,0 +1,291 @@
+/**
+ * Incident correlation over escalation rows: the ONE reducer every daemon filing
+ * passes through (queries/escalations.ts createEscalation calls it).
+ *
+ * queries/cause-key.ts defines the two keys: a per-detector CAUSE key
+ * (idempotency + dismissal memory) and the cross-detector INCIDENT key (the
+ * execution anchor an observation is about). This module applies them to rows:
+ *
+ *  - STAMPING: every row filed with an anchor carries metadata.incident_key, and
+ *    its own observation is seeded into metadata.symptoms.
+ *  - CORRELATION (correlateFiling): a filing whose incident already has an open
+ *    row IN ITS LANE is attached to that row as a symptom instead of becoming a
+ *    second row. The I/O is injected (incidentIoOver builds it over callApi), so
+ *    this module takes no value import of the API client.
+ *  - KIND DEDUP: a row answers for its own kind, a hand-off row's originalKind (a
+ *    historic promotion refile) / original_cause_key (that refile, or a routing
+ *    decider's MCP filing carrying sourceCauseKey), and every symptom it carries,
+ *    so the kind/column dedup reads in queries/escalations.ts see correlated and
+ *    handed-off rows too.
+ *
+ * The attach/lane contract (decided 2026-09-12, reversible -- readers group rows
+ * by metadata.incident_key and rely on exactly this):
+ *
+ *  1. LANE = the disposition the chokepoint SENDS (after routeFilingDisposition).
+ *     A filing attaches only to an OPEN row of its incident whose disposition is
+ *     the same; with no such row it opens one. The chokepoint sends EVERY daemon
+ *     filing agent_resolvable (an observation, whatever disposition it proposed)
+ *     or with no disposition, so a daemon filing attaches only to its incident's
+ *     open agent_resolvable row (or its plain, disposition-less row) -- never into
+ *     a human-lane row. Human-lane rows (needs_operator / external_wait carrying
+ *     metadata.human_act) are made by AGENTS through the MCP escalate surface,
+ *     which does not pass this reducer. findLaneIncidentRow still matches those
+ *     lanes exactly, so it reads a store holding them correctly, but no daemon
+ *     filing is sent in them. One incident has at most one open daemon-filed row
+ *     per lane, and they share metadata.incident_key.
+ *  2. A row's metadata.symptoms lists its OWN opening symptom plus exactly what
+ *     attached to THAT row -- never a copy of another row's symptoms.
+ *  3. A re-observed cause (the target row already carries its cause key as its
+ *     own, original, or symptom cause key) writes nothing and files nothing. A
+ *     site with no cause key gets the deterministic kind-scoped stand-in.
+ *  4. Exempt in BOTH directions (neither attach nor are attached to): the
+ *     INCIDENT_HOLD_KINDS, whose own row is read by kind as a spawn/cascade hold
+ *     with a kind-keyed close-half. A cross-product filing (targetProductId) also
+ *     never attaches -- the Nexus bridge resolves that row by its own id.
+ *  5. A failed read or attach write degrades to filing the row (same incident
+ *     key, own symptom only); correlation never loses a filing.
+ *  6. A symptom is part of an incident only while its condition is live. When a
+ *     close-half observes its condition clear it resolves its own-kind rows AND
+ *     retires the matching ABSORBED symptoms from the other open rows in the same
+ *     scope (retireClearedSymptoms): metadata.symptoms is rewritten without them
+ *     and each is recorded under metadata.cleared_symptoms (bounded). A row's OWN
+ *     opening symptom (its cause_key / original_cause_key / kind-scoped stand-in)
+ *     is never retired this way -- that row closes only through its own kind's
+ *     close-half. Readers (holds, dedup, the wedge arbiter) read only
+ *     metadata.symptoms, so a retired symptom holds and suppresses nothing.
+ *
+ * Kept free of VALUE imports that reach @telora/daemon-core or the API client, so
+ * the filing chokepoint can depend on it without dragging the mock-loader chain.
+ */
+import type { EscalationResolutionClass } from '@telora/daemon-core';
+import { type IncidentSymptom } from './cause-key.js';
+import type { CallApiDeps } from './shared.js';
+/**
+ * Kinds whose OWN open row is read BY KIND as a HOLD, released by a kind-keyed
+ * close-half: team_failure (the respawn guard), review_coverage_incomplete (the
+ * respawn guard, any disposition), review_handoff_exhausted (the state cascade's
+ * breaker hold). Absorbing one into another row would silently drop the hold, and
+ * absorbing another condition into one would be closed by the hold's own
+ * close-half -- so they never correlate in either direction (their rows still
+ * carry the shared incident_key).
+ */
+export declare const INCIDENT_HOLD_KINDS: ReadonlySet<string>;
+/** The escalation row fields correlation reads (the escalation_list summary shape). */
+export interface IncidentRow {
+    id: string;
+    status?: string | null;
+    disposition?: string | null;
+    escalationKind?: string | null;
+    focusId?: string | null;
+    deliveryId?: string | null;
+    productId?: string | null;
+    createdAt?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+/** First-class provenance a filing resolved to (explicit params already applied). */
+export interface IncidentProvenance {
+    productId?: string;
+    focusId?: string;
+    deliveryId?: string;
+}
+/** The filing fields the incident key and symptoms are derived from. */
+export interface IncidentFilingInput {
+    escalationKind?: string;
+    description: string;
+    metadata?: Record<string, unknown>;
+    anchor?: {
+        branch?: string;
+    };
+    targetProductId?: string;
+}
+/** Pure: the incident key a metadata bag carries, or null. */
+export declare function readIncidentKey(metadata: unknown): string | null;
+/** Pure: the well-formed symptoms a metadata bag carries (malformed entries dropped). */
+export declare function readSymptoms(metadata: unknown): IncidentSymptom[];
+/**
+ * Pure: the branch a filing is about, read from what the site already carries --
+ * anchor.branch (merge + stuck-branch filings), then metadata.branch_name
+ * (stuck_focus_branch), then metadata.branch (ci_run_red).
+ */
+export declare function filingBranch(input: Pick<IncidentFilingInput, 'anchor' | 'metadata'>): string | null;
+/**
+ * Pure: the incident key a filing is stamped with. An inbound notification kind
+ * never joins an incident. An incident_key already in the filing's metadata wins
+ * (a filing that carries its source's key forward); otherwise the key is
+ * derived from the RESOLVED provenance (delivery -> focus -> branch|product).
+ */
+export declare function resolveFilingIncidentKey(input: IncidentFilingInput, provenance: IncidentProvenance): string | null;
+/**
+ * Pure: one filing's observation as an incident symptom. A filing with no
+ * metadata.cause_key (a direct createEscalation site) gets a deterministic
+ * kind-scoped stand-in, so a re-observation maps to the same symptom. The routed
+ * observation's proposed disposition AND proposed human act ride on the symptom, so
+ * neither is lost when the filing attaches to another row: every absorbed
+ * detector's proposal reaches the routing decider, not only the opener's. A
+ * metadata.human_act is carried too, but the daemon chokepoint never writes one, so
+ * no daemon filing's symptom has it.
+ */
+export declare function filingSymptom(input: IncidentFilingInput, key: string, observedAt: string): IncidentSymptom;
+/**
+ * Pure: stamp a filing's metadata with its incident key and append its own
+ * symptom to whatever symptoms it already carries (none for a fresh row, so the
+ * opener is the first entry; a carried list otherwise).
+ * A null key leaves the metadata untouched.
+ */
+export declare function stampIncidentMetadata(input: IncidentFilingInput, key: string | null, observedAt: string): Record<string, unknown> | undefined;
+/** Pure: a row sits in the machine lane (agent_resolvable); everything else is human-facing. */
+export declare function isMachineLaneRow(row: Pick<IncidentRow, 'disposition'>): boolean;
+/** Pure: the cause keys recorded as symptoms on an OPEN row (idempotency survives correlation). */
+export declare function openRowSymptomCauseKeys(row: IncidentRow): string[];
+/** Pure: whether a filing may correlate at all (contract rule 4). */
+export declare function filingMayCorrelate(input: Pick<IncidentFilingInput, 'escalationKind' | 'targetProductId'>): boolean;
+/**
+ * Pure: the OPEN row of incident `key` in the filing's lane (contract rule 1), or
+ * null. Lane = the SENT disposition (null and undefined are one lane). Hold-kind
+ * rows are never a target. Among several, the oldest wins (createdAt ascending;
+ * rows without one keep list order, which escalation_list returns newest-first, so
+ * a later entry is older).
+ */
+export declare function findLaneIncidentRow(rows: readonly IncidentRow[], key: string, disposition: string | null | undefined): IncidentRow | null;
+/** Pure: whether a row already carries `causeKey` -- its own, its original, or a symptom's. */
+export declare function rowCarriesCause(row: IncidentRow, causeKey: string): boolean;
+/** The I/O correlation needs, injected so the reducer stays testable without the API client. */
+export interface IncidentAttachIo {
+    /** The OPEN rows (pending/in_review) a filing may attach to, narrowed server-side by focus when known. */
+    listOpenRows: (opts: {
+        focusId?: string;
+    }) => Promise<IncidentRow[]>;
+    /** Shallow-merge a metadata patch onto a row (escalation_update fields.metadata). */
+    updateMetadata: (escalationId: string, metadata: Record<string, unknown>) => Promise<void>;
+}
+/** The default correlation I/O over a callApi (escalation_list + escalation_update). */
+export declare function incidentIoOver(call: NonNullable<CallApiDeps['callApi']>): IncidentAttachIo;
+/** One filing about to be sent, as the reducer sees it. */
+export interface IncidentCorrelationInput {
+    /** The incident key the filing is stamped with (never null here). */
+    key: string;
+    /** The filing, carrying the ROUTED metadata (human_act / observation). */
+    filing: IncidentFilingInput;
+    /** The disposition the chokepoint sends (the lane). */
+    disposition: string | undefined;
+    /** The resolved focus, to narrow the open-row read. */
+    focusId?: string;
+    observedAt: string;
+}
+/** What the reducer decided. attached / already_carried mean no new row is filed. */
+export interface IncidentCorrelation {
+    outcome: 'attached' | 'already_carried' | 'open_row' | 'attach_failed';
+    /** The lane row attached to, carrying the cause, or whose attach failed; null for open_row. */
+    incidentRowId: string | null;
+    /** A log line for the chokepoint, when there is something to say. */
+    note: string | null;
+    warn: boolean;
+}
+/**
+ * Correlate one filing onto its incident (the contract in the module header):
+ * attach to the open lane row, report a re-observed cause, or tell the chokepoint
+ * to file the row. Never throws -- a failed read or write degrades to open_row /
+ * attach_failed, and the chokepoint files the row.
+ */
+export declare function correlateFiling(input: IncidentCorrelationInput, io: IncidentAttachIo): Promise<IncidentCorrelation>;
+/**
+ * Pure: whether a row answers for `kind` in a DEDUP read: its own column kind,
+ * the legacy metadata.kind, a hand-off row's metadata.originalKind or
+ * original_cause_key, or any symptom correlated onto it (by kind or by a cause key
+ * minted for the kind, `<kind>::...`). Hold reads must NOT use this -- a handed-off
+ * or absorbed condition has no close-half that would clear a hold keyed on it.
+ */
+export declare function rowAnswersForKind(row: IncidentRow, kind: string): boolean;
+/** Pure: a symptom is an observation of `kind` -- by its kind, or by a cause key minted for the kind (`<kind>::...`). */
+export declare function symptomAnswersForKind(symptom: IncidentSymptom, kind: string): boolean;
+/**
+ * Pure: whether a row is about `deliveryId` in a DEDUP read: the delivery_id
+ * column, the metadata fallbacks, or an incident key naming the delivery (a
+ * historic promotion refile is anchored to the focus, so only its carried key names it).
+ */
+export declare function rowNamesDelivery(row: IncidentRow, deliveryId: string): boolean;
+/**
+ * Pure: an OPEN row of `kind` on `focusId` -- the typed focus_id + escalation_kind
+ * columns, or (back-compat, a row filed before the column promotion)
+ * metadata.focusId + metadata.kind. With `matchCorrelated` (DEDUP reads only), also
+ * a row on the focus answering for the kind as a hand-off row or a correlated
+ * symptom (rowAnswersForKind).
+ */
+export declare function isOpenFocusKindRow(row: IncidentRow, focusId: string, kind: string, matchCorrelated?: boolean): boolean;
+/**
+ * Pure: an OPEN worktree-dirty-class row for `focusId` whose kind is in `kinds`.
+ * Shared by hasOpenWorktreeDirtyEscalation (dedup, matchCorrelated) and
+ * resolveOpenWorktreeDirtyEscalations (auto-close, never correlated: it must not
+ * close a row whose own condition is a different one) so both agree on what counts.
+ *
+ * The status re-check is defense-in-depth. The live escalation_list handler
+ * already honors the `statuses` filter server-side, but the invariant "a RESOLVED
+ * worktree-dirty row must never suppress (or be re-resolved as) a legitimate new
+ * escalation" must hold however the rows were fetched (custom `kinds`, a future
+ * caller that forgets the statuses filter, etc.).
+ */
+export declare function isOpenWorktreeDirtyMatch(row: IncidentRow, focusId: string, kinds: ReadonlySet<string>, matchCorrelated?: boolean): boolean;
+/** One retired symptom, recorded on its row under metadata.cleared_symptoms (snake_case JSONB). */
+export interface ClearedSymptom {
+    cause_key: string;
+    escalation_kind: string | null;
+    cleared_at: string;
+    resolution_class: string;
+}
+/**
+ * A close-half's clearing event: WHICH absorbed symptoms its condition clearing
+ * retires, and WHERE. `scope` must be at least as narrow as the close-half's own
+ * row match; a row is touched only when it matches every scope field given, and an
+ * EMPTY scope touches nothing (fail-safe: never org-wide).
+ */
+export interface SymptomClearing {
+    /** Symptom kinds the event clears (symptomAnswersForKind). */
+    kinds?: readonly string[];
+    /** Exact symptom cause keys the event clears. */
+    causeKeys?: readonly string[];
+    scope: {
+        focusId?: string;
+        productId?: string;
+    };
+    /** The class of actor that observed the clearing (the close-half's own resolution class). */
+    resolutionClass: EscalationResolutionClass;
+}
+/** Pure: the well-formed cleared-symptom records a metadata bag carries. */
+export declare function readClearedSymptoms(metadata: unknown): ClearedSymptom[];
+/**
+ * Pure: the cause keys that are a row's OWN -- its metadata.cause_key, a hand-off
+ * row's original_cause_key, and the kind-scoped stand-in its opening symptom got
+ * when filed without a cause key (filingSymptom). Never retired by retirement.
+ */
+export declare function rowOwnCauseKeys(row: IncidentRow): Set<string>;
+/**
+ * Pure: the metadata patch that retires a clearing's matching absorbed symptoms from
+ * one row -- the remaining metadata.symptoms plus metadata.cleared_symptoms with each
+ * retired one appended (de-duped by cause key, newest kept, bounded to
+ * INCIDENT_SYMPTOM_CAP) -- or null when the row is closed, out of scope, or carries
+ * nothing to retire. The row's own opening symptom is never retired.
+ */
+export declare function symptomRetirementPatch(row: IncidentRow, clearing: SymptomClearing, clearedAt: string): {
+    symptoms: IncidentSymptom[];
+    cleared_symptoms: ClearedSymptom[];
+} | null;
+/** What a retirement pass did: symptoms retired, and warnings for the caller to log. */
+export interface SymptomRetirementOutcome {
+    retired: number;
+    warnings: string[];
+}
+/**
+ * Retire a clearing's matching absorbed symptoms from the OPEN rows in its scope
+ * (contract rule 6). `rows` reuses rows the close-half already read for the scope
+ * (no second read); omitted, the open rows are read, narrowed by scope.focusId.
+ * `skipIds` are the close-half's own rows (being resolved, not rewritten). A clearing
+ * of hold kinds only reads nothing -- a hold kind is never absorbed (rule 4).
+ * Best-effort and never throws: a failed read or write becomes a warning and the
+ * pass continues. The write reads-then-writes like an attach (not atomic).
+ */
+export declare function retireClearedSymptoms(clearing: SymptomClearing, io: IncidentAttachIo, opts?: {
+    rows?: readonly IncidentRow[];
+    skipIds?: readonly string[];
+    clearedAt?: string;
+}): Promise<SymptomRetirementOutcome>;
+//# sourceMappingURL=incident-correlation.d.ts.map

package/dist/queries/incident-correlation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incident-correlation.d.ts","sourceRoot":"","sources":["../../src/queries/incident-correlation.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAQL,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAIlD,CAAC;AAEH,uFAAuF;AACvF,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC3C;AAED,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAUD,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,eAAe,EAAE,CAIjE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,UAAU,CAAC,GAAG,MAAM,GAAG,IAAI,CAGnG;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI,CAclH;AASD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,eAAe,CAiB1G;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAOrC;AAUD,gGAAgG;AAChG,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GAAG,OAAO,CAE/E;AAED,mGAAmG;AACnG,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,EAAE,CAElE;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,gBAAgB,GAAG,iBAAiB,CAAC,GAAG,OAAO,CAGlH;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACrC,WAAW,GAAG,IAAI,CAWpB;AASD,+FAA+F;AAC/F,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAI3E;AAED,gGAAgG;AAChG,MAAM,WAAW,gBAAgB;IAC/B,0GAA0G;IAC1G,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACrE,qFAAqF;IACrF,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5F;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,GAAG,gBAAgB,CAa1F;AAED,2DAA2D;AAC3D,MAAM,WAAW,wBAAwB;IACvC,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,MAAM,EAAE,mBAAmB,CAAC;IAC5B,uDAAuD;IACvD,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qFAAqF;AACrF,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,UAAU,GAAG,iBAAiB,GAAG,UAAU,GAAG,eAAe,CAAC;IACvE,+FAA+F;IAC/F,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,qEAAqE;IACrE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,wBAAwB,EAAE,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAsBzH;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMzE;AAED,yHAAyH;AACzH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAK9E;AAID;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,UAAQ,GAAG,OAAO,CAMpH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,eAAe,UAAQ,GACtB,OAAO,CAET;AAID,mGAAmG;AACnG,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,iDAAiD;IACjD,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,KAAK,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,6FAA6F;IAC7F,eAAe,EAAE,yBAAyB,CAAC;CAC5C;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,cAAc,EAAE,CAUvE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAU7D;AAeD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,eAAe,EACzB,SAAS,EAAE,MAAM,GAChB;IAAE,QAAQ,EAAE,eAAe,EAAE,CAAC;IAAC,gBAAgB,EAAE,cAAc,EAAE,CAAA;CAAE,GAAG,IAAI,CAgB5E;AAED,wFAAwF;AACxF,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,eAAe,EACzB,EAAE,EAAE,gBAAgB,EACpB,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5F,OAAO,CAAC,wBAAwB,CAAC,CA0BnC"}