@kernl-sdk/libsql 0.1.38 → 0.1.39

package/.turbo/turbo-build.log

@@ -1,4 +1,5 @@
-
-> @kernl-sdk/libsql@0.1.38 build /home/runner/work/kernl/kernl/packages/storage/libsql
-> tsc && tsc-alias --resolve-full-paths
-
+
+
+> @kernl-sdk/libsql@0.1.39 build /Users/andjones/Documents/projects/kernl/packages/storage/libsql
+> tsc && tsc-alias --resolve-full-paths
+

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @kernl/libsql
 
+## 0.1.39
+
+### Patch Changes
+
+- Updated dependencies [772acad]
+  - kernl@0.12.7
+  - @kernl-sdk/storage@0.2.7
+
 ## 0.1.38
 
 ### Patch Changes

package/README.md

@@ -0,0 +1,225 @@
+# @kernl-sdk/libsql
+
+LibSQL/SQLite storage adapter for Kernl. Supports local SQLite files, in-memory databases, and remote [Turso](https://turso.tech) databases.
+
+## Installation
+
+```bash
+pnpm add @kernl-sdk/libsql
+```
+
+## Usage
+
+### Local SQLite File
+
+```typescript
+import { Kernl } from "kernl";
+import { libsql } from "@kernl-sdk/libsql";
+
+const kernl = new Kernl({
+  storage: libsql({ url: "file:./kernl.db" }),
+});
+```
+
+### In-Memory (Testing)
+
+```typescript
+import { libsql } from "@kernl-sdk/libsql";
+
+const storage = libsql({ url: ":memory:" });
+```
+
+### Remote Turso
+
+```typescript
+import { libsql } from "@kernl-sdk/libsql";
+
+const storage = libsql({
+  url: "libsql://your-database.turso.io",
+  authToken: process.env.TURSO_AUTH_TOKEN,
+});
+```
+
+### Using an Existing Client
+
+```typescript
+import { createClient } from "@libsql/client";
+import { libsql } from "@kernl-sdk/libsql";
+
+const client = createClient({ url: "file:./kernl.db" });
+const storage = libsql({ client });
+```
+
+## Direct Usage
+
+You can use the thread and memory stores directly for lower-level operations.
+
+### Threads
+
+```typescript
+import { libsql } from "@kernl-sdk/libsql";
+
+const storage = libsql({ url: "file:./kernl.db" });
+
+// Create a thread
+const thread = await storage.threads.insert({
+  id: "thread-123",
+  namespace: "default",
+  agentId: "my-agent",
+  model: "openai/gpt-4",
+  context: { userId: "user-456" },
+  metadata: { title: "Support Chat" },
+});
+
+// Get a thread by ID
+const found = await storage.threads.get("thread-123");
+
+// Get thread with event history
+const withHistory = await storage.threads.get("thread-123", {
+  history: true,
+});
+
+// Get thread with filtered history
+const withFilteredHistory = await storage.threads.get("thread-123", {
+  history: { after: 5, kinds: ["message"], limit: 10, order: "desc" },
+});
+
+// List threads with filters
+const threads = await storage.threads.list({
+  filter: { namespace: "default", agentId: "my-agent", state: "idle" },
+  order: { createdAt: "desc" },
+  limit: 20,
+});
+
+// Update a thread
+const updated = await storage.threads.update("thread-123", {
+  state: "running",
+  metadata: { title: "Updated Title" },
+});
+
+// Get event history separately
+const events = await storage.threads.history("thread-123", {
+  after: 0,
+  kinds: ["message", "tool_call"],
+  limit: 50,
+  order: "asc",
+});
+
+// Delete a thread (cascades to events)
+await storage.threads.delete("thread-123");
+```
+
+### Memories
+
+```typescript
+import { libsql } from "@kernl-sdk/libsql";
+
+const storage = libsql({ url: "file:./kernl.db" });
+
+// Create a memory
+const memory = await storage.memories.create({
+  id: "mem-789",
+  scope: { namespace: "default", entityId: "user-456", agentId: "my-agent" },
+  kind: "semantic",
+  collection: "facts",
+  content: { text: "User prefers dark mode" },
+  wmem: true,
+  metadata: { source: "preference" },
+});
+
+// Get a memory by ID
+const found = await storage.memories.get("mem-789");
+
+// List memories with filters
+const memories = await storage.memories.list({
+  filter: {
+    scope: { namespace: "default", entityId: "user-456" },
+    collections: ["facts", "preferences"],
+    wmem: true,
+  },
+  order: "desc",
+  limit: 100,
+});
+
+// Update a memory
+const updated = await storage.memories.update("mem-789", {
+  content: { text: "User prefers light mode" },
+  metadata: { source: "updated-preference" },
+});
+
+// Delete a memory
+await storage.memories.delete("mem-789");
+
+// Delete multiple memories
+await storage.memories.mdelete(["mem-789", "mem-790", "mem-791"]);
+```
+
+## API
+
+### `libsql(config)`
+
+Creates a LibSQL storage adapter.
+
+**Config options:**
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `url` | `string` | Database URL. Supports `file:`, `:memory:`, or `libsql://` |
+| `authToken` | `string` | Auth token for Turso (optional for local) |
+| `client` | `Client` | Existing `@libsql/client` instance |
+
+## Store Methods
+
+### ThreadStore
+
+| Method | Description |
+|--------|-------------|
+| `get(tid, include?)` | Get a thread by ID, optionally with event history |
+| `list(options?)` | List threads with filtering, ordering, and pagination |
+| `insert(thread)` | Create a new thread |
+| `update(tid, patch)` | Update thread state, context, or metadata |
+| `delete(tid)` | Delete a thread and its events |
+| `history(tid, options?)` | Get event history for a thread |
+| `append(events)` | Append events to thread history (idempotent) |
+
+### MemoryStore
+
+| Method | Description |
+|--------|-------------|
+| `get(id)` | Get a memory by ID |
+| `list(options?)` | List memories with filtering and pagination |
+| `create(memory)` | Create a new memory record |
+| `update(id, patch)` | Update a memory record |
+| `delete(id)` | Delete a memory by ID |
+| `mdelete(ids)` | Delete multiple memories by ID |
+
+## Differences from PostgreSQL
+
+This adapter provides feature parity with `@kernl-sdk/pg` with the following SQLite-specific adaptations:
+
+- **JSON storage**: Uses `TEXT` columns instead of `JSONB`
+- **Booleans**: Stored as `INTEGER` (0/1)
+- **Arrays**: `IN (?, ?, ?)` instead of PostgreSQL's `= ANY($1)`
+- **Schema**: Table names prefixed with `kernl_` (SQLite has no schema support)
+
+## SQLite Configuration
+
+For local file databases (`file:` URLs), the adapter automatically sets:
+
+- `PRAGMA journal_mode = WAL` - Write-Ahead Logging for better concurrent read/write performance
+- `PRAGMA busy_timeout = 5000` - Wait up to 5 seconds when the database is locked
+
+These are not set for remote Turso databases, which manage these settings automatically.
+
+## Tables
+
+The adapter creates the following tables:
+
+- `kernl_migrations` - Migration tracking
+- `kernl_threads` - Thread records
+- `kernl_thread_events` - Thread event history
+- `kernl_memories` - Memory records
+
+## License
+
+MIT

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

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

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

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

package/dist/__tests__/constraints.test.js

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { create_client, create_storage, enable_foreign_keys, THREADS_TABLE, THREAD_EVENTS_TABLE, testid, } from "./helpers.js";
+describe("LibSQL constraints", () => {
+    let client;
+    let storage;
+    beforeEach(async () => {
+        client = create_client();
+        await enable_foreign_keys(client);
+        storage = create_storage(client);
+        // Initialize tables
+        await storage.memories.list();
+    });
+    afterEach(() => {
+        client.close();
+    });
+    it("enforces thread_events foreign key to threads", async () => {
+        // Try to insert event for non-existent thread
+        const result = client.execute({
+            sql: `INSERT INTO "${THREAD_EVENTS_TABLE}" (id, tid, seq, kind, timestamp) VALUES (?, ?, ?, ?, ?)`,
+            args: ["evt-1", "nonexistent-thread", 1, "message", Date.now()],
+        });
+        await expect(result).rejects.toThrow(/FOREIGN KEY/i);
+    });
+    it("cascades thread deletion to events", async () => {
+        const tid = testid("thread");
+        // Insert a thread directly
+        await client.execute({
+            sql: `INSERT INTO "${THREADS_TABLE}" (id, namespace, agent_id, model, context, tick, state, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+                tid,
+                "default",
+                "agent-1",
+                "test/model",
+                "{}",
+                0,
+                "idle",
+                Date.now(),
+                Date.now(),
+            ],
+        });
+        // Insert events for the thread
+        await client.execute({
+            sql: `INSERT INTO "${THREAD_EVENTS_TABLE}" (id, tid, seq, kind, timestamp) VALUES (?, ?, ?, ?, ?)`,
+            args: ["evt-1", tid, 1, "message", Date.now()],
+        });
+        await client.execute({
+            sql: `INSERT INTO "${THREAD_EVENTS_TABLE}" (id, tid, seq, kind, timestamp) VALUES (?, ?, ?, ?, ?)`,
+            args: ["evt-2", tid, 2, "message", Date.now()],
+        });
+        // Verify events exist
+        const beforeDelete = await client.execute({
+            sql: `SELECT COUNT(*) as count FROM "${THREAD_EVENTS_TABLE}" WHERE tid = ?`,
+            args: [tid],
+        });
+        expect(beforeDelete.rows[0].count).toBe(2);
+        // Delete thread
+        await client.execute({
+            sql: `DELETE FROM "${THREADS_TABLE}" WHERE id = ?`,
+            args: [tid],
+        });
+        // Events should be cascaded
+        const afterDelete = await client.execute({
+            sql: `SELECT COUNT(*) as count FROM "${THREAD_EVENTS_TABLE}" WHERE tid = ?`,
+            args: [tid],
+        });
+        expect(afterDelete.rows[0].count).toBe(0);
+    });
+    it("enforces unique (tid, id) on thread_events", async () => {
+        const tid = testid("thread");
+        // Insert a thread
+        await client.execute({
+            sql: `INSERT INTO "${THREADS_TABLE}" (id, namespace, agent_id, model, context, tick, state, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+                tid,
+                "default",
+                "agent-1",
+                "test/model",
+                "{}",
+                0,
+                "idle",
+                Date.now(),
+                Date.now(),
+            ],
+        });
+        // Insert an event
+        await client.execute({
+            sql: `INSERT INTO "${THREAD_EVENTS_TABLE}" (id, tid, seq, kind, timestamp) VALUES (?, ?, ?, ?, ?)`,
+            args: ["evt-1", tid, 1, "message", Date.now()],
+        });
+        // Try to insert duplicate (tid, id) - should fail
+        const duplicate = client.execute({
+            sql: `INSERT INTO "${THREAD_EVENTS_TABLE}" (id, tid, seq, kind, timestamp) VALUES (?, ?, ?, ?, ?)`,
+            args: ["evt-1", tid, 2, "message", Date.now()],
+        });
+        await expect(duplicate).rejects.toThrow(/UNIQUE/i);
+    });
+});

package/dist/__tests__/helpers.d.ts

@@ -0,0 +1,36 @@
+import { type Client } from "@libsql/client";
+import type { IAgentRegistry, IModelRegistry } from "kernl";
+import { LibSQLStorage } from "../storage.js";
+/**
+ * Generate a unique database URL for each test.
+ * Uses temp file instead of :memory: due to libsql bug with in-memory transactions.
+ */
+export declare function test_db_url(): string;
+export declare const THREADS_TABLE = "kernl_threads";
+export declare const THREAD_EVENTS_TABLE = "kernl_thread_events";
+export declare const MEMORIES_TABLE = "kernl_memories";
+export declare const MIGRATIONS_TABLE = "kernl_migrations";
+/**
+ * Create a test database setup with client and storage sharing the same URL.
+ */
+export declare function create_test_db(): {
+    client: Client;
+    storage: LibSQLStorage;
+    url: string;
+};
+export declare function create_client(url?: string): Client;
+export declare function enable_foreign_keys(client: Client): Promise<void>;
+export declare function create_storage(client: Client, url?: string): LibSQLStorage;
+export declare function reset_tables(client: Client): Promise<void>;
+/**
+ * Create mock registries for thread hydration tests.
+ */
+export declare function create_mock_registries(): {
+    agents: IAgentRegistry;
+    models: IModelRegistry;
+};
+/**
+ * Generate a unique ID for tests.
+ */
+export declare function testid(prefix?: string): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/__tests__/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/__tests__/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5D,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAK3C;;;GAGG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,eAAO,MAAM,aAAa,kBAAiC,CAAC;AAC5D,eAAO,MAAM,mBAAmB,wBAAuC,CAAC;AACxE,eAAO,MAAM,cAAc,mBAAkC,CAAC;AAC9D,eAAO,MAAM,gBAAgB,qBAAoC,CAAC;AAElE;;GAEG;AACH,wBAAgB,cAAc,IAAI;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAKxF;AAED,wBAAgB,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAGlD;AAED,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,aAAa,CAG1E;AAED,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI;IACxC,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE,cAAc,CAAC;CACxB,CAgCA;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,MAAM,GAAE,MAAe,GAAG,MAAM,CAEtD"}

package/dist/__tests__/helpers.js

@@ -0,0 +1,80 @@
+import { createClient } from "@libsql/client";
+import { KERNL_SCHEMA_NAME } from "@kernl-sdk/storage";
+import { LibSQLStorage } from "../storage.js";
+// Counter to ensure unique database URLs within the same process
+let dbCounter = 0;
+/**
+ * Generate a unique database URL for each test.
+ * Uses temp file instead of :memory: due to libsql bug with in-memory transactions.
+ */
+export function test_db_url() {
+    return `file:/tmp/kernl-test-${process.pid}-${Date.now()}-${++dbCounter}.db`;
+}
+export const THREADS_TABLE = `${KERNL_SCHEMA_NAME}_threads`;
+export const THREAD_EVENTS_TABLE = `${KERNL_SCHEMA_NAME}_thread_events`;
+export const MEMORIES_TABLE = `${KERNL_SCHEMA_NAME}_memories`;
+export const MIGRATIONS_TABLE = `${KERNL_SCHEMA_NAME}_migrations`;
+/**
+ * Create a test database setup with client and storage sharing the same URL.
+ */
+export function create_test_db() {
+    const url = test_db_url();
+    const client = createClient({ url });
+    const storage = new LibSQLStorage({ client, url });
+    return { client, storage, url };
+}
+export function create_client(url) {
+    const dbUrl = url ?? test_db_url();
+    return createClient({ url: dbUrl });
+}
+export async function enable_foreign_keys(client) {
+    await client.execute("PRAGMA foreign_keys = ON");
+}
+export function create_storage(client, url) {
+    const dbUrl = url ?? test_db_url();
+    return new LibSQLStorage({ client, url: dbUrl });
+}
+export async function reset_tables(client) {
+    await client.execute(`DELETE FROM "${THREAD_EVENTS_TABLE}"`);
+    await client.execute(`DELETE FROM "${THREADS_TABLE}"`);
+    await client.execute(`DELETE FROM "${MEMORIES_TABLE}"`);
+}
+/**
+ * Create mock registries for thread hydration tests.
+ */
+export function create_mock_registries() {
+    const agentMap = new Map();
+    const modelMap = new Map();
+    // Add a test agent
+    agentMap.set("test-agent", {
+        id: "test-agent",
+        kind: "llm",
+        name: "Test Agent",
+    });
+    // Add a test model
+    modelMap.set("test/model", {
+        id: "test/model",
+        provider: "test",
+        modelId: "model",
+    });
+    return {
+        agents: {
+            get: (id) => agentMap.get(id),
+            set: (id, agent) => agentMap.set(id, agent),
+            has: (id) => agentMap.has(id),
+            list: () => Array.from(agentMap.values()),
+        },
+        models: {
+            get: (id) => modelMap.get(id),
+            set: (id, model) => modelMap.set(id, model),
+            has: (id) => modelMap.has(id),
+            list: () => Array.from(modelMap.values()),
+        },
+    };
+}
+/**
+ * Generate a unique ID for tests.
+ */
+export function testid(prefix = "test") {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}

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

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

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

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

package/dist/__tests__/memory.create-get.test.js

@@ -0,0 +1,8 @@
+import { describe, it } from "vitest";
+describe("LibSQL memory create/get", () => {
+    it.todo("creates memory with text content");
+    it.todo("creates memory with object content");
+    it.todo("creates working memory (wmem=true)");
+    it.todo("creates short-term memory with expiration");
+    it.todo("gets by id and returns null when missing");
+});

package/dist/__tests__/memory.delete.test.d.ts

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

package/dist/__tests__/memory.delete.test.d.ts.map

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

package/dist/__tests__/memory.delete.test.js

@@ -0,0 +1,6 @@
+import { describe, it } from "vitest";
+describe("LibSQL memory delete", () => {
+    it.todo("deletes by id");
+    it.todo("mdelete removes multiple ids");
+    it.todo("mdelete handles empty array");
+});

package/dist/__tests__/memory.list.test.d.ts

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

package/dist/__tests__/memory.list.test.d.ts.map

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

package/dist/__tests__/memory.list.test.js

@@ -0,0 +1,8 @@
+import { describe, it } from "vitest";
+describe("LibSQL memory list", () => {
+    it.todo("filters by namespace/entity/agent/collection");
+    it.todo("filters by wmem and smem");
+    it.todo("filters by timestamp range");
+    it.todo("orders by timestamp desc/asc");
+    it.todo("applies limit and offset");
+});

package/dist/__tests__/memory.update.test.d.ts

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

package/dist/__tests__/memory.update.test.d.ts.map

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

package/dist/__tests__/memory.update.test.js

@@ -0,0 +1,8 @@
+import { describe, it } from "vitest";
+describe("LibSQL memory update", () => {
+    it.todo("updates content and bumps updated_at");
+    it.todo("updates wmem flag");
+    it.todo("updates smem expiration");
+    it.todo("updates metadata");
+    it.todo("throws when memory does not exist");
+});

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

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

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

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

package/dist/__tests__/migrations.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { create_client, create_storage, THREADS_TABLE, MEMORIES_TABLE, } from "./helpers.js";
+describe("LibSQL migrations", () => {
+    let client;
+    beforeEach(() => {
+        client = create_client();
+    });
+    afterEach(() => {
+        client.close();
+    });
+    it("creates tables with mapped SQLite types", async () => {
+        const storage = create_storage(client);
+        await storage.memories.list();
+        // Check threads table schema
+        const threadInfo = await client.execute(`PRAGMA table_info("${THREADS_TABLE}")`);
+        const threadCols = Object.fromEntries(threadInfo.rows.map((r) => [r.name, r.type]));
+        // JSON fields should be TEXT (not JSONB)
+        expect(threadCols.context).toBe("TEXT");
+        expect(threadCols.metadata).toBe("TEXT");
+        expect(threadCols.state).toBe("TEXT");
+        // Check memories table schema
+        const memoryInfo = await client.execute(`PRAGMA table_info("${MEMORIES_TABLE}")`);
+        const memoryCols = Object.fromEntries(memoryInfo.rows.map((r) => [r.name, r.type]));
+        // Boolean fields should be INTEGER
+        expect(memoryCols.wmem).toBe("INTEGER");
+        // JSON fields should be TEXT
+        expect(memoryCols.content).toBe("TEXT");
+        expect(memoryCols.metadata).toBe("TEXT");
+    });
+    it("applies column defaults correctly", async () => {
+        const storage = create_storage(client);
+        await storage.memories.list();
+        // Check threads table defaults
+        const threadInfo = await client.execute(`PRAGMA table_info("${THREADS_TABLE}")`);
+        const tickCol = threadInfo.rows.find((r) => r.name === "tick");
+        const namespaceCol = threadInfo.rows.find((r) => r.name === "namespace");
+        expect(tickCol?.dflt_value).toBe("0");
+        expect(namespaceCol?.dflt_value).toBe("'kernl'");
+        // Check memories table defaults
+        const memoryInfo = await client.execute(`PRAGMA table_info("${MEMORIES_TABLE}")`);
+        const wmemCol = memoryInfo.rows.find((r) => r.name === "wmem");
+        expect(wmemCol?.dflt_value).toBe("0");
+    });
+    it("creates indexes from table definitions", async () => {
+        const storage = create_storage(client);
+        await storage.memories.list();
+        // Check for indexes on threads table
+        const threadIndexes = await client.execute(`PRAGMA index_list("${THREADS_TABLE}")`);
+        const threadIndexNames = threadIndexes.rows.map((r) => r.name);
+        // Should have index on namespace
+        expect(threadIndexNames.some((n) => n.includes("namespace"))).toBe(true);
+        // Check for indexes on memories table
+        const memoryIndexes = await client.execute(`PRAGMA index_list("${MEMORIES_TABLE}")`);
+        const memoryIndexNames = memoryIndexes.rows.map((r) => r.name);
+        // Should have indexes for common queries
+        expect(memoryIndexNames.some((n) => n.includes("namespace"))).toBe(true);
+    });
+    it("creates foreign key constraint on thread_events", async () => {
+        const storage = create_storage(client);
+        await storage.memories.list();
+        const fkInfo = await client.execute('PRAGMA foreign_key_list("kernl_thread_events")');
+        expect(fkInfo.rows.length).toBeGreaterThan(0);
+        const threadFk = fkInfo.rows.find((r) => r.table === THREADS_TABLE);
+        expect(threadFk).toBeDefined();
+        expect(threadFk?.from).toBe("tid");
+        expect(threadFk?.to).toBe("id");
+    });
+});

package/dist/__tests__/row-codecs.test.d.ts

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

package/dist/__tests__/row-codecs.test.d.ts.map

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