@freqhole/reliquary 0.0.0

package/dist/transfer/prefetch.test.js

@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+import { createPrefetcher } from "./prefetch.js";
+function item(id, cost) {
+    return { id, cost };
+}
+describe("Prefetcher", () => {
+    it("selects a budget-limited prefix and fetches every selected item", async () => {
+        const prefetcher = createPrefetcher();
+        const fetched = [];
+        const settled = [];
+        let resolveAll;
+        const done = new Promise((resolve) => {
+            resolveAll = resolve;
+        });
+        const items = [item("a", 10), item("b", 10), item("c", 10), item("d", 10)];
+        prefetcher.run(items, {
+            budget: 25,
+            costOf: (it) => it.cost,
+            fetchItem: async (it) => {
+                fetched.push(it.id);
+            },
+            onSettled: (it) => {
+                settled.push(it.id);
+                if (settled.length === 3)
+                    resolveAll();
+            },
+        });
+        await done;
+        // budget 25: a (15 left), b (5 left), c (-5, still selected since
+        // budget was > 0 before subtracting) - the budget check happens in
+        // the loop condition, the subtraction after, so the item that
+        // crosses zero is still included.
+        expect(fetched.sort()).toEqual(["a", "b", "c"]);
+        expect(settled.sort()).toEqual(["a", "b", "c"]);
+    });
+    it("fires onPending for every selected item before fetching starts", async () => {
+        const prefetcher = createPrefetcher();
+        const pending = [];
+        let resolveAll;
+        const done = new Promise((resolve) => {
+            resolveAll = resolve;
+        });
+        prefetcher.run([item("a", 5), item("b", 5)], {
+            budget: 100,
+            costOf: (it) => it.cost,
+            fetchItem: async () => { },
+            onPending: (it) => pending.push(it.id),
+            onSettled: () => {
+                if (pending.length === 2)
+                    resolveAll();
+            },
+        });
+        await done;
+        expect(pending).toEqual(["a", "b"]);
+    });
+    it("stops selecting once the budget runs out", async () => {
+        const prefetcher = createPrefetcher();
+        const pending = [];
+        let resolveAll;
+        const done = new Promise((resolve) => {
+            resolveAll = resolve;
+        });
+        prefetcher.run([item("a", 100), item("b", 5), item("c", 5)], {
+            budget: 50,
+            costOf: (it) => it.cost,
+            fetchItem: async () => { },
+            onPending: (it) => pending.push(it.id),
+            onSettled: () => resolveAll(),
+        });
+        await done;
+        // "a" alone exhausts the budget (100 > 50 remaining after selection),
+        // so "b"/"c" are never even considered.
+        expect(pending).toEqual(["a"]);
+    });
+    it("supersedes an in-flight run when run() is called again", async () => {
+        const prefetcher = createPrefetcher();
+        const fetchOrder = [];
+        let releaseFirst;
+        const firstGate = new Promise((resolve) => {
+            releaseFirst = resolve;
+        });
+        prefetcher.run([item("a", 1), item("b", 1)], {
+            budget: 10,
+            costOf: (it) => it.cost,
+            concurrency: 1,
+            fetchItem: async (it) => {
+                fetchOrder.push(it.id);
+                if (it.id === "a")
+                    await firstGate;
+            },
+        });
+        // give the first run a tick to select+start fetching "a", then
+        // supersede it before it reaches "b".
+        await new Promise((r) => setTimeout(r, 0));
+        let secondDone;
+        const secondFinished = new Promise((resolve) => {
+            secondDone = resolve;
+        });
+        prefetcher.run([item("c", 1)], {
+            budget: 10,
+            costOf: (it) => it.cost,
+            fetchItem: async (it) => {
+                fetchOrder.push(it.id);
+            },
+            onSettled: () => secondDone(),
+        });
+        await secondFinished;
+        releaseFirst();
+        await new Promise((r) => setTimeout(r, 0));
+        expect(fetchOrder).toContain("a");
+        expect(fetchOrder).toContain("c");
+        expect(fetchOrder).not.toContain("b");
+    });
+    it("fires onSettled for selected-but-not-yet-fetched items when superseded", async () => {
+        const prefetcher = createPrefetcher();
+        const settled = [];
+        prefetcher.run([item("a", 1), item("b", 1), item("c", 1)], {
+            budget: 10,
+            costOf: (it) => it.cost,
+            concurrency: 1,
+            fetchItem: async () => {
+                await new Promise((r) => setTimeout(r, 20));
+            },
+            onSettled: (it) => settled.push(it.id),
+        });
+        await new Promise((r) => setTimeout(r, 0));
+        prefetcher.run([], { budget: 0, costOf: () => 0, fetchItem: async () => { } });
+        await new Promise((r) => setTimeout(r, 50));
+        // "a" was mid-flight when superseded (its own batch already started,
+        // so it still completes); "b" and "c" were selected but never reached
+        // a batch - both get a settled callback anyway so ui pending state
+        // never leaks.
+        expect(settled).toContain("b");
+        expect(settled).toContain("c");
+    });
+});

package/dist/transfer/serve.d.ts

@@ -0,0 +1,66 @@
+import type { BlobCapableNode } from "./types.js";
+/** how long an imported blob stays available after its last request,
+ *  absent an explicit override. */
+export declare const DEFAULT_RELEASE_AFTER_MS: number;
+export interface BlobServerOptions {
+    /** ms an imported blob stays available after its last request. */
+    releaseAfterMs?: number;
+}
+export interface ServedBlobInfo {
+    blake3: string;
+    size: number;
+    mime?: string;
+}
+/**
+ * server-side import cache for peer-served blobs. imports a locally-known
+ * blob into the transport node's store on first request, keyed by
+ * whatever id the app addresses that blob by (a sha256, a rest-style blob
+ * id, ...) - not necessarily the blake3 hash the peer ends up downloading
+ * by. every repeat request for the same id resets the release timer
+ * rather than re-importing.
+ */
+export declare class BlobServer {
+    private readonly node;
+    private readonly options;
+    private readonly served;
+    constructor(node: BlobCapableNode, options?: BlobServerOptions);
+    /** true when `id` is currently tracked (imported and not yet released). */
+    has(id: string): boolean;
+    /** the tracked info for `id`, without resetting its release timer, or
+     *  `null` when not currently tracked. */
+    peek(id: string): ServedBlobInfo | null;
+    /** import (on first request) and (always) reset the release timer for
+     *  `id`. `resolve` is only called on a cache miss - a repeat request
+     *  never re-reads or re-imports the source bytes. */
+    serve(id: string, resolve: () => Promise<{
+        bytes: Uint8Array;
+        size: number;
+        mime?: string;
+    }>): Promise<ServedBlobInfo>;
+    /** reset the release timer for `id` without re-importing. a no-op when
+     *  `id` isn't currently tracked. */
+    touch(id: string): void;
+    /** stop tracking `id` and release it from the node's store immediately,
+     *  instead of waiting out the release timer. */
+    release(id: string): void;
+    /** number of ids currently tracked (import-cache size). */
+    size(): number;
+    /** clear every release timer and release every tracked blob from the
+     *  node's store - call on shutdown so nothing stays pinned behind it. */
+    dispose(): void;
+    private scheduleRelease;
+    private releaseFromNode;
+}
+/**
+ * answer a peer's blob request: resolve the blob's bytes locally (via
+ * `resolve`, only called on a cache miss) and stage it into the
+ * transport node's store through `server`, returning the blake3 hash +
+ * size the peer downloads by. returns `null` when `resolve` reports no
+ * such blob.
+ */
+export declare function serveBlobRequest(server: BlobServer, id: string, resolve: (id: string) => Promise<{
+    bytes: Uint8Array;
+    size: number;
+    mime?: string;
+} | null>): Promise<ServedBlobInfo | null>;
+//# sourceMappingURL=serve.d.ts.map

package/dist/transfer/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/transfer/serve.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD;mCACmC;AACnC,eAAO,MAAM,wBAAwB,QAAiB,CAAC;AAEvD,MAAM,WAAW,iBAAiB;IAChC,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAMD;;;;;;;GAOG;AACH,qBAAa,UAAU;IAInB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;gBAGtC,IAAI,EAAE,eAAe,EACrB,OAAO,GAAE,iBAAsB;IAGlD,2EAA2E;IAC3E,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB;6CACyC;IACzC,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAMvC;;yDAEqD;IAC/C,KAAK,CACT,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,OAAO,CAAC;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GACzE,OAAO,CAAC,cAAc,CAAC;IAkB1B;wCACoC;IACpC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKvB;oDACgD;IAChD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQzB,2DAA2D;IAC3D,IAAI,IAAI,MAAM;IAId;6EACyE;IACzE,OAAO,IAAI,IAAI;IAQf,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,eAAe;CAOxB;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,UAAU,EAClB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,GAC1F,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAWhC"}

package/dist/transfer/serve.js

@@ -0,0 +1,126 @@
+// serve side of p2p blob transfer: import cache + release timer.
+//
+// answering a peer's blob request means staging the blob's bytes into the
+// transport node's own store (so verified-transfer downloads can read it),
+// then releasing that stage once nobody has asked for it in a while so
+// served memory doesn't grow unboundedly. `BlobServer` is that cache;
+// `serveBlobRequest` is a thin resolver-based wrapper over it.
+import { log } from "../utils/log.js";
+const TAG = "transfer.serve";
+/** how long an imported blob stays available after its last request,
+ *  absent an explicit override. */
+export const DEFAULT_RELEASE_AFTER_MS = 10 * 60 * 1000;
+/**
+ * server-side import cache for peer-served blobs. imports a locally-known
+ * blob into the transport node's store on first request, keyed by
+ * whatever id the app addresses that blob by (a sha256, a rest-style blob
+ * id, ...) - not necessarily the blake3 hash the peer ends up downloading
+ * by. every repeat request for the same id resets the release timer
+ * rather than re-importing.
+ */
+export class BlobServer {
+    node;
+    options;
+    served = new Map();
+    constructor(node, options = {}) {
+        this.node = node;
+        this.options = options;
+    }
+    /** true when `id` is currently tracked (imported and not yet released). */
+    has(id) {
+        return this.served.has(id);
+    }
+    /** the tracked info for `id`, without resetting its release timer, or
+     *  `null` when not currently tracked. */
+    peek(id) {
+        const entry = this.served.get(id);
+        if (!entry)
+            return null;
+        return { blake3: entry.blake3, size: entry.size, mime: entry.mime };
+    }
+    /** import (on first request) and (always) reset the release timer for
+     *  `id`. `resolve` is only called on a cache miss - a repeat request
+     *  never re-reads or re-imports the source bytes. */
+    async serve(id, resolve) {
+        const cached = this.served.get(id);
+        if (cached) {
+            this.scheduleRelease(id, cached);
+            return { blake3: cached.blake3, size: cached.size, mime: cached.mime };
+        }
+        if (!this.node.import_blob) {
+            throw new Error("node does not support import_blob");
+        }
+        const { bytes, size, mime } = await resolve();
+        const blake3 = await this.node.import_blob(bytes);
+        const info = { blake3, size, mime };
+        this.scheduleRelease(id, info);
+        return info;
+    }
+    /** reset the release timer for `id` without re-importing. a no-op when
+     *  `id` isn't currently tracked. */
+    touch(id) {
+        const cached = this.served.get(id);
+        if (cached)
+            this.scheduleRelease(id, cached);
+    }
+    /** stop tracking `id` and release it from the node's store immediately,
+     *  instead of waiting out the release timer. */
+    release(id) {
+        const entry = this.served.get(id);
+        if (!entry)
+            return;
+        clearTimeout(entry.releaseTimer);
+        this.served.delete(id);
+        this.releaseFromNode(entry.blake3);
+    }
+    /** number of ids currently tracked (import-cache size). */
+    size() {
+        return this.served.size;
+    }
+    /** clear every release timer and release every tracked blob from the
+     *  node's store - call on shutdown so nothing stays pinned behind it. */
+    dispose() {
+        for (const [id, entry] of this.served) {
+            clearTimeout(entry.releaseTimer);
+            this.releaseFromNode(entry.blake3);
+            this.served.delete(id);
+        }
+    }
+    scheduleRelease(id, info) {
+        const existing = this.served.get(id);
+        if (existing)
+            clearTimeout(existing.releaseTimer);
+        const releaseAfterMs = this.options.releaseAfterMs ?? DEFAULT_RELEASE_AFTER_MS;
+        const releaseTimer = setTimeout(() => {
+            this.served.delete(id);
+            this.releaseFromNode(info.blake3);
+        }, releaseAfterMs);
+        this.served.set(id, { ...info, releaseTimer });
+    }
+    releaseFromNode(blake3) {
+        try {
+            void this.node.release_blob?.(blake3);
+        }
+        catch (err) {
+            log.debug(TAG, "release_blob failed (non-fatal):", err);
+        }
+    }
+}
+/**
+ * answer a peer's blob request: resolve the blob's bytes locally (via
+ * `resolve`, only called on a cache miss) and stage it into the
+ * transport node's store through `server`, returning the blake3 hash +
+ * size the peer downloads by. returns `null` when `resolve` reports no
+ * such blob.
+ */
+export async function serveBlobRequest(server, id, resolve) {
+    const cached = server.peek(id);
+    if (cached) {
+        server.touch(id);
+        return cached;
+    }
+    const blob = await resolve(id);
+    if (!blob)
+        return null;
+    return server.serve(id, async () => blob);
+}

package/dist/transfer/serve.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serve.test.d.ts.map

package/dist/transfer/serve.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.test.d.ts","sourceRoot":"","sources":["../../src/transfer/serve.test.ts"],"names":[],"mappings":""}

package/dist/transfer/serve.test.js

@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BlobServer, serveBlobRequest } from "./serve.js";
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+function makeNode() {
+    let counter = 0;
+    return {
+        node_id: () => "me",
+        import_blob: vi.fn(async () => `blake3-${++counter}`),
+        release_blob: vi.fn(),
+    };
+}
+describe("BlobServer", () => {
+    it("imports on first serve and reuses the cached blake3 on a repeat request", async () => {
+        const node = makeNode();
+        const server = new BlobServer(node);
+        const getBytes = vi.fn(async () => new Uint8Array([1, 2, 3]));
+        const first = await server.serve("sha-a", async () => ({ bytes: await getBytes(), size: 3 }));
+        const second = await server.serve("sha-a", async () => ({ bytes: await getBytes(), size: 3 }));
+        expect(first.blake3).toBe(second.blake3);
+        expect(node.import_blob).toHaveBeenCalledTimes(1);
+        expect(getBytes).toHaveBeenCalledTimes(1);
+    });
+    it("releases from the node after the release timer elapses", async () => {
+        const node = makeNode();
+        const server = new BlobServer(node, { releaseAfterMs: 1000 });
+        await server.serve("sha-a", async () => ({ bytes: new Uint8Array([1]), size: 1 }));
+        expect(server.has("sha-a")).toBe(true);
+        vi.advanceTimersByTime(999);
+        expect(server.has("sha-a")).toBe(true);
+        expect(node.release_blob).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(1);
+        expect(server.has("sha-a")).toBe(false);
+        expect(node.release_blob).toHaveBeenCalledWith("blake3-1");
+    });
+    it("resets the release timer on every repeat request", async () => {
+        const node = makeNode();
+        const server = new BlobServer(node, { releaseAfterMs: 1000 });
+        await server.serve("sha-a", async () => ({ bytes: new Uint8Array([1]), size: 1 }));
+        vi.advanceTimersByTime(700);
+        await server.serve("sha-a", async () => ({ bytes: new Uint8Array([1]), size: 1 }));
+        vi.advanceTimersByTime(700);
+        // 1400ms elapsed total, but the second serve reset the clock at 700ms,
+        // so only 700ms have passed since the last touch - still tracked.
+        expect(server.has("sha-a")).toBe(true);
+        vi.advanceTimersByTime(300);
+        expect(server.has("sha-a")).toBe(false);
+    });
+    it("releases immediately on request, without waiting for the timer", async () => {
+        const node = makeNode();
+        const server = new BlobServer(node);
+        await server.serve("sha-a", async () => ({ bytes: new Uint8Array([1]), size: 1 }));
+        server.release("sha-a");
+        expect(server.has("sha-a")).toBe(false);
+        expect(node.release_blob).toHaveBeenCalledWith("blake3-1");
+    });
+    it("dispose releases every tracked blob", async () => {
+        const node = makeNode();
+        const server = new BlobServer(node);
+        await server.serve("a", async () => ({ bytes: new Uint8Array([1]), size: 1 }));
+        await server.serve("b", async () => ({ bytes: new Uint8Array([2]), size: 1 }));
+        server.dispose();
+        expect(server.size()).toBe(0);
+        expect(node.release_blob).toHaveBeenCalledTimes(2);
+    });
+    it("rejects when the node has no import_blob", async () => {
+        const server = new BlobServer({ node_id: () => "me" });
+        await expect(server.serve("a", async () => ({ bytes: new Uint8Array([1]), size: 1 }))).rejects.toThrow(/import_blob/);
+    });
+});
+describe("serveBlobRequest", () => {
+    it("resolves bytes on a cache miss and stages them via the server", async () => {
+        const node = makeNode();
+        const server = new BlobServer(node);
+        const resolve = vi.fn(async () => ({ bytes: new Uint8Array([1, 2]), size: 2, mime: "audio/mpeg" }));
+        const result = await serveBlobRequest(server, "sha-a", resolve);
+        expect(result).toEqual({ blake3: "blake3-1", size: 2, mime: "audio/mpeg" });
+        expect(resolve).toHaveBeenCalledWith("sha-a");
+    });
+    it("returns null when resolve reports no such blob, without touching the server", async () => {
+        const node = makeNode();
+        const server = new BlobServer(node);
+        const resolve = vi.fn(async () => null);
+        const result = await serveBlobRequest(server, "missing", resolve);
+        expect(result).toBeNull();
+        expect(node.import_blob).not.toHaveBeenCalled();
+    });
+    it("skips resolve entirely on a cache hit", async () => {
+        const node = makeNode();
+        const server = new BlobServer(node);
+        await server.serve("sha-a", async () => ({ bytes: new Uint8Array([1]), size: 1 }));
+        const resolve = vi.fn(async () => ({ bytes: new Uint8Array([9]), size: 9 }));
+        const result = await serveBlobRequest(server, "sha-a", resolve);
+        expect(resolve).not.toHaveBeenCalled();
+        expect(result?.size).toBe(1);
+    });
+});

package/dist/transfer/snatch.d.ts

@@ -0,0 +1,39 @@
+import type { BlobCapableNode, DiskSnatchResult, SnatchInfo, SnatchOptions, SnatchResult } from "./types.js";
+/**
+ * download a blob's bytes from the first peer (in `peerNodeIds` order)
+ * that can serve it. a peer failure (offline, transport error, hash
+ * mismatch) tries the next peer; a cancelled error (see `cancellation.ts`)
+ * rethrows immediately with no next-peer retry.
+ */
+export declare function snatchBlob(node: BlobCapableNode, peerNodeIds: string[], info: SnatchInfo, options?: SnatchOptions): Promise<SnatchResult>;
+/**
+ * download a blob straight to a user-chosen disk location, writing each
+ * verified chunk to `writable` at its explicit offset as it streams in
+ * (no full payload ever held in memory). falls back to a fully-buffered
+ * `snatchBlob` + single write when the node has no streaming strategy.
+ *
+ * on a mid-stream peer failure, `writable` is truncated back to zero
+ * before the next peer is tried, so a retry never appends onto partial
+ * data. on a cancelled error, `writable` is left exactly as it is (no
+ * truncate, no close) so a resumed snatch can rewrite the same offsets;
+ * the caller owns pausing/closing/discarding it in that case.
+ */
+export declare function snatchBlobToDisk(node: BlobCapableNode, peerNodeIds: string[], info: SnatchInfo, writable: FileSystemWritableFileStream, options?: SnatchOptions): Promise<DiskSnatchResult>;
+/**
+ * pause an in-flight snatch registered under `downloadId`. the transfer
+ * stops at the next chunk boundary and its promise rejects with a
+ * cancelled error (see `isCancelledError`). the partial stays pinned in
+ * the transport's store - resume by calling `snatchBlob`/
+ * `snatchBlobToDisk` again with the same `downloadId`/blake3 (only
+ * missing ranges transfer). returns false when `node` has no
+ * `download_cancel` or the download already settled.
+ */
+export declare function pauseSnatchDownload(node: BlobCapableNode, downloadId: string): Promise<boolean>;
+/**
+ * discard a paused partial: releases the gc pin a paused download left
+ * behind so the transport can reclaim it. call when the user cancels for
+ * good rather than pausing to resume later. best-effort - failures are
+ * logged, not thrown.
+ */
+export declare function discardPausedDownload(node: BlobCapableNode, blake3Hash: string): Promise<void>;
+//# sourceMappingURL=snatch.d.ts.map

package/dist/transfer/snatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snatch.d.ts","sourceRoot":"","sources":["../../src/transfer/snatch.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,UAAU,EACV,aAAa,EACb,YAAY,EACb,MAAM,YAAY,CAAC;AA0KpB;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,eAAe,EACrB,WAAW,EAAE,MAAM,EAAE,EACrB,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAwBvB;AAiDD;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,eAAe,EACrB,WAAW,EAAE,MAAM,EAAE,EACrB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,4BAA4B,EACtC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CAsD3B;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,eAAe,EACrB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,OAAO,CAAC,CAGlB;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,eAAe,EACrB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAOf"}