@kernl-sdk/libsql 0.1.36 → 0.1.39

package/dist/thread/store.js

@@ -0,0 +1,282 @@
+/**
+ * LibSQL Thread store implementation.
+ */
+import assert from "assert";
+import { Context, } from "kernl";
+import { Thread } from "kernl/internal";
+import { KERNL_SCHEMA_NAME, NewThreadCodec, ThreadEventRecordCodec, } from "@kernl-sdk/storage";
+import { SQL_WHERE, SQL_ORDER, SQL_UPDATE } from "./sql.js";
+import { RowToThreadRecord, RowToEventRecord, RowToEventRecordDirect, } from "./row.js";
+import { expandarray } from "../sql.js";
+// SQLite doesn't support schemas, so we use table name prefix
+const THREADS_TABLE = `${KERNL_SCHEMA_NAME}_threads`;
+const THREAD_EVENTS_TABLE = `${KERNL_SCHEMA_NAME}_thread_events`;
+/**
+ * LibSQL Thread store implementation.
+ *
+ * All async methods call `ensureInit()` before database operations
+ * to ensure schema/tables exist.
+ */
+export class LibSQLThreadStore {
+    db;
+    registries;
+    ensureInit;
+    constructor(db, ensureInit) {
+        this.db = db;
+        this.ensureInit = ensureInit;
+        this.registries = null;
+    }
+    /**
+     * Bind runtime registries for hydrating Thread instances.
+     */
+    bind(registries) {
+        this.registries = registries;
+    }
+    /**
+     * Get a thread by id.
+     */
+    async get(tid, include) {
+        await this.ensureInit();
+        // JOIN with thread_events if include.history
+        if (include?.history) {
+            const opts = typeof include.history === "object" ? include.history : undefined;
+            const params = [tid];
+            let eventFilter = "";
+            if (opts?.after !== undefined) {
+                eventFilter += ` AND e.seq > ?`;
+                params.push(opts.after);
+            }
+            if (opts?.kinds && opts.kinds.length > 0) {
+                const { placeholders, params: kindParams } = expandarray(opts.kinds);
+                eventFilter += ` AND e.kind IN (${placeholders})`;
+                params.push(...kindParams);
+            }
+            const order = opts?.order ?? "asc";
+            const limit = opts?.limit ? ` LIMIT ${opts.limit}` : "";
+            const query = `
+        SELECT
+          t.*,
+          e.id as event_id,
+          e.tid as event_tid,
+          e.seq,
+          e.kind as event_kind,
+          e.timestamp,
+          e.data,
+          e.metadata as event_metadata
+        FROM ${THREADS_TABLE} t
+        LEFT JOIN ${THREAD_EVENTS_TABLE} e ON t.id = e.tid${eventFilter}
+        WHERE t.id = ?
+        ORDER BY e.seq ${order.toUpperCase()}
+        ${limit}
+      `;
+            // Move tid to end of params (WHERE t.id = ?)
+            const finalParams = [...params.slice(1), tid];
+            const result = await this.db.execute({ sql: query, args: finalParams });
+            if (result.rows.length === 0) {
+                return null;
+            }
+            // first row has thread data (all rows have same thread data)
+            const record = RowToThreadRecord.encode(result.rows[0]);
+            // collect events from all rows (skip rows where event_id is null)
+            const events = result.rows
+                .filter((row) => row.event_id !== null)
+                .map((row) => ThreadEventRecordCodec.decode(RowToEventRecord.encode(row)));
+            try {
+                return this.hydrate({ record, events });
+            }
+            catch {
+                return null;
+            }
+        }
+        // simple query without events
+        const result = await this.db.execute({
+            sql: `SELECT * FROM ${THREADS_TABLE} WHERE id = ?`,
+            args: [tid],
+        });
+        if (result.rows.length === 0) {
+            return null;
+        }
+        try {
+            return this.hydrate({ record: RowToThreadRecord.encode(result.rows[0]) });
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List threads matching the filter.
+     */
+    async list(options) {
+        await this.ensureInit();
+        const { sql: where, params } = SQL_WHERE.encode({
+            filter: options?.filter,
+        });
+        let query = `SELECT * FROM ${THREADS_TABLE}`;
+        if (where)
+            query += ` WHERE ${where}`;
+        query += ` ORDER BY ${SQL_ORDER.encode({ order: options?.order })}`;
+        const args = [...params];
+        if (options?.limit) {
+            query += ` LIMIT ?`;
+            args.push(options.limit);
+        }
+        if (options?.offset) {
+            query += ` OFFSET ?`;
+            args.push(options.offset);
+        }
+        const result = await this.db.execute({ sql: query, args });
+        return result.rows
+            .map((row) => {
+            try {
+                return this.hydrate({ record: RowToThreadRecord.encode(row) });
+            }
+            catch {
+                // Skip threads with non-existent agent/model (graceful degradation)
+                return null;
+            }
+        })
+            .filter((thread) => thread !== null);
+    }
+    /**
+     * Insert a new thread into the store.
+     */
+    async insert(thread) {
+        await this.ensureInit();
+        const record = NewThreadCodec.encode(thread);
+        const result = await this.db.execute({
+            sql: `INSERT INTO ${THREADS_TABLE}
+       (id, namespace, agent_id, model, context, tick, state, parent_task_id, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`,
+            args: [
+                record.id,
+                record.namespace,
+                record.agent_id,
+                record.model,
+                JSON.stringify(record.context),
+                record.tick,
+                record.state,
+                record.parent_task_id,
+                record.metadata ? JSON.stringify(record.metadata) : null,
+                record.created_at,
+                record.updated_at,
+            ],
+        });
+        return this.hydrate({ record: RowToThreadRecord.encode(result.rows[0]) });
+    }
+    /**
+     * Update thread runtime state.
+     */
+    async update(tid, patch) {
+        await this.ensureInit();
+        const { sql: updates, params } = SQL_UPDATE.encode({ patch });
+        const args = [...params, tid];
+        const result = await this.db.execute({
+            sql: `UPDATE ${THREADS_TABLE}
+       SET ${updates}
+       WHERE id = ?
+       RETURNING *`,
+            args,
+        });
+        return this.hydrate({ record: RowToThreadRecord.encode(result.rows[0]) });
+    }
+    /**
+     * Delete a thread and cascade to thread_events.
+     */
+    async delete(tid) {
+        await this.ensureInit();
+        await this.db.execute({
+            sql: `DELETE FROM ${THREADS_TABLE} WHERE id = ?`,
+            args: [tid],
+        });
+    }
+    /**
+     * Get the event history for a thread.
+     */
+    async history(tid, opts) {
+        await this.ensureInit();
+        let query = `SELECT * FROM ${THREAD_EVENTS_TABLE} WHERE tid = ?`;
+        const args = [tid];
+        // - filter:seq -
+        if (opts?.after !== undefined) {
+            query += ` AND seq > ?`;
+            args.push(opts.after);
+        }
+        // - filter:kind -
+        if (opts?.kinds && opts.kinds.length > 0) {
+            const { placeholders, params: kindParams } = expandarray(opts.kinds);
+            query += ` AND kind IN (${placeholders})`;
+            args.push(...kindParams);
+        }
+        // - order -
+        const order = opts?.order ?? "asc";
+        query += ` ORDER BY seq ${order.toUpperCase()}`;
+        // - limit -
+        if (opts?.limit !== undefined) {
+            query += ` LIMIT ?`;
+            args.push(opts.limit);
+        }
+        const result = await this.db.execute({ sql: query, args });
+        return result.rows.map((row) => ThreadEventRecordCodec.decode(RowToEventRecordDirect.encode(row)));
+    }
+    /**
+     * 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
+     */
+    async append(events) {
+        if (events.length === 0)
+            return;
+        await this.ensureInit();
+        const records = events.map((e) => ThreadEventRecordCodec.encode(e));
+        const placeholders = [];
+        const values = [];
+        for (const record of records) {
+            placeholders.push(`(?, ?, ?, ?, ?, ?, ?)`);
+            values.push(record.id, record.tid, record.seq, record.kind, record.timestamp, record.data ? JSON.stringify(record.data) : null, record.metadata ? JSON.stringify(record.metadata) : null);
+        }
+        // insert with ON CONFLICT DO NOTHING for idempotency
+        await this.db.execute({
+            sql: `INSERT INTO ${THREAD_EVENTS_TABLE}
+       (id, tid, seq, kind, timestamp, data, metadata)
+       VALUES ${placeholders.join(", ")}
+       ON CONFLICT (tid, id) DO NOTHING`,
+            args: values,
+        });
+    }
+    /**
+     * Hydrate a Thread instance from a database record.
+     */
+    hydrate(thread) {
+        assert(this.registries, "registries should be bound to storage in Kernl constructor");
+        const { record, events = [] } = thread;
+        const agent = this.registries.agents.get(record.agent_id);
+        const model = this.registries.models.get(record.model);
+        if (!agent || !model) {
+            throw new Error(`Thread ${record.id} references non-existent agent/model (agent: ${record.agent_id}, model: ${record.model})`);
+        }
+        // safety: threads only exist for llm agents
+        if (agent.kind !== "llm") {
+            throw new Error(`Thread ${record.id} references non-llm agent ${record.agent_id} (kind: ${agent.kind})`);
+        }
+        return new Thread({
+            agent: agent,
+            history: events,
+            context: new Context(record.namespace, record.context),
+            model,
+            task: null, // TODO: load from TaskStore when it exists
+            tid: record.id,
+            namespace: record.namespace,
+            tick: record.tick,
+            state: record.state,
+            metadata: record.metadata,
+            createdAt: new Date(Number(record.created_at)),
+            updatedAt: new Date(Number(record.updated_at)),
+            storage: this, // pass storage reference so resumed thread can persist
+            persisted: true,
+        });
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared utilities for LibSQL storage.
+ */
+/**
+ * Parse a JSON string from SQLite into an object.
+ *
+ * SQLite stores JSON as TEXT, so we need to parse it back.
+ */
+export declare function parsejson<T>(value: unknown): T | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,GAAG,IAAI,CAUrD"}

package/dist/utils.js

@@ -0,0 +1,21 @@
+/**
+ * Shared utilities for LibSQL storage.
+ */
+/**
+ * Parse a JSON string from SQLite into an object.
+ *
+ * SQLite stores JSON as TEXT, so we need to parse it back.
+ */
+export function parsejson(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "string") {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernl-sdk/libsql",
-  "version": "0.1.36",
+  "version": "0.1.39",
   "description": "LibSQL storage adapter for kernl",
   "keywords": [
     "kernl",
@@ -29,15 +29,6 @@
       "import": "./dist/index.js"
     }
   },
-  "devDependencies": {
-    "@types/node": "^24.10.0",
-    "tsc-alias": "^1.8.10",
-    "typescript": "5.9.2",
-    "vitest": "^4.0.8"
-  },
-  "dependencies": {
-    "@kernl-sdk/storage": "0.2.4"
-  },
   "scripts": {
     "build": "tsc && tsc-alias --resolve-full-paths",
     "dev": "tsc --watch",
@@ -45,5 +36,18 @@
     "test": "vitest",
     "test:watch": "vitest --watch",
     "test:run": "vitest run"
+  },
+  "devDependencies": {
+    "@kernl-sdk/protocol": "workspace:*",
+    "@types/node": "^24.10.0",
+    "tsc-alias": "^1.8.10",
+    "typescript": "5.9.2",
+    "vitest": "^4.0.8"
+  },
+  "dependencies": {
+    "@kernl-sdk/shared": "workspace:*",
+    "@kernl-sdk/storage": "workspace:*",
+    "@libsql/client": "^0.14.0",
+    "kernl": "workspace:*"
   }
-}
+}

package/src/__tests__/constraints.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import type { Client } from "@libsql/client";
+
+import {
+  create_client,
+  create_storage,
+  enable_foreign_keys,
+  THREADS_TABLE,
+  THREAD_EVENTS_TABLE,
+  testid,
+} from "./helpers";
+import { LibSQLStorage } from "../storage";
+
+describe("LibSQL constraints", () => {
+  let client: Client;
+  let storage: LibSQLStorage;
+
+  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/src/__tests__/helpers.ts

@@ -0,0 +1,98 @@
+import { createClient, type Client } from "@libsql/client";
+import { KERNL_SCHEMA_NAME } from "@kernl-sdk/storage";
+import type { IAgentRegistry, IModelRegistry } from "kernl";
+
+import { LibSQLStorage } from "../storage";
+
+// 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(): string {
+  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(): { client: Client; storage: LibSQLStorage; url: string } {
+  const url = test_db_url();
+  const client = createClient({ url });
+  const storage = new LibSQLStorage({ client, url });
+  return { client, storage, url };
+}
+
+export function create_client(url?: string): Client {
+  const dbUrl = url ?? test_db_url();
+  return createClient({ url: dbUrl });
+}
+
+export async function enable_foreign_keys(client: Client): Promise<void> {
+  await client.execute("PRAGMA foreign_keys = ON");
+}
+
+export function create_storage(client: Client, url?: string): LibSQLStorage {
+  const dbUrl = url ?? test_db_url();
+  return new LibSQLStorage({ client, url: dbUrl });
+}
+
+export async function reset_tables(client: Client): Promise<void> {
+  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(): {
+  agents: IAgentRegistry;
+  models: IModelRegistry;
+} {
+  const agentMap = new Map<string, any>();
+  const modelMap = new Map<string, any>();
+
+  // 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: string) => agentMap.get(id),
+      set: (id: string, agent: any) => agentMap.set(id, agent),
+      has: (id: string) => agentMap.has(id),
+      list: () => Array.from(agentMap.values()),
+    } as IAgentRegistry,
+    models: {
+      get: (id: string) => modelMap.get(id),
+      set: (id: string, model: any) => modelMap.set(id, model),
+      has: (id: string) => modelMap.has(id),
+      list: () => Array.from(modelMap.values()),
+    } as IModelRegistry,
+  };
+}
+
+/**
+ * Generate a unique ID for tests.
+ */
+export function testid(prefix: string = "test"): string {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}

package/src/__tests__/migrations.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import type { Client } from "@libsql/client";
+
+import {
+  create_client,
+  create_storage,
+  THREADS_TABLE,
+  MEMORIES_TABLE,
+} from "./helpers";
+
+describe("LibSQL migrations", () => {
+  let client: 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 as string);
+
+    // 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 as string);
+
+    // 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");
+  });
+});