@kernl-sdk/libsql 0.1.36 → 0.1.39

package/dist/__tests__/row-codecs.test.js

@@ -0,0 +1,175 @@
+import { describe, it, expect } from "vitest";
+import { RowToThreadRecord, RowToEventRecord, RowToEventRecordDirect, } from "../thread/row.js";
+import { RowToMemoryRecord } from "../memory/row.js";
+/** Cast test data to Row type (libsql rows are array-like) */
+const asRow = (data) => data;
+describe("LibSQL row codecs", () => {
+    describe("RowToThreadRecord", () => {
+        it("decodes thread record with JSON fields", () => {
+            const row = asRow({
+                id: "thread-1",
+                namespace: "default",
+                agent_id: "agent-1",
+                model: "openai/gpt-4",
+                context: '{"userId": "user-1"}',
+                tick: 5,
+                state: "stopped",
+                parent_task_id: null,
+                metadata: '{"title": "Test"}',
+                created_at: 1700000000000,
+                updated_at: 1700000001000,
+            });
+            const result = RowToThreadRecord.encode(row);
+            expect(result).toEqual({
+                id: "thread-1",
+                namespace: "default",
+                agent_id: "agent-1",
+                model: "openai/gpt-4",
+                context: { userId: "user-1" },
+                tick: 5,
+                state: "stopped",
+                parent_task_id: null,
+                metadata: { title: "Test" },
+                created_at: 1700000000000,
+                updated_at: 1700000001000,
+            });
+        });
+        it("handles null metadata", () => {
+            const row = asRow({
+                id: "thread-1",
+                namespace: "default",
+                agent_id: "agent-1",
+                model: "openai/gpt-4",
+                context: "{}",
+                tick: 0,
+                state: "stopped",
+                parent_task_id: null,
+                metadata: null,
+                created_at: 1700000000000,
+                updated_at: 1700000000000,
+            });
+            const result = RowToThreadRecord.encode(row);
+            expect(result.metadata).toBeNull();
+            expect(result.context).toEqual({});
+        });
+    });
+    describe("RowToEventRecord", () => {
+        it("decodes event record from join query", () => {
+            const row = asRow({
+                // thread fields (ignored by this codec)
+                id: "thread-1",
+                namespace: "default",
+                // event fields (with event_ prefix)
+                event_id: "evt-1",
+                event_tid: "thread-1",
+                seq: 1,
+                event_kind: "message",
+                timestamp: "1700000000000", // BigInt comes as string
+                data: '{"role": "user", "content": "Hello"}',
+                event_metadata: '{"source": "api"}',
+            });
+            const result = RowToEventRecord.encode(row);
+            expect(result).toEqual({
+                id: "evt-1",
+                tid: "thread-1",
+                seq: 1,
+                kind: "message",
+                timestamp: 1700000000000,
+                data: { role: "user", content: "Hello" },
+                metadata: { source: "api" },
+            });
+        });
+        it("handles null data and metadata", () => {
+            const row = asRow({
+                event_id: "evt-1",
+                event_tid: "thread-1",
+                seq: 1,
+                event_kind: "tick",
+                timestamp: 1700000000000,
+                data: null,
+                event_metadata: null,
+            });
+            const result = RowToEventRecord.encode(row);
+            expect(result.data).toBeNull();
+            expect(result.metadata).toBeNull();
+        });
+    });
+    describe("RowToEventRecordDirect", () => {
+        it("decodes event record from direct query", () => {
+            const row = asRow({
+                id: "evt-1",
+                tid: "thread-1",
+                seq: 1,
+                kind: "message",
+                timestamp: "1700000000000",
+                data: '{"role": "assistant"}',
+                metadata: null,
+            });
+            const result = RowToEventRecordDirect.encode(row);
+            expect(result).toEqual({
+                id: "evt-1",
+                tid: "thread-1",
+                seq: 1,
+                kind: "message",
+                timestamp: 1700000000000,
+                data: { role: "assistant" },
+                metadata: null,
+            });
+        });
+    });
+    describe("RowToMemoryRecord", () => {
+        it("decodes memory record with JSON and boolean fields", () => {
+            const row = asRow({
+                id: "mem-1",
+                namespace: "default",
+                entity_id: "user-1",
+                agent_id: "agent-1",
+                kind: "semantic",
+                collection: "facts",
+                content: '{"text": "User likes coffee"}',
+                wmem: 1, // SQLite boolean
+                smem_expires_at: 1700100000000,
+                timestamp: 1700000000000,
+                created_at: 1700000000000,
+                updated_at: 1700000001000,
+                metadata: '{"confidence": 0.9}',
+            });
+            const result = RowToMemoryRecord.encode(row);
+            expect(result).toEqual({
+                id: "mem-1",
+                namespace: "default",
+                entity_id: "user-1",
+                agent_id: "agent-1",
+                kind: "semantic",
+                collection: "facts",
+                content: { text: "User likes coffee" },
+                wmem: true,
+                smem_expires_at: 1700100000000,
+                timestamp: 1700000000000,
+                created_at: 1700000000000,
+                updated_at: 1700000001000,
+                metadata: { confidence: 0.9 },
+            });
+        });
+        it("converts SQLite 0 to false for wmem", () => {
+            const row = asRow({
+                id: "mem-1",
+                namespace: null,
+                entity_id: null,
+                agent_id: null,
+                kind: "episodic",
+                collection: null,
+                content: "{}",
+                wmem: 0,
+                smem_expires_at: null,
+                timestamp: 1700000000000,
+                created_at: 1700000000000,
+                updated_at: 1700000000000,
+                metadata: null,
+            });
+            const result = RowToMemoryRecord.encode(row);
+            expect(result.wmem).toBe(false);
+            expect(result.metadata).toBeNull();
+        });
+    });
+});

package/dist/__tests__/sql-utils.test.d.ts

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

package/dist/__tests__/sql-utils.test.d.ts.map

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

package/dist/__tests__/sql-utils.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { expandarray, SQL_IDENTIFIER_REGEX } from "../sql.js";
+describe("libsql sql utils", () => {
+    describe("expandarray", () => {
+        it("returns placeholders and params for array", () => {
+            const result = expandarray(["a", "b", "c"]);
+            expect(result.placeholders).toBe("?, ?, ?");
+            expect(result.params).toEqual(["a", "b", "c"]);
+        });
+        it("handles single element", () => {
+            const result = expandarray(["only"]);
+            expect(result.placeholders).toBe("?");
+            expect(result.params).toEqual(["only"]);
+        });
+        it("handles empty array", () => {
+            const result = expandarray([]);
+            expect(result.placeholders).toBe("");
+            expect(result.params).toEqual([]);
+        });
+        it("preserves original values", () => {
+            const result = expandarray([1, "two", null, true]);
+            expect(result.placeholders).toBe("?, ?, ?, ?");
+            expect(result.params).toEqual([1, "two", null, true]);
+        });
+    });
+    describe("SQL_IDENTIFIER_REGEX", () => {
+        it("accepts valid identifiers", () => {
+            expect(SQL_IDENTIFIER_REGEX.test("users")).toBe(true);
+            expect(SQL_IDENTIFIER_REGEX.test("thread_events")).toBe(true);
+            expect(SQL_IDENTIFIER_REGEX.test("kernl_threads")).toBe(true);
+            expect(SQL_IDENTIFIER_REGEX.test("_private")).toBe(true);
+            expect(SQL_IDENTIFIER_REGEX.test("Table1")).toBe(true);
+            expect(SQL_IDENTIFIER_REGEX.test("a")).toBe(true);
+        });
+        it("rejects invalid identifiers", () => {
+            expect(SQL_IDENTIFIER_REGEX.test("")).toBe(false);
+            expect(SQL_IDENTIFIER_REGEX.test("1starts_with_number")).toBe(false);
+            expect(SQL_IDENTIFIER_REGEX.test("has space")).toBe(false);
+            expect(SQL_IDENTIFIER_REGEX.test("has-dash")).toBe(false);
+            expect(SQL_IDENTIFIER_REGEX.test("has.dot")).toBe(false);
+            expect(SQL_IDENTIFIER_REGEX.test("DROP TABLE")).toBe(false);
+            expect(SQL_IDENTIFIER_REGEX.test("users; --")).toBe(false);
+        });
+    });
+});

package/dist/__tests__/storage.init.test.d.ts

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

package/dist/__tests__/storage.init.test.d.ts.map

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

package/dist/__tests__/storage.init.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { create_client, create_storage, MIGRATIONS_TABLE, THREADS_TABLE, MEMORIES_TABLE, } from "./helpers.js";
+describe("LibSQLStorage init", () => {
+    let client;
+    beforeEach(() => {
+        client = create_client();
+    });
+    afterEach(() => {
+        client.close();
+    });
+    it("auto-initializes on first store operation", async () => {
+        const storage = create_storage(client);
+        // Tables shouldn't exist yet
+        const before = await client.execute({
+            sql: "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+            args: [THREADS_TABLE],
+        });
+        expect(before.rows.length).toBe(0);
+        // Trigger init via store operation
+        await storage.memories.list();
+        // Now tables should exist
+        const after = await client.execute({
+            sql: "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+            args: [THREADS_TABLE],
+        });
+        expect(after.rows.length).toBe(1);
+    });
+    it("creates migrations table and applies migrations", async () => {
+        const storage = create_storage(client);
+        // Trigger init
+        await storage.memories.list();
+        // Check migrations table exists and has records
+        const result = await client.execute(`SELECT * FROM "${MIGRATIONS_TABLE}"`);
+        expect(result.rows.length).toBeGreaterThan(0);
+        // Verify migration IDs
+        const migrationIds = result.rows.map((r) => r.id);
+        expect(migrationIds).toContain("001_threads");
+    });
+    it("is idempotent across multiple init calls", async () => {
+        const storage = create_storage(client);
+        // Trigger init multiple times
+        await storage.memories.list();
+        await storage.threads.list();
+        await storage.memories.list();
+        // Should still work and have same migrations
+        const result = await client.execute(`SELECT * FROM "${MIGRATIONS_TABLE}"`);
+        const migrationCount = result.rows.length;
+        // Trigger again
+        await storage.memories.list();
+        const result2 = await client.execute(`SELECT * FROM "${MIGRATIONS_TABLE}"`);
+        expect(result2.rows.length).toBe(migrationCount);
+    });
+    it("creates all required tables", async () => {
+        const storage = create_storage(client);
+        await storage.memories.list();
+        const tables = await client.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name");
+        const tableNames = tables.rows.map((r) => r.name);
+        expect(tableNames).toContain(MIGRATIONS_TABLE);
+        expect(tableNames).toContain(THREADS_TABLE);
+        expect(tableNames).toContain(MEMORIES_TABLE);
+        expect(tableNames).toContain("kernl_thread_events");
+    });
+});

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

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

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

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

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

@@ -0,0 +1,172 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { message, IN_PROGRESS, COMPLETED } from "@kernl-sdk/protocol";
+import { create_client, create_storage, create_mock_registries, THREAD_EVENTS_TABLE, testid, } from "./helpers.js";
+/** Create a ThreadEvent from a message */
+function evt(id, tid, seq, timestamp, role, text) {
+    return {
+        ...message({ role, text }),
+        id,
+        tid,
+        seq,
+        timestamp,
+        metadata: {},
+    };
+}
+/** Create a tool.call ThreadEvent */
+function toolCallEvt(id, tid, seq, timestamp, callId, toolId) {
+    return {
+        kind: "tool.call",
+        id,
+        tid,
+        seq,
+        timestamp,
+        callId,
+        toolId,
+        state: IN_PROGRESS,
+        arguments: "{}",
+        metadata: {},
+    };
+}
+/** Create a tool.result ThreadEvent */
+function toolResultEvt(id, tid, seq, timestamp, callId, toolId) {
+    return {
+        kind: "tool.result",
+        id,
+        tid,
+        seq,
+        timestamp,
+        callId,
+        toolId,
+        state: COMPLETED,
+        result: null,
+        error: null,
+        metadata: {},
+    };
+}
+describe("LibSQL thread lifecycle", () => {
+    let client;
+    let storage;
+    beforeEach(async () => {
+        client = create_client();
+        storage = create_storage(client);
+        storage.bind(create_mock_registries());
+        // Initialize tables
+        await storage.memories.list();
+    });
+    afterEach(() => {
+        client.close();
+    });
+    it("persists thread and events for simple run", async () => {
+        const tid = testid("thread");
+        // Insert thread
+        const thread = await storage.threads.insert({
+            id: tid,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+            context: { userId: "user-1" },
+            metadata: { title: "Test Thread" },
+        });
+        expect(thread.tid).toBe(tid);
+        // Append events
+        const now = Date.now();
+        await storage.threads.append([
+            evt("evt-1", tid, 1, new Date(now), "user", "Hello"),
+            evt("evt-2", tid, 2, new Date(now + 1), "assistant", "Hi!"),
+        ]);
+        // Verify in database
+        const events = await client.execute({
+            sql: `SELECT * FROM "${THREAD_EVENTS_TABLE}" WHERE tid = ? ORDER BY seq`,
+            args: [tid],
+        });
+        expect(events.rows.length).toBe(2);
+        expect(events.rows[0].kind).toBe("message");
+        expect(events.rows[1].seq).toBe(2);
+    });
+    it("persists tool call events across ticks", async () => {
+        const tid = testid("thread");
+        await storage.threads.insert({
+            id: tid,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+        });
+        const now = Date.now();
+        // Tick 1: user message + assistant with tool call
+        await storage.threads.append([
+            evt("evt-1", tid, 1, new Date(now), "user", "search for something"),
+            toolCallEvt("evt-2", tid, 2, new Date(now + 1), "call-1", "search"),
+        ]);
+        await storage.threads.update(tid, { tick: 1, state: "interruptible" });
+        // Tick 2: tool result + final response
+        await storage.threads.append([
+            toolResultEvt("evt-3", tid, 3, new Date(now + 2), "call-1", "search"),
+            evt("evt-4", tid, 4, new Date(now + 3), "assistant", "I found it"),
+        ]);
+        await storage.threads.update(tid, { tick: 2, state: "stopped" });
+        // Verify all events persisted
+        const history = await storage.threads.history(tid);
+        expect(history.length).toBe(4);
+        expect(history.map((e) => e.kind)).toEqual([
+            "message",
+            "tool.call",
+            "tool.result",
+            "message",
+        ]);
+    });
+    it("resumes a thread and appends new events", async () => {
+        const tid = testid("thread");
+        // Create thread with initial events
+        await storage.threads.insert({
+            id: tid,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+        });
+        const now = Date.now();
+        await storage.threads.append([
+            evt("evt-1", tid, 1, new Date(now), "user", "hello"),
+            evt("evt-2", tid, 2, new Date(now + 1), "assistant", "hi"),
+        ]);
+        await storage.threads.update(tid, { tick: 1, state: "stopped" });
+        // Resume: get thread with history
+        const resumed = await storage.threads.get(tid, { history: true });
+        expect(resumed).not.toBeNull();
+        // Append more events
+        await storage.threads.append([
+            evt("evt-3", tid, 3, new Date(now + 100), "user", "continue"),
+            evt("evt-4", tid, 4, new Date(now + 101), "assistant", "ok"),
+        ]);
+        await storage.threads.update(tid, { tick: 2 });
+        // Verify total history
+        const history = await storage.threads.history(tid);
+        expect(history.length).toBe(4);
+    });
+    it("keeps event seq monotonic across runs", async () => {
+        const tid = testid("thread");
+        await storage.threads.insert({
+            id: tid,
+            namespace: "default",
+            agentId: "test-agent",
+            model: "test/model",
+        });
+        const now = Date.now();
+        // Run 1
+        await storage.threads.append([
+            evt("r1-1", tid, 1, new Date(now), "user", "m1"),
+            evt("r1-2", tid, 2, new Date(now + 1), "assistant", "m2"),
+        ]);
+        // Run 2 (continuing sequence)
+        await storage.threads.append([
+            evt("r2-1", tid, 3, new Date(now + 100), "user", "m3"),
+            evt("r2-2", tid, 4, new Date(now + 101), "assistant", "m4"),
+        ]);
+        // Run 3
+        await storage.threads.append([
+            evt("r3-1", tid, 5, new Date(now + 200), "user", "m5"),
+        ]);
+        const history = await storage.threads.history(tid);
+        const seqs = history.map((e) => e.seq);
+        expect(seqs).toEqual([1, 2, 3, 4, 5]);
+    });
+});

package/dist/__tests__/transaction.test.d.ts

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

package/dist/__tests__/transaction.test.d.ts.map

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

package/dist/__tests__/transaction.test.js

@@ -0,0 +1,16 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { UnimplementedError } from "@kernl-sdk/shared/lib";
+import { create_client, create_storage } from "./helpers.js";
+describe("LibSQLStorage transaction", () => {
+    let client;
+    beforeEach(() => {
+        client = create_client();
+    });
+    afterEach(() => {
+        client.close();
+    });
+    it("throws UnimplementedError until implemented", async () => {
+        const storage = create_storage(client);
+        await expect(storage.transaction(async () => { })).rejects.toThrow(UnimplementedError);
+    });
+});

package/dist/__tests__/utils.test.d.ts

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

package/dist/__tests__/utils.test.d.ts.map

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

package/dist/__tests__/utils.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import { parsejson } from "../utils.js";
+describe("libsql utils", () => {
+    describe("parsejson", () => {
+        it("parses JSON strings", () => {
+            expect(parsejson('{"foo": "bar"}')).toEqual({ foo: "bar" });
+            expect(parsejson("[1, 2, 3]")).toEqual([1, 2, 3]);
+            expect(parsejson('"hello"')).toEqual("hello");
+            expect(parsejson("42")).toEqual(42);
+            expect(parsejson("true")).toEqual(true);
+            expect(parsejson("null")).toEqual(null);
+        });
+        it("returns null on invalid JSON", () => {
+            expect(parsejson("{invalid}")).toBeNull();
+            expect(parsejson("not json")).toBeNull();
+            expect(parsejson("{foo: bar}")).toBeNull();
+        });
+        it("returns null for null/undefined input", () => {
+            expect(parsejson(null)).toBeNull();
+            expect(parsejson(undefined)).toBeNull();
+        });
+        it("passes through non-strings as-is", () => {
+            const obj = { foo: "bar" };
+            expect(parsejson(obj)).toBe(obj);
+            const arr = [1, 2, 3];
+            expect(parsejson(arr)).toBe(arr);
+            expect(parsejson(42)).toBe(42);
+            expect(parsejson(true)).toBe(true);
+        });
+    });
+});

package/dist/client.d.ts

@@ -0,0 +1,46 @@
+/**
+ * LibSQL client configuration and factory.
+ */
+import type { KernlStorage } from "kernl";
+import { type Client } from "@libsql/client";
+/**
+ * LibSQL connection configuration.
+ *
+ * Supports:
+ * - Local SQLite files: `file:./data.db` or `file:/path/to/data.db`
+ * - In-memory: `:memory:`
+ * - Remote Turso: `libsql://your-db.turso.io`
+ */
+export type LibSQLConnectionConfig = {
+    client: Client;
+} | {
+    url: string;
+    authToken?: string;
+};
+/**
+ * LibSQL storage configuration.
+ */
+export type LibSQLConfig = LibSQLConnectionConfig;
+/**
+ * Create a LibSQL storage adapter for Kernl.
+ *
+ * @example Local file
+ * ```ts
+ * const storage = libsql({ url: 'file:./kernl.db' });
+ * ```
+ *
+ * @example In-memory (for testing)
+ * ```ts
+ * const storage = libsql({ url: ':memory:' });
+ * ```
+ *
+ * @example Remote Turso
+ * ```ts
+ * const storage = libsql({
+ *   url: 'libsql://your-db.turso.io',
+ *   authToken: process.env.TURSO_AUTH_TOKEN
+ * });
+ * ```
+ */
+export declare function libsql(config: LibSQLConfig): KernlStorage;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,EAAgB,KAAK,MAAM,EAAe,MAAM,gBAAgB,CAAC;AAIxE;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAC9B;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAExC;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAIzD"}

package/dist/client.js

@@ -0,0 +1,46 @@
+/**
+ * LibSQL client configuration and factory.
+ */
+import { createClient } from "@libsql/client";
+import { LibSQLStorage } from "./storage.js";
+/**
+ * Create a LibSQL storage adapter for Kernl.
+ *
+ * @example Local file
+ * ```ts
+ * const storage = libsql({ url: 'file:./kernl.db' });
+ * ```
+ *
+ * @example In-memory (for testing)
+ * ```ts
+ * const storage = libsql({ url: ':memory:' });
+ * ```
+ *
+ * @example Remote Turso
+ * ```ts
+ * const storage = libsql({
+ *   url: 'libsql://your-db.turso.io',
+ *   authToken: process.env.TURSO_AUTH_TOKEN
+ * });
+ * ```
+ */
+export function libsql(config) {
+    const client = createLibSQLClient(config);
+    const url = "url" in config ? config.url : undefined;
+    return new LibSQLStorage({ client, url });
+}
+/**
+ * Create a LibSQL client from configuration.
+ */
+function createLibSQLClient(config) {
+    if ("client" in config) {
+        return config.client;
+    }
+    const clientConfig = {
+        url: config.url,
+    };
+    if (config.authToken) {
+        clientConfig.authToken = config.authToken;
+    }
+    return createClient(clientConfig);
+}

package/dist/index.d.ts

@@ -1,4 +1,9 @@
 /**
  * @kernl/libsql - LibSQL storage adapter for Kernl
  */
+export { LibSQLStorage, type LibSQLStorageConfig } from "./storage.js";
+export { LibSQLThreadStore } from "./thread/store.js";
+export { LibSQLMemoryStore } from "./memory/store.js";
+export { libsql, type LibSQLConfig, type LibSQLConnectionConfig, } from "./client.js";
+export { MIGRATIONS, REQUIRED_SCHEMA_VERSION } from "./migrations.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EACL,MAAM,EACN,KAAK,YAAY,EACjB,KAAK,sBAAsB,GAC5B,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,4 +1,8 @@
-"use strict";
 /**
  * @kernl/libsql - LibSQL storage adapter for Kernl
  */
+export { LibSQLStorage } from "./storage.js";
+export { LibSQLThreadStore } from "./thread/store.js";
+export { LibSQLMemoryStore } from "./memory/store.js";
+export { libsql, } from "./client.js";
+export { MIGRATIONS, REQUIRED_SCHEMA_VERSION } from "./migrations.js";

package/dist/memory/__tests__/create-get.test.d.ts

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