@loomwork/ui-lineage 0.0.0-stage → 0.1.1

package/dist/seen.d.ts

@@ -0,0 +1,375 @@
+import { type ContentStore } from "@loomwork/plugin-content";
+import { type Audience, type DeclaredToolClasses, type ProjectionCatalog, type ReadPolicy, type SeenEntry, type SeenSnapshot, type UndeclaredToolPolicy, type Viewer } from "@loomwork/ui-core";
+import { z } from "zod";
+import type { Lineage, LineageResult, Refused } from "./lineage";
+import { type SeenKeyStore } from "./seenCrypto";
+import { type LineageStore } from "./store";
+export declare const VIEW_RECORDED = "VIEW_RECORDED";
+/** A retention watermark: every record at or below `floor` has rolled off. */
+export declare const VIEWS_RETAINED = "VIEWS_RETAINED";
+/** The viewer was erased (written AFTER the key is destroyed; a rerun completes it). */
+export declare const VIEWER_ERASED = "VIEWER_ERASED";
+/** The reserved-stream namespace a viewer's record lives under (distinct from the lineage's). */
+export declare const SEEN_STREAM_PREFIX = "__loom_ui_seen__:";
+export declare const SEEN_WORKFLOW_ID = "loom-ui.seen";
+/** Default most views a viewer's log keeps readable; older ones roll off (never a refusal). */
+export declare const DEFAULT_MAX_SEEN_VIEWS = 10000;
+/** Most records one read returns. */
+export declare const MAX_SEEN_READ = 500;
+export declare const ViewRecordPayload: z.ZodObject<{
+    experienceId: z.ZodString;
+    versionHash: z.ZodString;
+    viewerId: z.ZodString;
+    /** The clearance the viewer held when shown the surface (informational: reads use the READER's). */
+    clearance: z.ZodOptional<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        source: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"handle">;
+            handle: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "handle";
+            handle: string;
+        }, {
+            kind: "handle";
+            handle: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"projection">;
+            id: z.ZodString;
+            path: z.ZodString;
+            version: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            kind: "projection";
+            id: string;
+            version: string;
+        }, {
+            path: string;
+            kind: "projection";
+            id: string;
+            version: string;
+        }>]>;
+        nodeIds: z.ZodArray<z.ZodString, "many">;
+        class: z.ZodString;
+        state: z.ZodEnum<["seen", "absent", "oversize", "over-budget", "unreadable"]>;
+        status: z.ZodOptional<z.ZodString>;
+        /** Only for `oversize` / `over-budget` (where the size is the recorded fact). A `seen` entry's size lives inside `sealed`. */
+        bytes: z.ZodOptional<z.ZodNumber>;
+        /** `{ref, bytes}`, constant-length padded and AEAD-sealed under the viewer's data key (see the header). Never a plain address. */
+        sealed: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        state: "seen" | "absent" | "oversize" | "over-budget" | "unreadable";
+        source: {
+            kind: "handle";
+            handle: string;
+        } | {
+            path: string;
+            kind: "projection";
+            id: string;
+            version: string;
+        };
+        nodeIds: string[];
+        class: string;
+        status?: string | undefined;
+        bytes?: number | undefined;
+        sealed?: string | undefined;
+    }, {
+        state: "seen" | "absent" | "oversize" | "over-budget" | "unreadable";
+        source: {
+            kind: "handle";
+            handle: string;
+        } | {
+            path: string;
+            kind: "projection";
+            id: string;
+            version: string;
+        };
+        nodeIds: string[];
+        class: string;
+        status?: string | undefined;
+        bytes?: number | undefined;
+        sealed?: string | undefined;
+    }>, "many">;
+    omitted: z.ZodNumber;
+    restricted: z.ZodBoolean;
+    /** Keyed digest (HMAC under the viewer's key) of the manifest's meaning: an identical consecutive view is not re-recorded. */
+    digest: z.ZodString;
+    /** The retention floor in force when this was written (see the header). */
+    floor: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        state: "seen" | "absent" | "oversize" | "over-budget" | "unreadable";
+        source: {
+            kind: "handle";
+            handle: string;
+        } | {
+            path: string;
+            kind: "projection";
+            id: string;
+            version: string;
+        };
+        nodeIds: string[];
+        class: string;
+        status?: string | undefined;
+        bytes?: number | undefined;
+        sealed?: string | undefined;
+    }[];
+    experienceId: string;
+    versionHash: string;
+    viewerId: string;
+    omitted: number;
+    restricted: boolean;
+    digest: string;
+    clearance?: string | undefined;
+    floor?: number | undefined;
+}, {
+    entries: {
+        state: "seen" | "absent" | "oversize" | "over-budget" | "unreadable";
+        source: {
+            kind: "handle";
+            handle: string;
+        } | {
+            path: string;
+            kind: "projection";
+            id: string;
+            version: string;
+        };
+        nodeIds: string[];
+        class: string;
+        status?: string | undefined;
+        bytes?: number | undefined;
+        sealed?: string | undefined;
+    }[];
+    experienceId: string;
+    versionHash: string;
+    viewerId: string;
+    omitted: number;
+    restricted: boolean;
+    digest: string;
+    clearance?: string | undefined;
+    floor?: number | undefined;
+}>;
+export type ViewRecordPayload = z.infer<typeof ViewRecordPayload>;
+/** How long a viewer's views stay readable (and their value blobs live). Old views roll off; new ones always record. */
+export interface SeenRetention {
+    /** Most views kept readable per viewer (default {@link DEFAULT_MAX_SEEN_VIEWS}). */
+    readonly maxViews?: number;
+    /** Views older than this (ms, by the record's own time) roll off. Default: no age limit. */
+    readonly maxAgeMs?: number;
+    /**
+     * The clock skew tolerated between writers (ms, default {@link DEFAULT_MAX_SKEW_MS}). READS apply
+     * `maxAgeMs` exactly, but the two IRREVERSIBLE age actions are conservative by this much: a
+     * persisted `VIEWS_RETAINED` watermark only covers views older than `maxAgeMs + maxSkewMs` by the
+     * writer's clock, and the collector keeps the blobs of views younger than that. So a writer whose
+     * clock runs ahead by up to `maxSkewMs` cannot roll off, or get swept, a view that is still inside
+     * the window by true time (a writer further ahead than this is an operator clock fault).
+     */
+    readonly maxSkewMs?: number;
+}
+/** The smallest power of two >= `n` (0 stays 0): the only size an `oversize` / `over-budget` entry stores. */
+export declare function sizeClass(n: number): number;
+/** Default tolerated clock skew between writers (5 minutes). */
+export declare const DEFAULT_MAX_SKEW_MS = 300000;
+/** What the collector could not read inside the live window (see {@link SeenLog.forEachLiveRef}). */
+export interface SeenUnreadable {
+    /** Streams whose key does not round-trip `seenStreamKey`. */
+    readonly streams: number;
+    /** `VIEW_RECORDED` records that failed to parse (a newer writer's shape, corruption) or name another viewer. */
+    readonly records: number;
+    /** Sealed refs that failed to open while the key IS present (unknown version, rotated key, tamper). */
+    readonly refs: number;
+    /** Where to look: at most {@link UNREADABLE_EXAMPLES} identifiers per kind (stream keys; `experience/viewer@sequence` records; `experience/viewer@sequence#entry` refs). */
+    readonly examples: {
+        readonly streams: readonly string[];
+        readonly records: readonly string[];
+        readonly refs: readonly string[];
+    };
+}
+/** Cap on the offenders named per kind in {@link SeenUnreadable.examples}. */
+export declare const UNREADABLE_EXAMPLES = 16;
+export interface SeenLogOptions {
+    /** A `LineageStore` over a namespace of its own (`eventStoreLineageStore(store, { streamPrefix: SEEN_STREAM_PREFIX, workflowId: SEEN_WORKFLOW_ID })`). */
+    readonly events: LineageStore;
+    /** Where value bytes live. The same store the lineage uses is fine: addresses are content hashes. */
+    readonly content: ContentStore;
+    /** Resolves the version a record names (and refuses one that is not a version of the line). */
+    readonly lineage: Lineage;
+    /** Per-(experience, viewer) data keys. Destroying one erases that viewer. A loom `KeyStore` fits. */
+    readonly keys: SeenKeyStore;
+    readonly retention?: SeenRetention;
+    readonly now?: () => string;
+    /**
+     * The read policy bound ONCE: every `record` and `read` applies it, joined (raise-only) with the
+     * `lineage`'s own bound policy and with any per-call values. Absent = the lineage's policy alone.
+     */
+    readonly readPolicy?: ReadPolicy;
+}
+/**
+ * Why a seen-log call did not happen. It IS a lineage `Refused` (`kind`, `finding`), so a
+ * `SeenResult<T>` is assignable to a `LineageResult<T>`, and it keeps the flat `code` / `message`
+ * every seen-log caller already reads (the same values as `finding.code` / `finding.message`).
+ */
+export type SeenRefusal = Refused & {
+    readonly code: string;
+    readonly message: string;
+};
+export type SeenResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    refusal: SeenRefusal;
+};
+export interface SeenView {
+    readonly sequence: number;
+    readonly at: string;
+    readonly versionHash: string;
+    /** The entries THIS reader may see, values resolved. */
+    readonly entries: readonly SeenEntry[];
+    /** Something was withheld from this reader (a class, an unreadable stamp, a missing artifact): no count, no name. */
+    readonly restricted: boolean;
+    /** Sources the capture dropped at its source cap. */
+    readonly omitted: number;
+}
+export declare const seenStreamKey: (experienceId: string, viewerId: string) => string;
+export declare class SeenLog {
+    private readonly events;
+    private readonly content;
+    private readonly lineage;
+    private readonly keys;
+    private readonly maxViews;
+    private readonly maxAgeMs;
+    private readonly maxSkewMs;
+    private readonly slack;
+    private readonly now;
+    private readonly policy;
+    constructor(opts: SeenLogOptions);
+    /** The content store value blobs live in (for the collector). */
+    get contentStore(): ContentStore;
+    /** The lineage the records name versions of (for the collector's roots). */
+    get lineageOf(): Lineage;
+    private lastRecords;
+    private after;
+    /** The live views (oldest first) of a window: after the floor, inside the age limit, newest `maxViews`. */
+    private liveViews;
+    /**
+     * Record that `viewerId` was shown `snapshot` (built with core's `snapshotSeen`). The snapshot is
+     * not trusted: its version must be a version of the line, its entries are re-validated, re-capped
+     * and RESTAMPED against that version's artifact (a stamp laxer than the artifact says is raised; an
+     * entry the recording viewer may not see is dropped), and values are measured again. An identical
+     * consecutive view records nothing (`recorded: false`). A new view ALWAYS records: when the
+     * viewer's window is full, the oldest views roll off (see the header). Refuses an erased viewer.
+     * Performs no authorization: `viewerId` and `viewer` are the host's claims.
+     */
+    record(input: {
+        readonly experienceId: string;
+        readonly viewerId: string;
+        readonly snapshot: SeenSnapshot;
+        readonly viewer?: Viewer;
+        /** The audience the surface was drawn for: `"broadcast"` records only what a viewer with no clearance saw. */
+        readonly audience?: Audience;
+        readonly projections?: ProjectionCatalog;
+        readonly hydrationProjectionId?: string;
+        readonly declaredToolClasses?: DeclaredToolClasses;
+        readonly undeclared?: UndeclaredToolPolicy;
+    }): Promise<SeenResult<{
+        readonly recorded: boolean;
+        readonly sequence: number;
+    }>>;
+    /**
+     * Retention: append a watermark when enough has aged out. Best effort (a lost race or a failure
+     * only defers it: reads and the collector apply the window themselves, so correctness never
+     * depends on a watermark having been written). `slack` batches the writes: one watermark per
+     * `slack` roll-offs, not one per view.
+     */
+    private rollOff;
+    /**
+     * Erase a viewer: destroy their data key (the irreversible step), then write a tombstone. After
+     * it, the stream holds no decryptable ref, `read` reports `erased: true`, and `record` refuses.
+     * Idempotent and safe to rerun after a crash (a rerun completes whichever half is missing). The
+     * value BLOBS the viewer cited are reclaimed by the next `collectSeenGarbage` pass (unless another
+     * viewer or the lineage still cites them). The stream's structure stays (see the header).
+     * AUTHORIZATION IS THE HOST'S: erasing a (experience, viewer) pair that never existed still
+     * writes a tombstone stream (and permanently bars that viewer from recording there), so the host
+     * decides who may erase what; this method performs no check.
+     */
+    eraseViewer(input: {
+        readonly experienceId: string;
+        readonly viewerId: string;
+    }): Promise<SeenResult<{
+        readonly erased: true;
+    }>>;
+    /**
+     * Erase ONE data subject across every experience: enumerate the seen streams (`listStreams`;
+     * refused with `seen-enumeration-unavailable` if the store cannot), and erase `viewerId`'s stream in
+     * each experience (see {@link eraseViewer}, including its authorization note). Idempotent and
+     * resumable: a rerun skips what is erased and completes what is not. A per-experience failure does
+     * not stop the others; `complete` is true only when every experience was erased.
+     *
+     * COVERAGE: only streams that EXIST when enumeration runs are erased. A stream created after
+     * that point (a new view by this viewer during the erase) is not covered: the host must serialize
+     * erasure against new views for the subject, or rerun. An orphan key with no stream (a crash
+     * between `getOrCreate` and the first append) is not destroyed by this enumeration; it holds no
+     * data (a key and nothing sealed under it).
+     */
+    eraseViewerEverywhere(input: {
+        readonly viewerId: string;
+    }): Promise<SeenResult<{
+        readonly results: ReadonlyArray<{
+            readonly experienceId: string;
+            readonly erased: boolean;
+            readonly refusal?: SeenRefusal;
+        }>;
+        readonly complete: boolean;
+    }>>;
+    /**
+     * What `viewerId` was shown, newest first (at most `limit`, default 20, hard cap
+     * `MAX_SEEN_READ`), as seen by `reader`: entries the reader may not see are withheld (and
+     * `restricted` says only that something was), BEFORE any value blob is fetched. Only views inside
+     * the retention window are returned. A malformed record is counted in `malformed`, never thrown.
+     * `until` (ISO time) keeps records at or before it: the view as of then. An erased viewer (key
+     * destroyed or tombstoned) returns `{ erased: true, views: [] }`: nothing is decryptable, so
+     * nothing is shown.
+     */
+    read(input: {
+        readonly experienceId: string;
+        readonly viewerId: string;
+        readonly reader?: Viewer;
+        /** The audience the READ serves: `"broadcast"` reads as a viewer with no clearance. */
+        readonly audience?: Audience;
+        readonly limit?: number;
+        readonly until?: string;
+        readonly projections?: ProjectionCatalog;
+        readonly hydrationProjectionId?: string;
+        readonly declaredToolClasses?: DeclaredToolClasses;
+        readonly undeclared?: UndeclaredToolPolicy;
+    }): Promise<SeenResult<{
+        readonly views: readonly SeenView[];
+        readonly malformed: number;
+        readonly erased: boolean;
+    }>>;
+    private openRef;
+    /**
+     * Call `visit` with the content address of every DECRYPTABLE ref inside every viewer's retention
+     * window (kept conservatively: views inside `maxAgeMs + maxSkewMs`; with out-of-order timestamps within `maxSkewMs` at the `maxViews` cap this window can differ from the exact read window's newest-N, in the direction of keeping MORE): the seen log's half of the
+     * collector's root set. Erased viewers (key ABSENT: the shred path) and rolled-off views
+     * contribute nothing, which is exactly what lets their unique blobs be swept. THROWS if the store
+     * cannot enumerate its streams or the key store fails (an unreadable root is not an absent one).
+     *
+     * Returns what it could NOT read inside the live window (a stream key that does not round-trip, a
+     * record that fails to parse, a sealed ref that fails to open under a PRESENT key). Those are not
+     * absent either: whatever they cite is unrooted here, so a collector must refuse to sweep on a
+     * non-zero count (see `collectSeenGarbage`).
+     *
+     * `visitVersion` (optional) is called with the (experience, version) of every live view: the seen log
+     * READS that version's artifact from the lineage, so a collector that reclaims old versions must
+     * keep it (see `collectSeenRoots`).
+     */
+    forEachLiveRef(visit: (address: string) => void, visitVersion?: (experienceId: string, versionHash: string) => void): Promise<SeenUnreadable>;
+}
+/** Convenience: the manifest stream a `SeenLog` over an `EventStore` should use. */
+export declare const seenStoreOptions: {
+    readonly streamPrefix: "__loom_ui_seen__:";
+    readonly workflowId: "loom-ui.seen";
+};
+export type { LineageResult };
+//# sourceMappingURL=seen.d.ts.map

package/dist/seen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seen.d.ts","sourceRoot":"","sources":["../src/seen.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAIlB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAMxB,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,MAAM,EAIZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAW,OAAO,EAAE,MAAM,WAAW,CAAC;AAC1E,OAAO,EAEL,KAAK,YAAY,EAOlB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAyB,KAAK,YAAY,EAA4B,MAAM,SAAS,CAAC;AAsD7F,eAAO,MAAM,aAAa,kBAAkB,CAAC;AAC7C,8EAA8E;AAC9E,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAC/C,wFAAwF;AACxF,eAAO,MAAM,aAAa,kBAAkB,CAAC;AAC7C,iGAAiG;AACjG,eAAO,MAAM,kBAAkB,sBAAsB,CAAC;AACtD,eAAO,MAAM,gBAAgB,iBAAiB,CAAC;AAC/C,+FAA+F;AAC/F,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAC7C,qCAAqC;AACrC,eAAO,MAAM,aAAa,MAAM,CAAC;AA2BjC,eAAO,MAAM,iBAAiB;;;;IAI5B,oGAAoG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QATpG,8HAA8H;;QAE9H,kIAAkI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYlI,8HAA8H;;IAE9H,2EAA2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,wHAAwH;AACxH,MAAM,WAAW,aAAa;IAC5B,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,4FAA4F;IAC5F,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,8GAA8G;AAC9G,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG3C;AAED,gEAAgE;AAChE,eAAO,MAAM,mBAAmB,SAAU,CAAC;AAI3C,qGAAqG;AACrG,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gHAAgH;IAChH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4KAA4K;IAC5K,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;QACpC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;QACpC,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;KAClC,CAAC;CACH;AACD,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,MAAM,WAAW,cAAc;IAC7B,0JAA0J;IAC1J,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,qGAAqG;IACrG,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,+FAA+F;IAC/F,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,qGAAqG;IACrG,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC;IACnC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AACxF,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAmCzF,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;IACvC,qHAAqH;IACrH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,aAAa,GAAI,cAAc,MAAM,EAAE,UAAU,MAAM,KAAG,MACA,CAAC;AA8CxE,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAe;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;gBAExB,IAAI,EAAE,cAAc;IAmChC,iEAAiE;IACjE,IAAI,YAAY,IAAI,YAAY,CAE/B;IACD,4EAA4E;IAC5E,IAAI,SAAS,IAAI,OAAO,CAEvB;YAIa,WAAW;YAMX,KAAK;IAKnB,2GAA2G;IAC3G,OAAO,CAAC,SAAS;IAajB;;;;;;;;OAQG;IACG,MAAM,CAAC,KAAK,EAAE;QAClB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;QAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QACzB,8GAA8G;QAC9G,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;QAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;QACzC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;QACxC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;QACnD,QAAQ,CAAC,UAAU,CAAC,EAAE,oBAAoB,CAAC;KAC5C,GAAG,OAAO,CAAC,UAAU,CAAC;QAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAoLlF;;;;;OAKG;YACW,OAAO;IA8CrB;;;;;;;;;OASG;IACG,WAAW,CAAC,KAAK,EAAE;QACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,GAAG,OAAO,CAAC,UAAU,CAAC;QAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IA6BlD;;;;;;;;;;;;OAYG;IACG,qBAAqB,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CACxE,UAAU,CAAC;QACT,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;YAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;YAC9B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;YACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC;SAChC,CAAC,CAAC;QACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;KAC5B,CAAC,CACH;IA6BD;;;;;;;;OAQG;IACG,IAAI,CAAC,KAAK,EAAE;QAChB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QACzB,uFAAuF;QACvF,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;QAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;QACzC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;QACxC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;QACnD,QAAQ,CAAC,UAAU,CAAC,EAAE,oBAAoB,CAAC;KAC5C,GAAG,OAAO,CACT,UAAU,CAAC;QACT,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;QACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;KAC1B,CAAC,CACH;IAmHD,OAAO,CAAC,OAAO;IAWf;;;;;;;;;;;;;;;OAeG;IACG,cAAc,CAClB,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EAChC,YAAY,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,GACjE,OAAO,CAAC,cAAc,CAAC;CAgD3B;AAED,oFAAoF;AACpF,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,YAAY,EAAE,aAAa,EAAE,CAAC"}