@optimystic/db-p2p 0.24.2 → 0.25.0

package/dist/src/storage/block-storage.d.ts

@@ -1,7 +1,9 @@
 import type { BlockId, IBlock, Transform, ActionId, ActionRev } from "@optimystic/db-core";
+import type { BlockCommitProof } from "../cluster/commit-proof.js";
 import type { RestoreCallback } from "./struct.js";
 import type { IRawStorage } from "./i-raw-storage.js";
-import type { IBlockStorage } from "./i-block-storage.js";
+import { type IBlockStorage } from "./i-block-storage.js";
+import type { BlockWriteLatch } from "./block-latch.js";
 export declare class BlockStorage implements IBlockStorage {
     private readonly blockId;
     private readonly storage;
@@ -20,27 +22,43 @@ export declare class BlockStorage implements IBlockStorage {
      */
     checkpointInterval?: number);
     getLatest(): Promise<ActionRev | undefined>;
+    /**
+     * Guard every write: the token must have been minted for THIS block and must still be live. The
+     * type already proves the caller went through `acquireBlockWriteLatch`; this catches the two
+     * things the type cannot — a token for block A presented to block B's storage, and a token
+     * stashed by a callback and used after its scope released the latch.
+     */
+    private assertLatch;
+    /**
+     * LOCAL-ONLY read — never fetches from a peer. A revision outside `meta.ranges` throws
+     * {@link RevisionNotCoveredError}; the one caller allowed to heal that (`StorageRepo.get`) does so
+     * with {@link restoreRevision} under the block's write latch and re-reads. Keeping the fetch out of
+     * here is what lets the commit path hold N block latches with no network I/O inside them.
+     */
     getBlock(rev?: number): Promise<{
         block: IBlock;
         actionRev: ActionRev;
     } | undefined>;
+    restoreRevision(rev: number, latch: BlockWriteLatch): Promise<void>;
     getTransaction(actionId: ActionId): Promise<Transform | undefined>;
+    getBlockProof(rev: number): Promise<BlockCommitProof | undefined>;
+    saveBlockProof(rev: number, proof: BlockCommitProof, latch: BlockWriteLatch): Promise<void>;
     getPendingTransaction(actionId: ActionId): Promise<Transform | undefined>;
     listPendingTransactions(): AsyncIterable<ActionId>;
-    savePendingTransaction(actionId: ActionId, transform: Transform): Promise<void>;
-    deletePendingTransaction(actionId: ActionId): Promise<void>;
+    savePendingTransaction(actionId: ActionId, transform: Transform, latch: BlockWriteLatch): Promise<void>;
+    deletePendingTransaction(actionId: ActionId, latch: BlockWriteLatch): Promise<void>;
     listRevisions(startRev: number, endRev: number): AsyncIterable<ActionRev>;
-    saveMaterializedBlock(actionId: ActionId, block: IBlock | undefined): Promise<void>;
-    pruneSupersededMaterialization(prior: ActionRev): Promise<void>;
-    saveRevision(rev: number, actionId: ActionId): Promise<void>;
-    promotePendingTransaction(actionId: ActionId): Promise<void>;
-    setLatest(latest: ActionRev): Promise<void>;
-    recover(): Promise<{
+    saveMaterializedBlock(actionId: ActionId, block: IBlock | undefined, latch: BlockWriteLatch): Promise<void>;
+    pruneSupersededMaterialization(prior: ActionRev, latch: BlockWriteLatch): Promise<void>;
+    saveRevision(rev: number, actionId: ActionId, latch: BlockWriteLatch): Promise<void>;
+    promotePendingTransaction(actionId: ActionId, latch: BlockWriteLatch): Promise<void>;
+    setLatest(latest: ActionRev, latch: BlockWriteLatch): Promise<void>;
+    recover(latch: BlockWriteLatch): Promise<{
         reconciled: boolean;
         latest?: ActionRev;
     }>;
-    saveReplica(block: IBlock, source?: ActionRev): Promise<ActionRev>;
-    saveDeletion(source: ActionRev): Promise<ActionRev>;
+    saveReplica(block: IBlock, source: ActionRev | undefined, proof: BlockCommitProof | undefined, latch: BlockWriteLatch): Promise<ActionRev>;
+    saveDeletion(source: ActionRev, latch: BlockWriteLatch): Promise<ActionRev>;
     /**
      * Shared forward-write path for saveReplica and saveDeletion. Both append a single new revision
      * that ADVANCES `latest` (never rewrites history): acquire the block's metadata latch, apply the
@@ -50,11 +68,150 @@ export declare class BlockStorage implements IBlockStorage {
      * plus the materialized `block`; a deletion carries `{ delete: true }` and no block. `rev` and
      * `actionId` are passed alongside `body` because the guard and the `latest` advance need them
      * independently of the archive body.
+     *
+     * `verifiedProof` travels OUTSIDE `body` on purpose — see {@link saveRestored}: it is the one
+     * channel that persists a proof, and only {@link saveReplica} (whose caller verified the proof
+     * against `body.block`) supplies it.
      */
     private saveForwardRevision;
-    private ensureRevision;
     private materializeBlock;
     private restoreBlock;
+    /**
+     * Vet an archive fetched for a PINNED restore of `rev`, returning the revision coverage to record
+     * for it — or `undefined` when the archive must be refused, in which case nothing is written at
+     * all and the reason is logged.
+     *
+     * This is the whole trust boundary for the restore wire. `restoreBlock`'s
+     * `RestorationCoordinator` verifies nothing about a response (`queryPeer` returns
+     * `response.archive` straight through), so every field below is a remote peer's assertion, and
+     * `saveRestored` writes keyed by REVISION and by ACTION ID — meaning an archive naming a
+     * revision or action id this node already holds would otherwise overwrite content that was never
+     * in question. The checks, in order:
+     *
+     *  - **The archive is about this block.** `saveRestored` writes under `this.blockId` and ignores
+     *    `archive.blockId`, so an answer about a different block would land as this block's history.
+     *  - **Every revision key is a real revision.** Keys arrive as JSON strings; a non-numeric key
+     *    coerces to `NaN` and would be stored as a garbage revision number. Min/max are folded rather
+     *    than spread through `Math.min`/`Math.max`, which throws `RangeError` past ~125k arguments —
+     *    reachable inside the 8 MiB sync-response cap (see `maxArchiveRevision`, same hazard).
+     *  - **Each entry's own `rev`, when it declares one, agrees with the key it is filed under.**
+     *    That disagreement IS the mislabel this ticket's family of bugs is about, in miniature.
+     *  - **The archive answers the pin.** NOT "carries revision `rev`" — `ActionContext.rev` is a
+     *    COLLECTION-wide revision, so it routinely sits above the revision at which this particular
+     *    block last changed. A peer answering a pin at 9 for a block whose last commit was rev 2
+     *    correctly serves rev 2, labelled as rev 2 (pinned in `test/block-archive-proof.spec.ts`).
+     *    So the rule is that the archive's LOWEST revision is at or below the pin: `materializeBlock`
+     *    descends from `rev`, so an archive entirely above the pin answers a different question and
+     *    is exactly the "old bytes under a newer label" shape that overwrites good local data.
+     *  - **The declared `range` agrees with the revisions actually carried** — it starts at the
+     *    lowest (the floor must be present, or the descending walk has nothing to land on) and ends
+     *    past the highest. An OPEN-ENDED range is refused outright: it would claim infinite coverage
+     *    and permanently disable restore for this block on one unverified peer's say-so.
+     *    (`RestoreCallback` allows open-ended for the UNPINNED call; `restoreRevision` never makes one.)
+     *  - **Nothing already held is overwritten with different content** — see
+     *    {@link noDivergentRewrite}.
+     *
+     * ## What gets recorded, and the one thing taken on trust
+     *
+     * The coverage returned is `[lowest, rev + 1)` — the archive's floor, up to the PIN and no
+     * further. Both halves of that are deliberate.
+     *
+     * Extending UP to the pin is an INFERENCE, and the only one here: a peer
+     * answering a pinned fetch with revision M ≤ N means "M is my highest committed revision of this
+     * block at or below N", i.e. nothing changed in (M, N]. This node cannot verify that locally.
+     *
+     * It is recorded anyway because the alternative is worse. `meta.ranges` is what
+     * {@link restoreRevision} consults to decide whether to fetch at all, so recording only the
+     * archive's literal `[M, M+1)` leaves `inRanges(N)` false and re-runs the ENTIRE restore — network
+     * round trip plus a full `saveRestored` write — on every later read at that pin, forever, never
+     * converging. The inference is also unavoidable rather than merely convenient: having the peer
+     * state the claim on the wire instead would not make it verifiable, only explicit, while breaking
+     * repair against every peer running an older build.
+     *
+     * Stopping AT the pin, on the other hand, discards coverage for any revision the archive
+     * volunteered ABOVE it. Those entries are still WRITTEN — an honest peer serves a contiguous
+     * span, so an archive of `{2, 3, 4}` answering a pin at 3 is normal, not hostile — they are
+     * merely not CLAIMED. `rev` is the one number in the exchange this node chose, so it is as far as
+     * its trust in the answer should reach; recording `highest + 1` instead would let the peer set
+     * the width of its own credibility by padding the archive with fabricated high revisions, and
+     * reads across that padded span would then be served from local content without ever re-asking.
+     * The cost is one redundant fetch the first time a revision above the pin is read; that fetch is
+     * idempotent (identical content is not a conflict, see {@link noDivergentRewrite}) and the
+     * coverage converges.
+     *
+     * NOTE: accepted tradeoff — a lying peer's answer is therefore STICKY across the whole span it
+     * was asked about: reads between M and N are served locally from M's content and never re-ask, so
+     * a later honest peer is never consulted for them. Weighed against an unbounded re-fetch loop and
+     * kept; that is the same "ranges records what this node can locally reconstruct, freshness is a
+     * separate concern" position `setLatest` and `saveForwardRevision` already take. Revisit if a
+     * restore ever gains a way to verify an archive (a commit proof chain over the served revision
+     * would do it) — at that point record only what verifies.
+     */
+    private vetRestoredArchive;
+    /**
+     * True when none of `entries` would overwrite content this node ALREADY holds with different
+     * content. False (having logged which entry, via `refuse`) when any would.
+     *
+     * The refusal is all-or-nothing: one divergent entry rejects the WHOLE archive rather than
+     * landing the entries this node happens to lack. Two reasons. An archive that contradicts locally
+     * held content is evidence the peer is wrong or hostile about this block, which makes the rest of
+     * it no more trustworthy than the part that was caught; and a partial apply would leave
+     * {@link vetRestoredArchive}'s coverage claiming a span the applied subset may not support.
+     *
+     * Identical content is NOT a conflict — a re-restore of the same archive must stay idempotent,
+     * which it has to be for the pin-extended coverage above to converge.
+     *
+     * NOTE: accepted tradeoff — first writer wins, permanently. Once a revision record is held, no
+     * later archive can replace it, so a lying peer that answers a gap FIRST makes every honest
+     * archive restating that revision refuse forever: the revision becomes unreadable rather than
+     * wrong. That is the deliberate direction — this guard exists precisely so a peer cannot rewrite
+     * held history, and it cannot tell "the held copy is the lie" from "the incoming copy is". Repair
+     * from that state is an operator action (drop the block's local records and re-fetch). Revisit
+     * only alongside a way to verify an archive, which would let the guard prefer the provable copy
+     * instead of the earlier one.
+     *
+     * Comparison is by `canonicalJson`, db-core's one deterministic encoding, so key ORDER across a
+     * JSON round trip over the wire never reads as divergence.
+     *
+     * The three keys mirror {@link saveRestored}'s three writes exactly; an entry that carries no
+     * `block` writes no materialization, so it cannot clobber one and is not checked for it.
+     *
+     * NOTE: costs up to three raw-storage reads per revision entry, on the restore path only — which
+     * has already paid for a network round trip, so it is not the term that matters. If a restore
+     * ever carries thousands of revisions and this shows up, check `getRevision` first and skip the
+     * other two for a revision this node does not hold at all.
+     */
+    private noDivergentRewrite;
+    /**
+     * Persist a fetched archive's revisions locally.
+     *
+     * A revision entry's own `proof` is deliberately IGNORED. An archive is remote wire data —
+     * {@link restoreBlock}'s `RestorationCoordinator` fetch verifies nothing, and a peer chooses
+     * what to attach — so persisting a proof read out of the archive body would re-serve a hostile
+     * peer's artifact as evidence this node retained itself. A proof reaches storage only through
+     * `verified`, passed out-of-band alongside the archive, which exactly one caller chain supplies:
+     * `cluster/reconcile-block.ts` → `StorageRepo.saveReplicatedBlock` → {@link saveReplica} →
+     * {@link saveForwardRevision}, where `certifyContent` had already bound the proof to these exact
+     * bytes. A separate parameter rather than a caller obligation to strip is what makes "an
+     * unverified proof reached `saveBlockProof`" unrepresentable instead of merely documented.
+     *
+     * This is a WRITER, not a gate: it trusts what it is handed, and each of its two callers is
+     * responsible for having earned that on its own terms.
+     *
+     *  - {@link restoreRevision} — the unverified restore wire — runs {@link vetRestoredArchive}
+     *    first. Those checks are ABOUT the pinned request (does the archive answer the revision that
+     *    was asked for?), and this function has no pin to check against, so they cannot live here.
+     *  - {@link saveForwardRevision} — reached by `saveReplica`/`saveDeletion` through
+     *    `StorageRepo.saveReplicatedBlock` — builds the archive it passes from local arguments, and
+     *    on the replica path `cluster/reconcile-block.ts` has already bound those bytes to a verified
+     *    proof. It writes strictly ABOVE its own `latest` (the monotonic guard returns first
+     *    otherwise), so it cannot rewrite held history, and it deliberately pays nothing for the
+     *    restore wire's checks.
+     *
+     * A THIRD caller would not inherit either argument. Any future one that takes an archive off a
+     * network must route through `vetRestoredArchive` (or an equivalent for its own trust model)
+     * before reaching here.
+     */
     private saveRestored;
     private inRanges;
     /**

package/dist/src/storage/block-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block-storage.d.ts","sourceRoot":"","sources":["../../../src/storage/block-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAmB,MAAM,qBAAqB,CAAC;AAE5G,OAAO,KAAK,EAA+B,eAAe,EAAiB,MAAM,aAAa,CAAC;AAC/F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAY1D,qBAAa,YAAa,YAAW,aAAa;IAEhD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC;IACjC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBARlB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,WAAW,EACpB,eAAe,CAAC,EAAE,eAAe,YAAA;IAClD;;;;OAIG;IACc,kBAAkB,GAAE,MAA4B;IAG5D,SAAS,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAK3C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,SAAS,CAAA;KAAE,GAAG,SAAS,CAAC;IA2DpF,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAIlE,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAIxE,uBAAuB,IAAI,aAAa,CAAC,QAAQ,CAAC;IAInD,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAe/E,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAK1D,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC;IAI1E,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAInF,8BAA8B,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB/D,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5D,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5D,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B3C,OAAO,IAAI,OAAO,CAAC;QAAE,UAAU,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC;IAuC/D,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IAkBlE,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IAczD;;;;;;;;;OASG;YACW,mBAAmB;YA+EnB,cAAc;YA+Bd,gBAAgB;YAiEhB,YAAY;YAKZ,YAAY;IAc1B,OAAO,CAAC,QAAQ;IAMhB;;;;;;;;;OASG;IACH,OAAO,CAAC,aAAa;IAMrB;;sGAEkG;IAClG,OAAO,CAAC,YAAY;CASpB"}
+{"version":3,"file":"block-storage.d.ts","sourceRoot":"","sources":["../../../src/storage/block-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAmB,MAAM,qBAAqB,CAAC;AAE5G,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAA+B,eAAe,EAAiB,MAAM,aAAa,CAAC;AAC/F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAoBxD,qBAAa,YAAa,YAAW,aAAa;IAEhD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC;IACjC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBARlB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,WAAW,EACpB,eAAe,CAAC,EAAE,eAAe,YAAA;IAClD;;;;OAIG;IACc,kBAAkB,GAAE,MAA4B;IAG5D,SAAS,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAKjD;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IASnB;;;;;OAKG;IACG,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,SAAS,CAAA;KAAE,GAAG,SAAS,CAAC;IAqCpF,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCnE,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAIlE,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAIjE,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3F,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAIxE,uBAAuB,IAAI,aAAa,CAAC,QAAQ,CAAC;IAInD,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBvG,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlF,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC;IAI1E,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3G,8BAA8B,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBvF,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpF,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAMpF,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA2BnE,OAAO,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC;QAAE,UAAU,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC;IAwCrF,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,SAAS,EAAE,KAAK,EAAE,gBAAgB,GAAG,SAAS,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC;IAoB1I,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC;IAejF;;;;;;;;;;;;;OAaG;YACW,mBAAmB;YAsFnB,gBAAgB;YAoFhB,YAAY;IAK1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsEG;YACW,kBAAkB;IA6DhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;YACW,kBAAkB;IA6BhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;YACW,YAAY;IAe1B,OAAO,CAAC,QAAQ;IAMhB;;;;;;;;;OASG;IACH,OAAO,CAAC,aAAa;IAMrB;;sGAEkG;IAClG,OAAO,CAAC,YAAY;CASpB"}