@kernl-sdk/libsql 0.1.38 → 0.1.39

package/dist/thread/__tests__/sql.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect } from "vitest";
+import { SQL_WHERE, SQL_ORDER, SQL_UPDATE } from "../sql.js";
+describe("LibSQL thread SQL codecs", () => {
+    describe("SQL_WHERE", () => {
+        it("returns empty clause when no filters", () => {
+            const result = SQL_WHERE.encode({ filter: undefined });
+            expect(result.sql).toBe("");
+            expect(result.params).toEqual([]);
+        });
+        it("encodes namespace filter", () => {
+            const result = SQL_WHERE.encode({
+                filter: { namespace: "default" },
+            });
+            expect(result.sql).toBe("namespace = ?");
+            expect(result.params).toEqual(["default"]);
+        });
+        it("encodes agentId filter", () => {
+            const result = SQL_WHERE.encode({
+                filter: { agentId: "agent-1" },
+            });
+            expect(result.sql).toBe("agent_id = ?");
+            expect(result.params).toEqual(["agent-1"]);
+        });
+        it("encodes single state filter", () => {
+            const result = SQL_WHERE.encode({
+                filter: { state: "stopped" },
+            });
+            expect(result.sql).toBe("state = ?");
+            expect(result.params).toEqual(["stopped"]);
+        });
+        it("encodes state array filter with IN clause", () => {
+            const result = SQL_WHERE.encode({
+                filter: { state: ["stopped", "running", "interruptible"] },
+            });
+            expect(result.sql).toBe("state IN (?, ?, ?)");
+            expect(result.params).toEqual(["stopped", "running", "interruptible"]);
+        });
+        it("encodes parentTaskId filter", () => {
+            const result = SQL_WHERE.encode({
+                filter: { parentTaskId: "task-1" },
+            });
+            expect(result.sql).toBe("parent_task_id = ?");
+            expect(result.params).toEqual(["task-1"]);
+        });
+        it("encodes date range filters", () => {
+            const after = new Date("2024-01-01");
+            const before = new Date("2024-12-31");
+            const result = SQL_WHERE.encode({
+                filter: { createdAfter: after, createdBefore: before },
+            });
+            // Uses > and < not >= and <=
+            expect(result.sql).toBe("created_at > ? AND created_at < ?");
+            expect(result.params).toEqual([after.getTime(), before.getTime()]);
+        });
+        it("combines multiple filters with AND", () => {
+            const result = SQL_WHERE.encode({
+                filter: {
+                    namespace: "default",
+                    agentId: "agent-1",
+                    state: "stopped",
+                },
+            });
+            // Order depends on filter processing order, check contains
+            expect(result.sql).toContain("namespace = ?");
+            expect(result.sql).toContain("agent_id = ?");
+            expect(result.sql).toContain("state = ?");
+            expect(result.sql).toContain(" AND ");
+            expect(result.params).toContain("default");
+            expect(result.params).toContain("agent-1");
+            expect(result.params).toContain("stopped");
+        });
+    });
+    describe("SQL_ORDER", () => {
+        it("returns default ordering", () => {
+            const result = SQL_ORDER.encode({ order: undefined });
+            expect(result).toBe("created_at DESC");
+        });
+        it("encodes createdAt asc", () => {
+            const result = SQL_ORDER.encode({ order: { createdAt: "asc" } });
+            expect(result).toBe("created_at ASC");
+        });
+        it("encodes createdAt desc", () => {
+            const result = SQL_ORDER.encode({ order: { createdAt: "desc" } });
+            expect(result).toBe("created_at DESC");
+        });
+        it("encodes updatedAt asc", () => {
+            const result = SQL_ORDER.encode({ order: { updatedAt: "asc" } });
+            expect(result).toBe("updated_at ASC");
+        });
+        it("encodes updatedAt desc", () => {
+            const result = SQL_ORDER.encode({ order: { updatedAt: "desc" } });
+            expect(result).toBe("updated_at DESC");
+        });
+    });
+    describe("SQL_UPDATE", () => {
+        it("encodes tick update", () => {
+            const result = SQL_UPDATE.encode({ patch: { tick: 5 } });
+            expect(result.sql).toContain("tick = ?");
+            expect(result.params).toContain(5);
+        });
+        it("encodes state update", () => {
+            const result = SQL_UPDATE.encode({ patch: { state: "running" } });
+            expect(result.sql).toContain("state = ?");
+            expect(result.params).toContain("running");
+        });
+        it("encodes metadata update with JSON stringify", () => {
+            const metadata = { title: "Test" };
+            const result = SQL_UPDATE.encode({ patch: { metadata } });
+            expect(result.sql).toContain("metadata = ?");
+            expect(result.params).toContain(JSON.stringify(metadata));
+        });
+        it("always includes updated_at", () => {
+            const before = Date.now();
+            const result = SQL_UPDATE.encode({ patch: { tick: 1 } });
+            const after = Date.now();
+            expect(result.sql).toContain("updated_at = ?");
+            const updatedAt = result.params.find((p) => typeof p === "number" && p >= before && p <= after);
+            expect(updatedAt).toBeDefined();
+        });
+        it("combines multiple updates", () => {
+            const result = SQL_UPDATE.encode({
+                patch: { tick: 3, state: "interruptible" },
+            });
+            expect(result.sql).toContain("tick = ?");
+            expect(result.sql).toContain("state = ?");
+            expect(result.sql).toContain("updated_at = ?");
+        });
+    });
+});

package/dist/thread/__tests__/store.test.d.ts

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

package/dist/thread/__tests__/store.test.d.ts.map

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

package/dist/thread/__tests__/store.test.js

@@ -0,0 +1,170 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { message } from "@kernl-sdk/protocol";
+import { create_client, create_storage, create_mock_registries, testid, } from "../../__tests__/helpers.js";
+/** Create a message ThreadEvent */
+function evt(id, tid, seq, timestamp) {
+    return {
+        ...message({ role: "user", text: `msg-${seq}` }),
+        id,
+        tid,
+        seq,
+        timestamp,
+        metadata: {},
+    };
+}
+describe("LibSQLThreadStore", () => {
+    let client;
+    let storage;
+    beforeEach(async () => {
+        client = create_client();
+        storage = create_storage(client);
+        storage.bind(create_mock_registries());
+        await storage.memories.list(); // init
+    });
+    afterEach(() => {
+        client.close();
+    });
+    it("inserts and gets a thread", async () => {
+        const tid = testid("thread");
+        const inserted = await storage.threads.insert({
+            id: tid,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+            context: { userId: "user-1" },
+            metadata: { title: "Test" },
+        });
+        expect(inserted.tid).toBe(tid);
+        expect(inserted.namespace).toBe("default");
+        const found = await storage.threads.get(tid);
+        expect(found).not.toBeNull();
+        expect(found?.tid).toBe(tid);
+        expect(found?.metadata).toEqual({ title: "Test" });
+    });
+    it("returns null for non-existent thread", async () => {
+        const found = await storage.threads.get("nonexistent");
+        expect(found).toBeNull();
+    });
+    it("updates thread fields and metadata", async () => {
+        const tid = testid("thread");
+        await storage.threads.insert({
+            id: tid,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+        });
+        const updated = await storage.threads.update(tid, {
+            tick: 5,
+            state: "running",
+            metadata: { title: "Updated", score: 100 },
+        });
+        expect(updated._tick).toBe(5);
+        expect(updated.state).toBe("running");
+        expect(updated.metadata).toEqual({ title: "Updated", score: 100 });
+        // Verify persisted
+        const found = await storage.threads.get(tid);
+        expect(found?._tick).toBe(5);
+        expect(found?.state).toBe("running");
+    });
+    it("lists threads with filters and pagination", async () => {
+        // Create multiple threads
+        await storage.threads.insert({
+            id: testid("t1"),
+            namespace: "ns1",
+            agentId: "test-agent",
+            model: "test/model",
+            state: "stopped",
+        });
+        await storage.threads.insert({
+            id: testid("t2"),
+            namespace: "ns1",
+            agentId: "test-agent",
+            model: "test/model",
+            state: "running",
+        });
+        await storage.threads.insert({
+            id: testid("t3"),
+            namespace: "ns2",
+            agentId: "test-agent",
+            model: "test/model",
+            state: "stopped",
+        });
+        // Filter by namespace
+        const ns1Threads = await storage.threads.list({
+            filter: { namespace: "ns1" },
+        });
+        expect(ns1Threads.length).toBe(2);
+        // Filter by state
+        const stoppedThreads = await storage.threads.list({
+            filter: { state: "stopped" },
+        });
+        expect(stoppedThreads.length).toBe(2);
+        // Filter by state array
+        const activeThreads = await storage.threads.list({
+            filter: { state: ["stopped", "running"] },
+        });
+        expect(activeThreads.length).toBe(3);
+        // Pagination
+        const page1 = await storage.threads.list({ limit: 2 });
+        expect(page1.length).toBe(2);
+        const page2 = await storage.threads.list({ limit: 2, offset: 2 });
+        expect(page2.length).toBe(1);
+    });
+    it("orders threads by createdAt", async () => {
+        const t1 = testid("t1");
+        const t2 = testid("t2");
+        await storage.threads.insert({
+            id: t1,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+        });
+        // Small delay to ensure different timestamps
+        await new Promise((r) => setTimeout(r, 10));
+        await storage.threads.insert({
+            id: t2,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+        });
+        const asc = await storage.threads.list({
+            order: { createdAt: "asc" },
+        });
+        expect(asc[0].tid).toBe(t1);
+        expect(asc[1].tid).toBe(t2);
+        const desc = await storage.threads.list({
+            order: { createdAt: "desc" },
+        });
+        expect(desc[0].tid).toBe(t2);
+        expect(desc[1].tid).toBe(t1);
+    });
+    it("deletes thread", async () => {
+        const tid = testid("thread");
+        await storage.threads.insert({
+            id: tid,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+        });
+        // Add some events
+        await storage.threads.append([evt("evt-1", tid, 1, new Date())]);
+        await storage.threads.delete(tid);
+        const found = await storage.threads.get(tid);
+        expect(found).toBeNull();
+        // Events should also be deleted (cascade)
+        const history = await storage.threads.history(tid);
+        expect(history.length).toBe(0);
+    });
+    it("returns null when agent/model not in registry", async () => {
+        const tid = testid("thread");
+        // Insert with non-existent agent
+        await client.execute({
+            sql: `INSERT INTO kernl_threads (id, namespace, agent_id, model, context, tick, state, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [tid, "default", "unknown-agent", "unknown/model", "{}", 0, "idle", Date.now(), Date.now()],
+        });
+        // Get should return null (graceful degradation)
+        const found = await storage.threads.get(tid);
+        expect(found).toBeNull();
+    });
+});

package/dist/thread/row.d.ts

@@ -0,0 +1,19 @@
+/**
+ * LibSQL row codecs for thread data.
+ */
+import type { Row } from "@libsql/client";
+import type { Codec } from "@kernl-sdk/shared/lib";
+import type { ThreadRecord, ThreadEventRecord } from "@kernl-sdk/storage";
+/**
+ * Codec for converting LibSQL rows to ThreadRecord.
+ */
+export declare const RowToThreadRecord: Codec<Row, ThreadRecord>;
+/**
+ * Codec for converting LibSQL rows (from JOIN query) to ThreadEventRecord.
+ */
+export declare const RowToEventRecord: Codec<Row, ThreadEventRecord>;
+/**
+ * Codec for converting LibSQL rows to ThreadEventRecord (direct query).
+ */
+export declare const RowToEventRecordDirect: Codec<Row, ThreadEventRecord>;
+//# sourceMappingURL=row.d.ts.map

package/dist/thread/row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row.d.ts","sourceRoot":"","sources":["../../src/thread/row.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAI1E;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,GAAG,EAAE,YAAY,CAoBtD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,GAAG,EAAE,iBAAiB,CAgB1D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,GAAG,EAAE,iBAAiB,CAgBhE,CAAC"}

package/dist/thread/row.js

@@ -0,0 +1,65 @@
+/**
+ * LibSQL row codecs for thread data.
+ */
+import { parsejson } from "../utils.js";
+/**
+ * Codec for converting LibSQL rows to ThreadRecord.
+ */
+export const RowToThreadRecord = {
+    encode(row) {
+        return {
+            id: row.id,
+            namespace: row.namespace,
+            agent_id: row.agent_id,
+            model: row.model,
+            context: parsejson(row.context) ?? {},
+            tick: row.tick,
+            state: row.state,
+            parent_task_id: row.parent_task_id,
+            metadata: parsejson(row.metadata),
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+        };
+    },
+    decode() {
+        throw new Error("RowToThreadRecord.decode not implemented");
+    },
+};
+/**
+ * Codec for converting LibSQL rows (from JOIN query) to ThreadEventRecord.
+ */
+export const RowToEventRecord = {
+    encode(row) {
+        return {
+            id: row.event_id,
+            tid: row.event_tid,
+            seq: row.seq,
+            kind: row.event_kind,
+            timestamp: Number(row.timestamp),
+            data: parsejson(row.data),
+            metadata: parsejson(row.event_metadata),
+        };
+    },
+    decode() {
+        throw new Error("RowToEventRecord.decode not implemented");
+    },
+};
+/**
+ * Codec for converting LibSQL rows to ThreadEventRecord (direct query).
+ */
+export const RowToEventRecordDirect = {
+    encode(row) {
+        return {
+            id: row.id,
+            tid: row.tid,
+            seq: row.seq,
+            kind: row.kind,
+            timestamp: Number(row.timestamp),
+            data: parsejson(row.data),
+            metadata: parsejson(row.metadata),
+        };
+    },
+    decode() {
+        throw new Error("RowToEventRecordDirect.decode not implemented");
+    },
+};

package/dist/thread/sql.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Thread SQL conversion codecs for LibSQL.
+ *
+ * Uses ? placeholders instead of PostgreSQL's $1, $2, etc.
+ */
+import type { ThreadFilter, ThreadUpdate, SortOrder } from "kernl";
+import type { Codec } from "@kernl-sdk/shared/lib";
+import { type SQLClause } from "../sql.js";
+export interface WhereInput {
+    filter?: ThreadFilter;
+}
+/**
+ * Encode ThreadFilter to SQL WHERE clause with ? placeholders.
+ */
+export declare const SQL_WHERE: Codec<WhereInput, SQLClause>;
+export interface OrderInput {
+    order?: {
+        createdAt?: SortOrder;
+        updatedAt?: SortOrder;
+    };
+}
+/**
+ * Encode order options to SQL ORDER BY clause.
+ */
+export declare const SQL_ORDER: Codec<OrderInput, string>;
+export interface UpdateInput {
+    patch: ThreadUpdate;
+}
+/**
+ * Encode ThreadUpdate to SQL SET clause with ? placeholders.
+ */
+export declare const SQL_UPDATE: Codec<UpdateInput, SQLClause>;
+//# sourceMappingURL=sql.d.ts.map

package/dist/thread/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../src/thread/sql.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,QAAQ,CAAC;AAErD,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,UAAU,EAAE,SAAS,CAsDlD,CAAC;AAEF,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE;QACN,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,SAAS,CAAC,EAAE,SAAS,CAAC;KACvB,CAAC;CACH;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,UAAU,EAAE,MAAM,CAqB/C,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,YAAY,CAAC;CACrB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE,SAAS,CAsCpD,CAAC"}

package/dist/thread/sql.js

@@ -0,0 +1,112 @@
+/**
+ * Thread SQL conversion codecs for LibSQL.
+ *
+ * Uses ? placeholders instead of PostgreSQL's $1, $2, etc.
+ */
+import { expandarray } from "../sql.js";
+/**
+ * Encode ThreadFilter to SQL WHERE clause with ? placeholders.
+ */
+export const SQL_WHERE = {
+    encode({ filter }) {
+        if (!filter) {
+            return { sql: "", params: [] };
+        }
+        const conditions = [];
+        const params = [];
+        if (filter.namespace !== undefined) {
+            conditions.push(`namespace = ?`);
+            params.push(filter.namespace);
+        }
+        if (filter.state !== undefined) {
+            if (Array.isArray(filter.state)) {
+                const { placeholders, params: stateParams } = expandarray(filter.state);
+                conditions.push(`state IN (${placeholders})`);
+                params.push(...stateParams);
+            }
+            else {
+                conditions.push(`state = ?`);
+                params.push(filter.state);
+            }
+        }
+        if (filter.agentId !== undefined) {
+            conditions.push(`agent_id = ?`);
+            params.push(filter.agentId);
+        }
+        if (filter.parentTaskId !== undefined) {
+            conditions.push(`parent_task_id = ?`);
+            params.push(filter.parentTaskId);
+        }
+        if (filter.createdAfter !== undefined) {
+            conditions.push(`created_at > ?`);
+            params.push(filter.createdAfter.getTime());
+        }
+        if (filter.createdBefore !== undefined) {
+            conditions.push(`created_at < ?`);
+            params.push(filter.createdBefore.getTime());
+        }
+        return {
+            sql: conditions.length > 0 ? conditions.join(" AND ") : "",
+            params,
+        };
+    },
+    decode() {
+        throw new Error("SQL_WHERE.decode not implemented");
+    },
+};
+/**
+ * Encode order options to SQL ORDER BY clause.
+ */
+export const SQL_ORDER = {
+    encode({ order }) {
+        const clauses = [];
+        if (order?.createdAt) {
+            clauses.push(`created_at ${order.createdAt.toUpperCase()}`);
+        }
+        if (order?.updatedAt) {
+            clauses.push(`updated_at ${order.updatedAt.toUpperCase()}`);
+        }
+        if (clauses.length === 0) {
+            return "created_at DESC";
+        }
+        return clauses.join(", ");
+    },
+    decode() {
+        throw new Error("SQL_ORDER.decode not implemented");
+    },
+};
+/**
+ * Encode ThreadUpdate to SQL SET clause with ? placeholders.
+ */
+export const SQL_UPDATE = {
+    encode({ patch }) {
+        const sets = [];
+        const params = [];
+        if (patch.tick !== undefined) {
+            sets.push(`tick = ?`);
+            params.push(patch.tick);
+        }
+        if (patch.state !== undefined) {
+            sets.push(`state = ?`);
+            params.push(patch.state);
+        }
+        if (patch.context !== undefined) {
+            sets.push(`context = ?`);
+            params.push(JSON.stringify(patch.context.context));
+        }
+        if (patch.metadata !== undefined) {
+            sets.push(`metadata = ?`);
+            params.push(patch.metadata ? JSON.stringify(patch.metadata) : null);
+        }
+        // always update updated_at
+        sets.push(`updated_at = ?`);
+        params.push(Date.now());
+        return {
+            sql: sets.join(", "),
+            params,
+        };
+    },
+    decode() {
+        throw new Error("SQL_UPDATE.decode not implemented");
+    },
+};

package/dist/thread/store.d.ts

@@ -0,0 +1,67 @@
+/**
+ * LibSQL Thread store implementation.
+ */
+import type { Client } from "@libsql/client";
+import { type IAgentRegistry, type IModelRegistry, type ThreadStore, type NewThread, type ThreadUpdate, type ThreadInclude, type ThreadListOptions, type ThreadHistoryOptions } from "kernl";
+import { Thread, type ThreadEvent } from "kernl/internal";
+import { type ThreadRecord } from "@kernl-sdk/storage";
+/**
+ * LibSQL Thread store implementation.
+ *
+ * All async methods call `ensureInit()` before database operations
+ * to ensure schema/tables exist.
+ */
+export declare class LibSQLThreadStore implements ThreadStore {
+    private db;
+    private registries;
+    private ensureInit;
+    constructor(db: Client, ensureInit: () => Promise<void>);
+    /**
+     * Bind runtime registries for hydrating Thread instances.
+     */
+    bind(registries: {
+        agents: IAgentRegistry;
+        models: IModelRegistry;
+    }): void;
+    /**
+     * Get a thread by id.
+     */
+    get(tid: string, include?: ThreadInclude): Promise<Thread | null>;
+    /**
+     * List threads matching the filter.
+     */
+    list(options?: ThreadListOptions): Promise<Thread[]>;
+    /**
+     * Insert a new thread into the store.
+     */
+    insert(thread: NewThread): Promise<Thread>;
+    /**
+     * Update thread runtime state.
+     */
+    update(tid: string, patch: ThreadUpdate): Promise<Thread>;
+    /**
+     * Delete a thread and cascade to thread_events.
+     */
+    delete(tid: string): Promise<void>;
+    /**
+     * Get the event history for a thread.
+     */
+    history(tid: string, opts?: ThreadHistoryOptions): Promise<ThreadEvent[]>;
+    /**
+     * Append events to the thread history.
+     *
+     * Semantics:
+     * - Guaranteed per-thread ordering via monotonically increasing `seq`
+     * - Idempotent on `(tid, event.id)`: duplicate ids MUST NOT create duplicate rows
+     * - Events maintain insertion order
+     */
+    append(events: ThreadEvent[]): Promise<void>;
+    /**
+     * Hydrate a Thread instance from a database record.
+     */
+    hydrate(thread: {
+        record: ThreadRecord;
+        events?: ThreadEvent[];
+    }): Thread;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/thread/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/thread/store.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,gBAAgB,CAAC;AAEtD,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAc5B;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,WAAW;IACnD,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,UAAU,CAA4D;IAC9E,OAAO,CAAC,UAAU,CAAsB;gBAE5B,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC;IAMvD;;OAEG;IACH,IAAI,CAAC,UAAU,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,cAAc,CAAA;KAAE,GAAG,IAAI;IAI1E;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAqFvE;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAsC1D;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;IA4BhD;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAiB/D;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQxC;;OAEG;IACG,OAAO,CACX,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,oBAAoB,GAC1B,OAAO,CAAC,WAAW,EAAE,CAAC;IAoCzB;;;;;;;OAOG;IACG,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAgClD;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,EAAE,CAAA;KAAE,GAAG,MAAM;CAyC1E"}