@optimystic/db-p2p 0.24.2 → 0.25.0

package/dist/src/repo/coordinator-repo.d.ts

@@ -1,9 +1,11 @@
-import type { PendRequest, ActionBlocks, IRepo, MessageOptions, CommitResult, GetBlockResults, PendResult, BlockGets, CommitRequest, IKeyNetwork, ICluster, ClusterConsensusConfig, BlockId, ActionRev, ActionContext } from "@optimystic/db-core";
+import type { PendRequest, ActionBlocks, IRepo, MessageOptions, CommitResult, GetBlockResults, PendResult, BlockGets, CommitRequest, IKeyNetwork, ICluster, ClusterConsensusConfig, BlockId, ActionContext } from "@optimystic/db-core";
 import type { PeerId } from "@libp2p/interface";
 import type { FretService } from "p2p-fret";
 import type { IPeerReputation } from "../reputation/types.js";
 import type { ITransactionStateStore } from "../cluster/i-transaction-state-store.js";
+import { type ProofAnchoring } from "../cluster/certified-claims.js";
 import type { ReconcileBlockCallback } from "../cluster/cluster-repo.js";
+import type { CertifiedActionRev } from "../storage/block-archive.js";
 /**
  * Acquire a block's content for a cohort-corroborated revision, from the cohort, and persist it.
  *
@@ -21,10 +23,21 @@ export type AcquireBlockCallback = ReconcileBlockCallback;
  */
 interface LocalClusterWithExecutionTracking extends ICluster {
     wasTransactionExecuted?(messageHash: string): boolean;
+    /** Local storage's verdict for a pend applied during consensus; see ClusterMember.getExecutedPendResult. */
+    getExecutedPendResult?(messageHash: string): PendResult | undefined;
+    /** Local storage's verdict for a commit applied during consensus; see ClusterMember.getExecutedCommitResult. */
+    getExecutedCommitResult?(messageHash: string): CommitResult | undefined;
 }
+/**
+ * A cohort peer's answer to the latest-revision consult. Defined with the archive shape it is
+ * projected from (`storage/block-archive.ts`) and re-exported here so it reads next to the callback
+ * that returns it; see {@link CertifiedActionRev} there for what the optional proof does and does
+ * not mean.
+ */
+export type { CertifiedActionRev } from "../storage/block-archive.js";
 /**
  * Callback to query a cluster peer for their latest revision of a block. Three-way contract:
- *  - resolves an `ActionRev` — the peer answered and holds the block at that revision;
+ *  - resolves a `CertifiedActionRev` — the peer answered and holds the block at that revision;
  *  - resolves `undefined` — the peer answered and holds NOTHING (an absent claim);
  *  - REJECTS — the peer could not be asked at all (dial failure, protocol error).
  *
@@ -36,7 +49,7 @@ interface LocalClusterWithExecutionTracking extends ICluster {
  * harness's `silentPeers` failure knob). Slowness needs no handling here — the caller deadlines
  * each query and treats expiry as silence.
  */
-export type ClusterLatestCallback = (peerId: PeerId, blockId: BlockId, context?: ActionContext) => Promise<ActionRev | undefined>;
+export type ClusterLatestCallback = (peerId: PeerId, blockId: BlockId, context?: ActionContext) => Promise<CertifiedActionRev | undefined>;
 interface CoordinatorRepoComponents {
     storageRepo: IRepo;
     localCluster?: LocalClusterWithExecutionTracking;
@@ -53,6 +66,14 @@ interface CoordinatorRepoComponents {
      * holds the corroborated action as a promotable pending. See {@link AcquireBlockCallback}.
      */
     acquireBlockFromCohort?: AcquireBlockCallback;
+    /**
+     * Optional layer-2 anchoring for the cohort commit proofs the latest-revision consult verifies
+     * (`cluster/certified-claims.ts`): re-derive the block's cohort and LOG the overlap with the
+     * proof's signers, plus surface proofs accepted without that comparison. Purely observational —
+     * never a gate — and absent in production wiring today; `certifyClaim` logs unanchored
+     * acceptance internally regardless.
+     */
+    proofAnchoring?: ProofAnchoring;
 }
 /**
  * Consensus config for the coordinator side, plus the repair yardstick the read-repair path measures
@@ -73,18 +94,19 @@ export declare class CoordinatorRepo implements IRepo {
     private readonly storageRepo;
     private readonly clusterLatestCallback?;
     private readonly acquireBlockFromCohort?;
+    private readonly proofAnchoring?;
     private coordinator;
     private readonly DEFAULT_TIMEOUT;
     private readonly localPeerId?;
     private readonly responsibilityCache;
     private static readonly RESPONSIBILITY_TTL_MS;
     private readonly lastSeenCommitMs;
-    /** Per block, the cohort-claimed revision the last freshness consult could not settle — the
-     *  doubt {@link flagUnconfirmedCurrency} stamps onto reads served below it. Outlives the
-     *  consult on purpose: the read-repair window skips consults for blocks checked recently, and
-     *  a doubt dropped there is a stale answer served as confirmed again.
+    /** Per block, what earlier repair passes left unresolved — see {@link AheadClaimState}.
+     *  Outlives the consult on purpose: the read-repair window skips consults for blocks checked
+     *  recently, and a doubt dropped there is a stale answer served as confirmed again.
      *  NOTE: LRU-bounded like `lastSeenCommitMs`; an eviction under >1000 doubted blocks loses the
-     *  doubt until the next consult re-derives it (one read-repair window later, at worst). */
+     *  doubt until the next consult re-derives it (one read-repair window later, at worst) and lets
+     *  {@link reportRepairDeadlock} say its piece a second time. */
     private readonly unsettledAheadClaims;
     private readonly readRepairMode;
     private readonly readRepairWindowMs;
@@ -107,7 +129,7 @@ export declare class CoordinatorRepo implements IRepo {
     now: () => number;
     /** Test seam: overridable RNG (0..1) for sample-rate gating. */
     rand: () => number;
-    constructor(keyNetwork: IKeyNetwork, createClusterClient: (peerId: PeerId) => ICluster, storageRepo: IRepo, cfg?: CoordinatorRepoConfig, localCluster?: LocalClusterWithExecutionTracking, localPeerId?: PeerId, fretService?: FretService, clusterLatestCallback?: ClusterLatestCallback | undefined, reputation?: IPeerReputation, stateStore?: ITransactionStateStore, acquireBlockFromCohort?: AcquireBlockCallback | undefined);
+    constructor(keyNetwork: IKeyNetwork, createClusterClient: (peerId: PeerId) => ICluster, storageRepo: IRepo, cfg?: CoordinatorRepoConfig, localCluster?: LocalClusterWithExecutionTracking, localPeerId?: PeerId, fretService?: FretService, clusterLatestCallback?: ClusterLatestCallback | undefined, reputation?: IPeerReputation, stateStore?: ITransactionStateStore, acquireBlockFromCohort?: AcquireBlockCallback | undefined, proofAnchoring?: ProofAnchoring | undefined);
     /**
      * The resolved super-majority threshold this coordinator commits on. Exposed so the composition root
      * can fail-fast if the coordinator and the cluster member would run different thresholds (see the
@@ -180,7 +202,7 @@ export declare class CoordinatorRepo implements IRepo {
      * from the tail block's `latest.rev`, and `syncInternal` commits every block of an action at
      * `context.rev + 1` — so `context.rev >= claimedRev` is a well-defined comparison. `state.latest`
      * is this node's newest revision for the block even on a pinned read (StorageRepo reports the
-     * content's own revision separately as `materializedRev`), which is exactly the number "is this
+     * content's own revision separately as `materialized`), which is exactly the number "is this
      * node behind the claim?" asks about.
      */
     private flagUnconfirmedCurrency;
@@ -244,7 +266,8 @@ export declare class CoordinatorRepo implements IRepo {
      * the repair. Returns the local revision afterwards.
      *
      * A pending-only block (metadata seeded by `savePendingTransaction`, no committed revision) asked
-     * for a forward revision no promotion can reach used to throw out of `BlockStorage.ensureRevision`.
+     * for a forward revision no promotion can reach used to throw out of the restore step (now
+     * `BlockStorage.restoreRevision`, driven by `StorageRepo.get`'s healing helper).
      * It no longer does: "no committed base here" is an absence, so that read comes back as a plain
      * unflagged `{ state: {} }` and this method simply returns `undefined` — acquisition then supplies
      * the revision. The `unavailable` arm below still fires for the shapes that ARE a guess (a `latest`
@@ -272,25 +295,109 @@ export declare class CoordinatorRepo implements IRepo {
      * repair. It is returned separately so the caller can compare, not vote.
      *
      * NOTE: the quorum is corroboration-of-a-claim, NOT Sybil-resistant cohort
-     * membership — a peer minting fresh keypairs still casts a vote, and the claims
-     * themselves are bare assertions (a `BlockArchive` carries no commit certificate, so
-     * there is nothing here to verify a `(rev, actionId)` against). Commit-cert +
-     * membership anchoring is deferred to backlog
-     * `debt-read-repair-commit-cert-verification`.
+     * membership — a peer minting fresh keypairs still casts a vote. A claim that arrives
+     * with a cohort commit proof is additionally VERIFIED here (`certifyClaim`,
+     * `cluster/certified-claims.ts`); when the proof holds, the claim is certified and
+     * {@link selectQuorumRev} accepts it without a second voter — the cohort's signature set
+     * is its corroboration. What a passing proof does NOT prove is that its signers are the
+     * block's responsible cohort (anyone controlling N keys can sign their own N-peer
+     * proof); anchoring the signer set to topology is the optional, observational-only
+     * {@link ProofAnchoring} layer, unwired in production today.
      */
     private queryClusterForLatest;
     /**
-     * Report peers whose reported latest contradicts the quorum-corroborated pair. Best-effort.
+     * Say ONCE per block, in words, when a corroboration decline is provably PERMANENT rather than a
+     * transient shortage of answers. There are exactly TWO permanent shapes, and they send the operator
+     * to different places, so each gets its own `reason` and its own wording:
+     *
+     *  - `cohort-too-small` — this node's cohort has fewer peers than the quorum would demand even if
+     *    every one of them answered and agreed. The remedy is machines or an honest declared size.
+     *  - `sole-holder` — the cohort is big enough, but exactly ONE of its peers holds the block at all
+     *    and every other peer answered that it holds nothing. The remedy is another cohort peer
+     *    holding the block; machines and configuration are both irrelevant. Note the scope: this node's
+     *    own copy is excluded from the claim set, so a reader that holds the block itself still sees
+     *    `sole-holder` — the message says "cohort peer", never "machine in the deployment".
+     *
+     * **What makes `cohort-too-small` provable.** Not "this pass fell short" — a pass falls short
+     * whenever some peer simply does not hold the block *yet*. The decisive question is whether the
+     * cohort could supply the quorum AT ALL: ask what would be required if every cohort peer answered
+     * and agreed — the best case any later pass can reach without new machines — and compare it to how
+     * many peers the cohort has. Short of that best case the shortfall is not the machine count, and
+     * saying PERMANENT would send the operator to change a number that was never the problem. Twelve
+     * days of log archaeology went into re-deriving the real condition from a thousand identical
+     * `cluster-fetch:no-quorum` lines; the node knows it at the moment of each decline.
      *
-     * NOTE: the `rev > selected.rev` branch is NOT provable misbehavior — an honest
-     * peer legitimately ahead of the sampled quorum (an in-flight commit it durably
-     * stored, or other honest holders dropped from the sample by the 1s per-peer
-     * timeout) reports a higher rev and gets penalized (weight 30 → immediate
-     * deprioritize at threshold 20). Distinguishing a liar from an honest leader
-     * needs the commit-cert verification tracked in backlog
-     * `debt-read-repair-penalty-provable-only` / `debt-read-repair-commit-cert-verification`.
+     * **What makes `sole-holder` provable.** Note it is only reachable for a lone UNCERTIFIED holder:
+     * a lone holder whose cohort commit proof verified is selected by the certified path and converges
+     * before any decline — so the wording's "a lone holder cannot second itself" stays accurate for
+     * every claim that gets here. "That peer will hold it later" is an assumption, and for a
+     * peer that ANSWERED "I hold nothing" it is false: the only two mechanisms that would turn a
+     * non-holder into a holder — `queryClusterForLatest` (read-repair) and `createReconcileBlock`
+     * (reconcile) — consume this very decision, so they decline for exactly the same reason on that
+     * peer. Every peer answered, one holds the block, the rest hold nothing, and no later pass changes
+     * any of that. What DOES change it is a new copy: a commit that writes the block again pushes it to
+     * the current cohort. (Sibling work `replicate-owned-blocks-when-the-cohort-grows` makes that
+     * automatic; until it lands the operator has to cause the write.)
+     *
+     * **What is deliberately NOT reported.** A cohort that answers unanimously "I hold nothing" — an
+     * agreed absence is an answer, not a failed repair. A pass with any silent peer: silence cannot
+     * change the arithmetic (`cohortPeers` counts silent peers too), but it does mean this node saw less
+     * than the whole picture, and the next clean pass says the same thing at no cost. Note there is
+     * deliberately NO "the claims disagreed" exemption for `cohort-too-small`: a cohort too small to
+     * reach quorum stays too small whether its peers agree or not, so disagreement would suppress a line
+     * that is still true. Two or more disagreeing holders DO suppress `sole-holder`, because that is a
+     * cohort with two copies whose peers have not settled yet — a later pass can settle it.
+     *
+     * **Never a lever.** This only classifies and logs; it never relaxes a floor. Which is also why the
+     * `cohort-too-small` message names *two* readings of the same numbers — a deployment that genuinely
+     * runs this few machines, or a cohort view shrunk below the real deployment by a partition or by an
+     * attacker with routing influence. `corroboratorCapacity` keeps the shrunken view out of the relaxed
+     * branch, but this node cannot tell the two apart from the inside, and an operator sent to fix the
+     * wrong one is the failure this line exists to end.
+     *
+     * NOTE: the reader is still told only "this may be stale" — `BlockPossiblyStaleError` implies a
+     * retry might help, which is wrong advice for a block whose repair is deadlocked as configured.
+     * Carrying this condition into the error needs a new field on `GetBlockResult` plus a change to
+     * that error's documented contract; deliberately out of scope here (see the ticket
+     * `repair-deadlock-is-never-named`, *Not this ticket*).
+     */
+    private reportRepairDeadlock;
+    /**
+     * Report peers whose reported latest PROVABLY contradicts a CORROBORATED selection: the same
+     * revision under a different actionId. Two actions cannot both be the commit at one revision,
+     * and the pair a quorum of distinct peers agreed on is the one this node can stand behind, so
+     * the disagreeing claimant is wrong. Best-effort.
+     *
+     * A CERTIFIED selection is deliberately excluded — no claim is penalized against it. A passing
+     * proof shows the cohort it names signed the commit, never that those signers are the block's
+     * responsible cohort: anyone holding N keys can mint a proof that verifies (see caller
+     * obligation #1 in `cluster/commit-proof.ts`, and the unwired {@link ProofAnchoring} layer).
+     * Penalizing here would therefore hand one forged proof a lever it must not have — every honest
+     * peer holding the real action at that revision reported for InvalidRestoration (weight 30,
+     * above the deprioritize threshold of 20), on every consult. Losing the selection to the proof
+     * is already the accepted cost of the certified path; deprioritizing the honest cohort on top of
+     * it is not. Revisit when certification is anchored to the block's derived cohort
+     * (`feat-cluster-membership-threshold-cert-anchoring`): a gated proof makes the contradiction
+     * provable again.
+     *
+     * A claim at a HIGHER rev than the selection is deliberately NOT penalized: a peer can honestly
+     * be ahead of the sampled quorum — an in-flight commit it durably stored before the rest of the
+     * cohort, or other honest holders dropped from the sample by the 1s per-peer consult deadline —
+     * and the InvalidRestoration weight (30) sits above the deprioritize threshold (20), so a single
+     * false hit used to deprioritize an honest, up-to-date peer. Declining to RESTORE from the
+     * uncorroborated higher claim already happens in selection; the affirmative penalty on that
+     * ambiguous evidence is what this method no longer applies. Provably-bad proof SERVICE is
+     * penalized at verification time instead (the certifyClaim pass in
+     * {@link queryClusterForLatest}).
      */
     private penalizeContradictingRevClaims;
+    /**
+     * Best-effort penalty for a peer whose SERVED PROOF provably lies or provably does not cover the
+     * claim it was attached to (see the attributability classification in
+     * `cluster/certified-claims.ts`). Never throws — mirrors
+     * {@link penalizeContradictingRevClaims}.
+     */
+    private penalizeProofService;
     pend(request: PendRequest, options?: MessageOptions): Promise<PendResult>;
     /**
      * Decide whether a cluster validator rejection was an optimistic-concurrency loss — the block
@@ -312,8 +419,58 @@ export declare class CoordinatorRepo implements IRepo {
      * genuine validation faults.
      */
     private classifyStaleRejection;
+    /**
+     * Sibling of {@link classifyStaleRejection} for the OTHER optimistic-concurrency refusal shape:
+     * the promise-phase pending-conflict vote (`validatePendOperations` rejecting a pend whose
+     * blocks are held by a different unresolved pending action). That vote surfaces here as a
+     * {@link ValidatorRejectionError}, and without classification it would escape as a throw —
+     * splitting multi-tree pends mid-batch instead of taking the retry path a lost race deserves.
+     *
+     * Same confirmation discipline as the stale classifier: purely local. Re-read the affected
+     * blocks from our own storage and require some block's `state.pendings` to carry a rival
+     * actionId; the signed reject text is never consulted. A confirmed rival returns a
+     * {@link StaleFailure} with `conflict: true` and the rivals as `pending` (`ActionPending`
+     * without `transform` — the type allows it, and no consumer rebases from it). Unconfirmed —
+     * including read errors during confirmation — stays a throw, preserving fail-fast for genuine
+     * validation faults. Checked after `classifyStaleRejection` so a confirmed committed loss
+     * (which carries the sharper `staleAt`) wins when both hold.
+     */
+    private classifyPendingConflictRejection;
     cancel(actionRef: ActionBlocks, options?: MessageOptions): Promise<void>;
     commit(request: CommitRequest, options?: MessageOptions): Promise<CommitResult>;
+    /**
+     * Commit-shaped sibling of {@link classifyStaleRejection}: decide whether a cluster validator
+     * rejection of a COMMIT was an optimistic-concurrency loss — the requested revision is already
+     * committed under a different action — rather than a genuine validation fault. A confirmed loss
+     * returns a {@link StaleFailure} with `conflict: true` so db-core's `commitCollection` surfaces
+     * it immediately as a stale loss (no verbatim retry) and the writer re-drives at a fresh
+     * revision.
+     *
+     * Same confirmation discipline as the pend classifiers: purely local re-read; the signed reject
+     * text is never consulted. One commit-specific delta — confirmation must EXCLUDE the
+     * own-action-at-rev case: a block whose requested revision is held by THIS action is already
+     * durable, and answering `conflict` for it would make the writer rebase and re-append an
+     * already-committed action at a new revision — a duplicate entry. So:
+     *  - `latest.rev === request.rev` → compare `latest.actionId`: ours ⇒ bail (stays a throw),
+     *    a rival's ⇒ confirmed loss;
+     *  - `latest.rev > request.rev` → ask the {@link IRevisionActionReader} capability who holds
+     *    `request.rev`: ours ⇒ bail, a rival's ⇒ confirmed loss, unknown/absent/fault ⇒ unconfirmed;
+     *  - anything unconfirmed (including read errors) stays a throw — fail-fast for genuine faults.
+     */
+    private classifyCommitStaleRejection;
+    /**
+     * Shared confirmation core for the two commit-tier conversion sites ({@link classifyCommitStaleRejection}
+     * and the locally-executed refusal check in {@link commit}): decide, from LOCAL storage only, who
+     * holds the requested revision.
+     *  - a confirmed RIVAL → the {@link StaleFailure} conflict answer (with `staleAt` = highest
+     *    confirmed holder);
+     *  - our OWN action durable at the requested revision → `'own-durable'` (callers must not answer
+     *    `conflict` — the writer would rebase an already-landed action into a duplicate entry);
+     *  - anything else (behind, truncated history, read faults, capability absent) → `undefined`,
+     *    unconfirmed.
+     * The signed reject text / retained verdict prose is never consulted.
+     */
+    private confirmCommitRivalAgainstLocal;
     /**
      * Report success for a commit the cluster carried but this peer could not apply locally. The
      * blocks are marked seen so the read path treats them as freshness-checked; convergence comes
@@ -321,5 +478,4 @@ export declare class CoordinatorRepo implements IRepo {
      */
     private tolerateLocalCommitDivergence;
 }
-export {};
 //# sourceMappingURL=coordinator-repo.d.ts.map

package/dist/src/repo/coordinator-repo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coordinator-repo.d.ts","sourceRoot":"","sources":["../../../src/repo/coordinator-repo.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"coordinator-repo.d.ts","sourceRoot":"","sources":["../../../src/repo/coordinator-repo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAgB,SAAS,EAAE,aAAa,EAAe,WAAW,EAAE,QAAQ,EAAE,sBAAsB,EAAE,OAAO,EAAuB,aAAa,EAAwD,MAAM,qBAAqB,CAAC;AAG9U,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAEtF,OAAO,EAA6D,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAIhI,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtE;;;;;;;;;GASG;AACH,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,CAAC;AAqL1D;;;GAGG;AACH,UAAU,iCAAkC,SAAQ,QAAQ;IAC3D,sBAAsB,CAAC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IACtD,4GAA4G;IAC5G,qBAAqB,CAAC,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;IACpE,gHAAgH;IAChH,uBAAuB,CAAC,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAAC;CACxE;AAED;;;;;GAKG;AACH,YAAY,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAAC;AAE3I,UAAU,yBAAyB;IAClC,WAAW,EAAE,KAAK,CAAC;IACnB,YAAY,CAAC,EAAE,iCAAiC,CAAC;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;IAC9C;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,oBAAoB,CAAC;IAC9C;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CAChC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC,GAAG;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8BAA8B,CAAC,EAAE,MAAM,CAAC;CACxC,CAAC;AAEF,wBAAgB,eAAe,CAC9B,UAAU,EAAE,WAAW,EACvB,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,QAAQ,EACjD,GAAG,CAAC,EAAE,qBAAqB,EAC3B,WAAW,CAAC,EAAE,WAAW,EACzB,UAAU,CAAC,EAAE,eAAe,EAC5B,UAAU,CAAC,EAAE,sBAAsB,GACjC,CAAC,UAAU,EAAE,yBAAyB,KAAK,eAAe,CAe5D;AAED,2HAA2H;AAC3H,qBAAa,eAAgB,YAAW,KAAK;IAqC3C,QAAQ,CAAC,UAAU,EAAE,WAAW;IAChC,QAAQ,CAAC,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,QAAQ;IAC1D,OAAO,CAAC,QAAQ,CAAC,WAAW;IAK5B,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAC;IAGvC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAC;IACxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IA/CjC,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqE;IACzG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAU;IACvD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoC;IACrE;;;;;oEAKgE;IAChE,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA6C;IAClF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA8B;IAC7D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,wGAAwG;IACxG,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAS;IACjD;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,8BAA8B,CAAS;IACxD,qHAAqH;IACrH,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAkB;IAC9C,oMAAoM;IACpM,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkC;IACtD,wEAAwE;IACxE,GAAG,EAAE,MAAM,MAAM,CAAoB;IACrC,gEAAgE;IAChE,IAAI,EAAE,MAAM,MAAM,CAAuB;gBAG/B,UAAU,EAAE,WAAW,EACvB,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,QAAQ,EACzC,WAAW,EAAE,KAAK,EACnC,GAAG,CAAC,EAAE,qBAAqB,EAC3B,YAAY,CAAC,EAAE,iCAAiC,EAChD,WAAW,CAAC,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,WAAW,EACR,qBAAqB,CAAC,EAAE,qBAAqB,YAAA,EAC9D,UAAU,CAAC,EAAE,eAAe,EAC5B,UAAU,CAAC,EAAE,sBAAsB,EAClB,sBAAsB,CAAC,EAAE,oBAAoB,YAAA,EAC7C,cAAc,CAAC,EAAE,cAAc,YAAA;IAsDjD;;;;OAIG;IACH,IAAI,+BAA+B,IAAI,MAAM,CAE5C;IAED,8EAA8E;IACxE,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAI1C;;;;;;OAMG;YACW,qBAAqB;IAwBnC;;OAEG;YACW,oBAAoB;IAa5B,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IAkInF;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,sBAAsB;IAS9B;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAiBxB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,CAAC,uBAAuB;IAmB/B,oHAAoH;IACpH,OAAO,CAAC,gBAAgB;IAcxB,iFAAiF;IACjF,OAAO,CAAC,KAAK;IAKb,0FAA0F;IAC1F,OAAO,CAAC,cAAc;IAOtB;;;;OAIG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAItD;;;;;;;;;;;;;;;;;;OAkBG;YACW,qBAAqB;IA2GnC;;;;;;;;;;;;;;;;;;;;;OAqBG;YACW,mBAAmB;IAuCjC;;;;;;;;;;;;;OAaG;YACW,mBAAmB;IAcjC;6FACyF;YAC3E,cAAc;IAK5B,yGAAyG;YAC3F,YAAY;IAI1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;YACW,qBAAqB;IA4KnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACH,OAAO,CAAC,oBAAoB;IAiF5B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,CAAC,8BAA8B;IAatC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAStB,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IAuG/E;;;;;;;;;;;;;;;;;;OAkBG;YACW,sBAAsB;IAuDpC;;;;;;;;;;;;;;;OAeG;YACW,gCAAgC;IA+BxC,MAAM,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IA4CxE,MAAM,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IA+GrF;;;;;;;;;;;;;;;;;;OAkBG;YACW,4BAA4B;IAS1C;;;;;;;;;;;OAWG;YACW,8BAA8B;IAkE5C;;;;OAIG;IACH,OAAO,CAAC,6BAA6B;CAKrC"}