keri-ts 1.0.0 → 2.0.0

package/types/app/queries/query-replies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-replies.d.ts","sourceRoot":"","sources":["../../../src/app/queries/query-replies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACtF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE/C,yFAAyF;AACzF,KAAK,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAelE,wDAAwD;AACxD,UAAU,eAAe;IACvB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;CACvC;AAED,gGAAgG;AAChG,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC7C,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,oDAAoD;IACpD,OAAO,IAAI,eAAe,GAAG,SAAS,CAAC;IACvC,kFAAkF;IAClF,OAAO,IAAI,eAAe,GAAG,SAAS,CAAC;IACvC,wFAAwF;IACxF,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;;GAMG;AACH,qBAAa,YAAY;IAQX,OAAO,CAAC,QAAQ,CAAC,SAAS;IAPtC,8FAA8F;IAC9F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD;;;;OAIG;gBAC0B,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC;IAEtD;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAIjC;;;;;;OAMG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU;IAInD;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IA6DlB;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI;CA2BtC"}

package/types/app/queries/querying.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Finite query workflows corresponding to `keri.app.querying` doers in KERIpy.
+ *
+ * Each operation expresses a particular accepted-state predicate. It enqueues
+ * unsigned work with WitnessInquisitor, then observes local protocol state;
+ * sending a query or receiving HTTP 204 never satisfies that predicate.
+ * Composition must run the sender, cue worker and actual reply intake alongside
+ * the workflow. HTTP replies arrive through independent mailbox/direct intake;
+ * TCP may process replies on the sending connection.
+ *
+ * Unlike KERIpy's nested DoDoers, these operations borrow one composed sender.
+ * Their caller owns cancellation/deadlines and keeps the Baser open until all
+ * children have joined. Cancelling a wait does not withdraw an already enqueued
+ * query. There is no workflow retry timer or implicit OOBI bootstrap here.
+ */
+import type { SealEvent } from "cesr-ts";
+import type { Operation } from "effection";
+import type { AgentCue } from "../../core/cues.js";
+import type { Deck } from "../../core/deck.js";
+import type { Baser } from "../../db/basing.js";
+import type { WitnessInquisitor } from "./witness-inquisitor.js";
+/** Identity selection shared by the concrete workflows; copied on construction. */
+interface QueryOptions {
+    /** Local AID endorsing the query; omission uses the sender's configured/sole Hab. */
+    signer?: string;
+    /** Remote attester overrides; omission uses the subject's accepted endpoint roles. */
+    wits?: string[];
+}
+/**
+ * Ask an attester for current key state and recover the KEL if its notice is ahead.
+ *
+ * A saved KSN is a remote statement, not acceptance of the referenced KEL. A
+ * matching notice completes immediately only when the local Kever has reached
+ * its sequence. Otherwise a LogQuerier waits for that accepted sequence. The
+ * first usable matching notice fixes this operation's target; later notices stay
+ * queued rather than introducing moving-target task replacement.
+ * The subject needs a local Kever before a notice can drive this comparison;
+ * initial evidence discovery belongs to OOBI/bootstrap composition.
+ *
+ * keyStateSaved denotes a validated, persisted remote notice. Ordinary KEL
+ * acceptance alone cannot satisfy the initial notice wait. Queued notices are
+ * not correlated to a particular request or filtered for request-time freshness.
+ */
+export declare class KeyStateNoticer {
+    private readonly db;
+    private readonly inquisitor;
+    readonly pre: string;
+    private readonly cues;
+    private readonly options;
+    /**
+     * Bind borrowed collaborators without starting I/O or consuming cues yet.
+     *
+     * @param db Baser receiving accepted KEL updates from the independently running intake.
+     * @param inquisitor Query sender over that same state; its delivery worker must run concurrently.
+     * @param pre Subject AID, distinct from the local signer and selected attester.
+     * @param cues Command-owned input Deck; this noticer is its sole consumer. The
+     * application cue owner must be wired to transfer saved notices here before I/O.
+     * @param options Local signer and optional remote attesters, never transport preferences.
+     */
+    constructor(db: Baser, inquisitor: WitnessInquisitor, pre: string, cues: Deck<AgentCue>, options?: QueryOptions);
+    /**
+     * Enqueue `ksn`, then pull/match/append one cue per cooperative turn, following
+     * KERIpy's noticer model. Unrelated cues and matching notices without local
+     * state remain queued. No queue scan, broadcast or request freshness is implied.
+     * Once a usable notice selects a target, directly await accepted catch-up.
+     * The caller supervises sibling sender/receiver failures and owns cancellation;
+     * stopping this operation does not withdraw already enqueued requests.
+     */
+    queryDo(): Operation<void>;
+}
+/**
+ * Recover a KEL through the target sequence learned from a remote key-state notice.
+ * Like KERIpy LogQuerier, request logs from the beginning (`fn=0`, `s=0`) and
+ * finish when the local Kever reaches the target. This is a minimum sequence
+ * condition, not a promise that the remote peer has no newer events.
+ */
+export declare class LogQuerier {
+    private readonly db;
+    private readonly inquisitor;
+    readonly pre: string;
+    readonly targetSn: number;
+    private readonly options;
+    /**
+     * @param db Borrowed accepted-state store, kept open for the operation's lifetime.
+     * @param inquisitor Concurrently running sender; this workflow does not drive it.
+     * @param pre Subject whose KEL should catch up.
+     * @param targetSn Minimum accepted sequence, as a number rather than wire hex text.
+     * @param options Local signing AID and optional remote attester overrides.
+     */
+    constructor(db: Baser, inquisitor: WitnessInquisitor, pre: string, targetSn: number, options?: QueryOptions);
+    /** Send the initial request once and remain active until accepted state reaches the target. */
+    queryDo(): Operation<void>;
+}
+/**
+ * Request logs starting at selected KEL and first-seen ordinals.
+ *
+ * `s` selects the event sequence and `fn` selects first-seen replay position;
+ * they are different coordinates. As in KERIpy SeqNoQuerier, completion depends
+ * on accepted KEL sequence reaching targetSn, not on a first-seen cursor or a
+ * transport outcome. Even an already satisfied target still enqueues the request.
+ */
+export declare class SeqNoQuerier {
+    private readonly db;
+    private readonly inquisitor;
+    readonly pre: string;
+    readonly targetSn: number;
+    private readonly options;
+    private readonly fn;
+    /**
+     * @param db Borrowed accepted-state store updated by independent protocol intake.
+     * @param inquisitor Concurrent sender borrowing the same accepted state.
+     * @param pre Subject AID whose KEL is requested.
+     * @param targetSn Numeric sequence used both in the query and the completion predicate.
+     * @param options Numeric first-seen start (default zero), local signer and remote attesters.
+     * Wire ordinals use lowercase hex; the existing encoder clamps negatives to zero.
+     */
+    constructor(db: Baser, inquisitor: WitnessInquisitor, pre: string, targetSn: number, { fn, ...options }?: QueryOptions & {
+        fn?: number;
+    });
+    /** Complete only from an accepted KEL at or beyond the requested sequence. */
+    queryDo(): Operation<void>;
+}
+/**
+ * Find an accepted KEL event containing the exact supplied event seal.
+ *
+ * `pre` identifies the sealing KEL; anchor.i/s/d identify the event sealed in it.
+ * Mere knowledge of the subject's latest sequence does not satisfy this wait.
+ * Existing accepted sealing evidence completes without sending. Otherwise one
+ * request is enqueued per current eligible attester, preserving the bounded
+ * candidate pass needed when a retired witness never learned the anchor. This
+ * differs deliberately from KERIpy's single randomly selected attester.
+ */
+export declare class AnchorQuerier {
+    private readonly db;
+    private readonly inquisitor;
+    readonly pre: string;
+    readonly anchor: ReturnType<typeof SealEvent.toSad>;
+    private readonly options;
+    /**
+     * @param db Borrowed store containing accepted sealing events and their indexes.
+     * @param inquisitor Concurrent sender; candidates are selected when queryDo starts.
+     * @param pre AID whose KEL must contain the seal.
+     * @param anchor Exact event-seal fields, copied so later caller mutation cannot change the query.
+     * @param options Local signing AID and optional remote attesters.
+     */
+    constructor(db: Baser, inquisitor: WitnessInquisitor, pre: string, anchor: ReturnType<typeof SealEvent.toSad>, options?: QueryOptions);
+    /**
+     * Ask the finite candidate set once, then observe accepted sealing evidence.
+     * No available candidate leaves unresolved work with the sender; it is not
+     * success. The caller supplies a deadline or cancels this otherwise open wait.
+     */
+    queryDo(): Operation<void>;
+}
+export {};
+//# sourceMappingURL=querying.d.ts.map

package/types/app/queries/querying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"querying.d.ts","sourceRoot":"","sources":["../../../src/app/queries/querying.ts"],"names":[],"mappings":"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"}

package/types/app/queries/witness-inquisitor.d.ts

@@ -0,0 +1,150 @@
+import { type Operation } from "effection";
+import type { QueryCue, QueryRequest } from "../../core/cues.js";
+import { Deck } from "../../core/deck.js";
+import type { Hab, Habery } from "../identity/habbing.js";
+import type { ProtocolProcessor } from "../protocol/protocol-processing.js";
+import type { RuntimeClock } from "../runtime/runtime-clock.js";
+import type { HttpClient } from "../transport/http-client.js";
+/**
+ * KERIpy-shaped query sender, independent from semantic query completion.
+ *
+ * Responsibilities:
+ * - turn incomplete portable `query` cues into honest outbound `qry` wire
+ *   packets when a local habitat and remote attester can be resolved
+ * - capture signed requests and own their concrete, joined transport attempts
+ *
+ * Unresolved signer/attester work stays unsigned for a later pass. Once a packet
+ * is prepared, the request leaves the Deck before transport: a failed attempt is
+ * reported, not automatically retried. Preparation failures leave the source
+ * head available and propagate. HTTP completion includes response EOF/cleanup;
+ * same-socket TCP completion also includes received protocol processing. Neither
+ * is a substitute for the calling workflow's accepted-state predicate.
+ */
+export declare class WitnessInquisitor {
+    /** Borrowed local signers and accepted-state stores. */
+    private readonly hby;
+    /** Borrowed receive processor for same-socket TCP replies only. */
+    private readonly protocol;
+    /** Borrowed HTTP client selected at composition. */
+    private readonly http;
+    /** Borrowed clock for this owner's actual network deadlines. */
+    private readonly clock;
+    /** One operation owns the current network attempt. */
+    private delivering;
+    /** Aborts the active send when this sender closes. */
+    private output?;
+    /** Joins active request/parser cleanup before owned queues are cleared. */
+    private outputJoined?;
+    /** Unsigned query instructions awaiting an available signer/endpoint. */
+    private readonly requests;
+    /** Inspect deferred work without exposing queue mutation outside its owner. */
+    get pending(): Pick<Deck<QueryRequest>, "length" | "empty" | "peekHead">;
+    /** Terminal admission state; closing stops production and delivery. */
+    private closed;
+    /** Explicit default signer; null requires a unique local habitat. */
+    private hab;
+    /**
+     * Bind actual protocol and I/O collaborators; acquire no store or network lifetime.
+     *
+     * @param hby Borrowed local habitat collection and accepted-state database.
+     * @param protocol Borrowed same-database processor for incoming query replies.
+     * @param http Borrowed HTTP implementation selected by composition.
+     * @param clock Borrowed clock for transport deadlines; times are milliseconds.
+     * @param hab Optional default local signer; null requires an unambiguous sole habitat.
+     */
+    constructor(hby: Habery, protocol: ProtocolProcessor, http: HttpClient, clock: RuntimeClock, hab?: Hab | null);
+    /**
+     * Select the local habitat used when queued requests have no explicit signer.
+     *
+     * @param options Optional default signing habitat; omission/null clears the explicit selection.
+     */
+    configure({ hab }?: {
+        hab?: Hab | null;
+    }): void;
+    /** Deferred instructions and active sends are this sender's only pending work. */
+    hasPendingWork(): boolean;
+    /**
+     * Queue for later resolution/delivery: copy the top level/witness list only.
+     * Nested query values remain borrowed immutable data until consumption or joined close retires the record.
+     *
+     * @param request Typed request; signer names a local AID and src names a remote attester.
+     */
+    enqueue(request: QueryRequest): void;
+    /**
+     * Admit a routed query cue for sender-owned resolution and one concrete transport attempt.
+     *
+     * @param cue Typed query cue; missing route/subject produces no request.
+     * @param hab Optional local signer hint when the cue has no explicit signer.
+     */
+    enqueueCue(cue: QueryCue, hab?: Hab | null): void;
+    /** Include actual query I/O in convergence; pending instructions have their own queue. */
+    get hasPendingDelivery(): boolean;
+    /**
+     * Attempt at most the work present when this pass starts, preserving new work
+     * for a later pass. Unresolved records rotate to the tail. A recognized send
+     * failure ends the pass and throws after cleanup; remaining requests stay queued.
+     * Calling during an active pass or after close performs no work.
+     */
+    deliverOnce(): Operation<void>;
+    /**
+     * Own one joined output scope for the pass. Catch only the actual post attempt's
+     * TransportError/CesrHttpRefusal as expected send outcomes. Resolution and
+     * signing failures stay outside that catch even when they use the same error
+     * type; joined-scope teardown failures also escape background reporting.
+     */
+    private deliveryPass;
+    /**
+     * Use ordinary POST delivery for HTTP, draining successful bytes without
+     * parsing them. The independent mailbox/direct receiver accepts HTTP replies.
+     * TCP explicitly enables same-connection reply processing before completion.
+     *
+     * @param delivery Retained signed packet including introduction and destination.
+     * @param controller Sender attempt cancellation; its signal covers response parsing and cleanup.
+     */
+    private postQueryMessage;
+    /**
+     * Stop admission, abort/join active transport and parser cleanup, then discard
+     * unsigned pending work. Does not close borrowed collaborators or Baser.
+     * Repeating close is harmless; genuine cleanup failures remain visible.
+     */
+    close(): Operation<void>;
+    /**
+     * Long-lived sender worker, run once by composition. Report an expected send
+     * failure once, then continue remaining requests on a later turn. Unexpected
+     * preparation/cleanup faults terminate the worker. Caller cancellation joins
+     * the current attempt; it does not close the borrowed state or HTTP service.
+     */
+    deliverDo(): Operation<never>;
+    /**
+     * Resolve the habitat that is allowed to sign the outbound query.
+     *
+     * Resolution order:
+     * - explicitly selected local signer (unavailable means unresolved, never fallback)
+     * - runtime-configured habitat
+     * - sole local habitat
+     *
+     * @param signer Explicit local AID; if unavailable return null rather than falling back.
+     * @returns Explicit signer, configured habitat or sole local habitat; otherwise null.
+     */
+    private configuredHab;
+    /**
+     * Resolve/sign one selected query and introduction immediately before its attempt.
+     *
+     * @param request Deferred unsigned request; nested query values must remain immutable.
+     * @returns Prepared packet, or null when signer/attester evidence is unresolved.
+     * @throws A selected attester with no endpoint URL throws; source removal remains with the caller.
+     */
+    private prepareRequest;
+    /**
+     * Return the first eligible role’s attester IDs; preparation chooses one randomly.
+     *
+     * @param pre Subject AID whose accepted endpoint roles are consulted.
+     * @param options Optional local signer AID and remote witness/attester overrides; neither selects a transport implementation.
+     * @returns Eligible attester AIDs, or an empty array for an unknown subject or unresolved signer/role.
+     */
+    attestersFor(pre: string, { signer, wits }?: {
+        signer?: string;
+        wits?: string[];
+    }): string[];
+}
+//# sourceMappingURL=witness-inquisitor.d.ts.map

package/types/app/queries/witness-inquisitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-inquisitor.d.ts","sourceRoot":"","sources":["../../../src/app/queries/witness-inquisitor.ts"],"names":[],"mappings":"AAWA,OAAO,EAAQ,KAAK,SAAS,EAAY,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAoB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAM1C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AA+F9D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAiB;IAC5B,wDAAwD;IACxD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,gEAAgE;IAChE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,sDAAsD;IACtD,OAAO,CAAC,UAAU,CAAS;IAC3B,sDAAsD;IACtD,OAAO,CAAC,MAAM,CAAC,CAAkB;IACjC,2EAA2E;IAC3E,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IACrD,+EAA+E;IAC/E,IAAI,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,UAAU,CAAC,CAEvE;IACD,uEAAuE;IACvE,OAAO,CAAC,MAAM,CAAS;IACvB,qEAAqE;IACrE,OAAO,CAAC,GAAG,CAAa;IAExB;;;;;;;;OAQG;gBACS,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,GAAE,GAAG,GAAG,IAAW;IASnH;;;;OAIG;IACH,SAAS,CAAC,EAAE,GAAU,EAAE,GAAE;QAAE,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAA;KAAO,GAAG,IAAI;IAI1D,kFAAkF;IAClF,cAAc,IAAI,OAAO;IAIzB;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IASpC;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI;IAQjD,0FAA0F;IAC1F,IAAI,kBAAkB,IAAI,OAAO,CAEhC;IAED;;;;;OAKG;IACF,WAAW,IAAI,SAAS,CAAC,IAAI,CAAC;IAK/B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAyCpB;;;;;;;OAOG;IACH,OAAO,CAAE,gBAAgB;IAmBzB;;;;OAIG;IACF,KAAK,IAAI,SAAS,CAAC,IAAI,CAAC;IAOzB;;;;;OAKG;IACF,SAAS,IAAI,SAAS,CAAC,KAAK,CAAC;IAQ9B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAetB;;;;;;OAMG;IACH,YAAY,CACV,GAAG,EAAE,MAAM,EACX,EAAE,MAAM,EAAE,IAAI,EAAE,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO,GAC1D,MAAM,EAAE;CAoBZ"}

package/types/app/runtime/abortable.d.ts

@@ -0,0 +1,39 @@
+import { type Operation, type Scope } from "effection";
+/**
+ * Identify foreign failures while joining cancelled work, without throwing as a filter.
+ *
+ * @param error Failure from joined I/O, possibly an AggregateError.
+ * @param signal Owner whose exact cancellation reason may be removed.
+ * @returns Foreign failures, preserving unchanged aggregates and error identities.
+ */
+export declare function cleanupFailures(error: unknown, signal: AbortSignal): unknown[];
+/**
+ * Stop the containing race when an upstream signal aborts, including pre-abort.
+ *
+ * @param signal Actual caller cancellation; register before checking its current state.
+ * @throws The signal's exact reason. The operation never completes normally.
+ */
+export declare function throwOnAbort(signal: AbortSignal): Operation<never>;
+/**
+ * Preserve foreign cleanup failures, removing only this owner's exact abort reason.
+ *
+ * @param error Failure observed during joined cleanup.
+ * @param signal Owner signal whose exact reason may be suppressed.
+ * @throws The original foreign failure, or an AggregateError containing multiple remaining failures.
+ */
+export declare function rethrowCleanupFailure(error: unknown, signal: AbortSignal): void;
+/**
+ * Own one cancellable Promise leaf inside an Effection operation.
+ * The leaf must observe its signal; teardown aborts it and joins its cleanup before returning.
+ * An isolated call scope keeps cancellation abrupt even while finalization yields.
+ * Register dependent owner resources before this leaf so reverse teardown joins it before disposal.
+ * Owned concurrent work uses the supplied leaf scope, so its signal aborts before child cleanup joins.
+ * Borrow that scope only for work joined within the leaf, never for later operations.
+ *
+ * @param start Starts the Promise leaf with an owned signal and scope; must observe abort and join any work borrowed from that scope.
+ * @param upstream Optional caller cancellation combined with the leaf's own signal.
+ * @returns The leaf result after successful completion; scope teardown joins pending work.
+ * @throws The leaf error or a foreign cleanup failure; exact owned cancellation is filtered during cleanup.
+ */
+export declare function abortable<T>(start: (signal: AbortSignal, scope: Scope) => Promise<T>, upstream?: AbortSignal): Operation<T>;
+//# sourceMappingURL=abortable.d.ts.map

package/types/app/runtime/abortable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortable.d.ts","sourceRoot":"","sources":["../../../src/app/runtime/abortable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,KAAK,EAAY,MAAM,WAAW,CAAC;AAkBnF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,EAAE,CAE9E;AAED;;;;;GAKG;AACH,wBAAiB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC,KAAK,CAAC,CAKnE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAI/E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,EACxD,QAAQ,CAAC,EAAE,WAAW,GACrB,SAAS,CAAC,CAAC,CAAC,CA+Bd"}