@ai-ecoverse/slicc-agent 1.1.0 → 1.2.0

package/README.md

@@ -16,6 +16,7 @@ await agent.prompt('What is in /home?');
 ```
 
 - `openAgent({ models, model, storage?, registry?, settings? })` opens a durable Harness (in memory unless `storage` is given) and its root conversation. `prompt(text)` submits an input and resolves with the answer's text.
+- `openOpfsSqliteStorage({ directory?, file? })` keeps the session in wasm SQLite ([`@sqlite.org/sqlite-wasm`](https://www.npmjs.com/package/@sqlite.org/sqlite-wasm)) in an `opfs-sahpool` pool, by default `/.slicc/agent/` in OPFS. It needs a dedicated worker. Only one worker holds a pool at a time: the opener takes a Web Lock per directory and waits until every file of the pool can be opened before sqlite-wasm installs it, because a failed install deletes the pool's directory. `openMemorySqliteStorage()` keeps the same database in memory. Pass either as `storage`.
 - `serveAgent(endpoint, agent)` answers prompts that arrive on a worker or `MessagePort`; `connectAgent(endpoint)` is the page side.
 
 ## Develop

package/dist/index.js

@@ -3,10 +3,20 @@ import {
   connectAgent,
   serveAgent
 } from "./port.js";
+import {
+  AGENT_DIRECTORY,
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage,
+  WasmSqliteDatabase
+} from "./sqlite.js";
 export {
+  AGENT_DIRECTORY,
+  WasmSqliteDatabase,
   answerText,
   connectAgent,
   openAgent,
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage,
   serveAgent
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport {\n  type AgentClient,\n  type AgentReply,\n  type AgentRequest,\n  connectAgent,\n  type MessageEndpoint,\n  serveAgent,\n} from './port.ts';\n"],
-  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE;AAAA,EAIE;AAAA,EAEA;AAAA,OACK;",
+  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport {\n  type AgentClient,\n  type AgentReply,\n  type AgentRequest,\n  connectAgent,\n  type MessageEndpoint,\n  serveAgent,\n} from './port.ts';\nexport {\n  AGENT_DIRECTORY,\n  type OpfsSqliteOptions,\n  openMemorySqliteStorage,\n  openOpfsSqliteStorage,\n  WasmSqliteDatabase,\n} from './sqlite.ts';\n"],
+  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE;AAAA,EAIE;AAAA,EAEA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,OACK;",
   "names": []
 }

package/dist/opfs-pool.js

@@ -0,0 +1,55 @@
+const names = /* @__PURE__ */ new Map();
+function vfsName(directory) {
+  let name = names.get(directory);
+  if (!name) {
+    name = `slicc-agent-${names.size}`;
+    names.set(directory, name);
+  }
+  return name;
+}
+function holdLock(locks, name) {
+  return new Promise((acquired, failed) => {
+    locks.request(name, { mode: "exclusive" }, () => new Promise((release) => acquired(release))).catch(failed);
+  });
+}
+async function opaque(root, directory) {
+  let dir = root;
+  try {
+    for (const part of [...directory.split("/").filter(Boolean), ".opaque"]) {
+      dir = await dir.getDirectoryHandle(part);
+    }
+  } catch {
+    return void 0;
+  }
+  return dir;
+}
+async function acquirable(dir) {
+  for await (const handle of dir.values()) {
+    if (handle.kind !== "file") continue;
+    try {
+      const access = await handle.createSyncAccessHandle();
+      access.close();
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+const pause = (ms) => new Promise((resume) => setTimeout(resume, ms));
+async function settlePool(directory, access = {}) {
+  const root = await (access.root ?? (() => navigator.storage.getDirectory()))();
+  const dir = await opaque(root, directory);
+  if (!dir) return;
+  const attempts = access.attempts ?? 50;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (await acquirable(dir)) return;
+    if (attempt < attempts) await pause(access.delayMs ?? 100);
+  }
+  throw new Error(`SQLite pool ${directory} is still in use by another worker`);
+}
+export {
+  holdLock,
+  settlePool,
+  vfsName
+};
+//# sourceMappingURL=opfs-pool.js.map

package/dist/opfs-pool.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/opfs-pool.ts"],
+  "sourcesContent": ["export interface PoolAccess {\n  root?: () => Promise<FileSystemDirectoryHandle>;\n  locks?: LockManager;\n  attempts?: number;\n  delayMs?: number;\n}\n\ninterface SyncAccessible {\n  createSyncAccessHandle(): Promise<{ close(): void }>;\n}\n\nconst names = new Map<string, string>();\n\nexport function vfsName(directory: string): string {\n  let name = names.get(directory);\n  if (!name) {\n    name = `slicc-agent-${names.size}`;\n    names.set(directory, name);\n  }\n  return name;\n}\n\nexport function holdLock(locks: LockManager, name: string): Promise<() => void> {\n  return new Promise((acquired, failed) => {\n    locks\n      .request(name, { mode: 'exclusive' }, () => new Promise<void>((release) => acquired(release)))\n      .catch(failed);\n  });\n}\n\nasync function opaque(\n  root: FileSystemDirectoryHandle,\n  directory: string\n): Promise<FileSystemDirectoryHandle | undefined> {\n  let dir = root;\n  try {\n    for (const part of [...directory.split('/').filter(Boolean), '.opaque']) {\n      dir = await dir.getDirectoryHandle(part);\n    }\n  } catch {\n    return undefined;\n  }\n  return dir;\n}\n\nasync function acquirable(dir: FileSystemDirectoryHandle): Promise<boolean> {\n  for await (const handle of dir.values()) {\n    if (handle.kind !== 'file') continue;\n    try {\n      const access = await (handle as unknown as SyncAccessible).createSyncAccessHandle();\n      access.close();\n    } catch {\n      return false;\n    }\n  }\n  return true;\n}\n\nconst pause = (ms: number) => new Promise((resume) => setTimeout(resume, ms));\n\nexport async function settlePool(directory: string, access: PoolAccess = {}): Promise<void> {\n  const root = await (access.root ?? (() => navigator.storage.getDirectory()))();\n  const dir = await opaque(root, directory);\n  if (!dir) return;\n  const attempts = access.attempts ?? 50;\n  for (let attempt = 1; attempt <= attempts; attempt++) {\n    if (await acquirable(dir)) return;\n    if (attempt < attempts) await pause(access.delayMs ?? 100);\n  }\n  throw new Error(`SQLite pool ${directory} is still in use by another worker`);\n}\n"],
+  "mappings": "AAWA,MAAM,QAAQ,oBAAI,IAAoB;AAE/B,SAAS,QAAQ,WAA2B;AACjD,MAAI,OAAO,MAAM,IAAI,SAAS;AAC9B,MAAI,CAAC,MAAM;AACT,WAAO,eAAe,MAAM,IAAI;AAChC,UAAM,IAAI,WAAW,IAAI;AAAA,EAC3B;AACA,SAAO;AACT;AAEO,SAAS,SAAS,OAAoB,MAAmC;AAC9E,SAAO,IAAI,QAAQ,CAAC,UAAU,WAAW;AACvC,UACG,QAAQ,MAAM,EAAE,MAAM,YAAY,GAAG,MAAM,IAAI,QAAc,CAAC,YAAY,SAAS,OAAO,CAAC,CAAC,EAC5F,MAAM,MAAM;AAAA,EACjB,CAAC;AACH;AAEA,eAAe,OACb,MACA,WACgD;AAChD,MAAI,MAAM;AACV,MAAI;AACF,eAAW,QAAQ,CAAC,GAAG,UAAU,MAAM,GAAG,EAAE,OAAO,OAAO,GAAG,SAAS,GAAG;AACvE,YAAM,MAAM,IAAI,mBAAmB,IAAI;AAAA,IACzC;AAAA,EACF,QAAQ;AACN,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,eAAe,WAAW,KAAkD;AAC1E,mBAAiB,UAAU,IAAI,OAAO,GAAG;AACvC,QAAI,OAAO,SAAS,OAAQ;AAC5B,QAAI;AACF,YAAM,SAAS,MAAO,OAAqC,uBAAuB;AAClF,aAAO,MAAM;AAAA,IACf,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,MAAM,QAAQ,CAAC,OAAe,IAAI,QAAQ,CAAC,WAAW,WAAW,QAAQ,EAAE,CAAC;AAE5E,eAAsB,WAAW,WAAmB,SAAqB,CAAC,GAAkB;AAC1F,QAAM,OAAO,OAAO,OAAO,SAAS,MAAM,UAAU,QAAQ,aAAa,IAAI;AAC7E,QAAM,MAAM,MAAM,OAAO,MAAM,SAAS;AACxC,MAAI,CAAC,IAAK;AACV,QAAM,WAAW,OAAO,YAAY;AACpC,WAAS,UAAU,GAAG,WAAW,UAAU,WAAW;AACpD,QAAI,MAAM,WAAW,GAAG,EAAG;AAC3B,QAAI,UAAU,SAAU,OAAM,MAAM,OAAO,WAAW,GAAG;AAAA,EAC3D;AACA,QAAM,IAAI,MAAM,eAAe,SAAS,oCAAoC;AAC9E;",
+  "names": []
+}

package/dist/sqlite.js

@@ -0,0 +1,158 @@
+import {
+  SqliteStorage
+} from "@earendil-works/pi-durable/storage/sqlite";
+import init, {} from "@sqlite.org/sqlite-wasm";
+import { holdLock, settlePool, vfsName } from "./opfs-pool.js";
+class SerialQueue {
+  #tail = Promise.resolve();
+  run(operation) {
+    const result = this.#tail.then(operation);
+    this.#tail = result.catch(() => {
+    });
+    return result;
+  }
+}
+class Statements {
+  #db;
+  #cache = /* @__PURE__ */ new Map();
+  constructor(db) {
+    this.#db = db;
+  }
+  bound(sql, params) {
+    let statement = this.#cache.get(sql);
+    if (!statement) {
+      statement = this.#db.prepare(sql);
+      this.#cache.set(sql, statement);
+    }
+    statement.reset(true);
+    if (params.length > 0) statement.bind([...params]);
+    return statement;
+  }
+  finalize() {
+    for (const statement of this.#cache.values()) statement.finalize();
+    this.#cache.clear();
+  }
+}
+class WasmSqliteExecutor {
+  db;
+  statements;
+  constructor(db, statements) {
+    this.db = db;
+    this.statements = statements;
+  }
+  async exec(sql) {
+    this.check();
+    this.db.exec(sql);
+  }
+  async run(sql, ...params) {
+    this.check();
+    this.statements.bound(sql, params).stepReset();
+  }
+  async get(sql, ...params) {
+    this.check();
+    const statement = this.statements.bound(sql, params);
+    const row = statement.step() ? statement.get({}) : void 0;
+    statement.reset();
+    return row;
+  }
+  async all(sql, ...params) {
+    this.check();
+    const statement = this.statements.bound(sql, params);
+    const rows = [];
+    while (statement.step()) rows.push(statement.get({}));
+    statement.reset();
+    return rows;
+  }
+  check() {
+  }
+}
+class WasmSqliteTransaction extends WasmSqliteExecutor {
+  active = true;
+  check() {
+    if (!this.active) throw new Error("SQLite transaction handle is no longer active");
+  }
+}
+class WasmSqliteDatabase extends WasmSqliteExecutor {
+  #queue = new SerialQueue();
+  #closed;
+  constructor(db, closed = () => {
+  }) {
+    super(db, new Statements(db));
+    this.#closed = closed;
+  }
+  exec(sql) {
+    return this.#queue.run(() => super.exec(sql));
+  }
+  run(sql, ...params) {
+    return this.#queue.run(() => super.run(sql, ...params));
+  }
+  get(sql, ...params) {
+    return this.#queue.run(() => super.get(sql, ...params));
+  }
+  all(sql, ...params) {
+    return this.#queue.run(() => super.all(sql, ...params));
+  }
+  transaction(callback) {
+    return this.#queue.run(async () => {
+      const transaction = new WasmSqliteTransaction(this.db, this.statements);
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = await callback(transaction);
+        this.db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        this.#rollback(error);
+        throw error;
+      } finally {
+        transaction.active = false;
+      }
+    });
+  }
+  close() {
+    return this.#queue.run(() => {
+      try {
+        this.statements.finalize();
+        this.db.close();
+      } finally {
+        this.#closed();
+      }
+    });
+  }
+  #rollback(cause) {
+    try {
+      this.db.exec("ROLLBACK");
+    } catch (error) {
+      throw new AggregateError([cause, error], "SQLite rollback failed");
+    }
+  }
+}
+const AGENT_DIRECTORY = "/.slicc/agent";
+async function openMemorySqliteStorage() {
+  const sqlite3 = await init();
+  return SqliteStorage.open(new WasmSqliteDatabase(new sqlite3.oo1.DB(":memory:", "c")));
+}
+async function openOpfsSqliteStorage(options = {}) {
+  const directory = options.directory ?? AGENT_DIRECTORY;
+  const release = await holdLock(
+    options.locks ?? navigator.locks,
+    `slicc-agent-sqlite:${directory}`
+  );
+  try {
+    await settlePool(directory, options);
+    const sqlite3 = await (options.load ?? init)();
+    const pool = await sqlite3.installOpfsSAHPoolVfs({ name: vfsName(directory), directory });
+    const db = new pool.OpfsSAHPoolDb(options.file ?? "/agent.sqlite");
+    db.exec("PRAGMA journal_mode = TRUNCATE");
+    return await SqliteStorage.open(new WasmSqliteDatabase(db, release));
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+export {
+  AGENT_DIRECTORY,
+  WasmSqliteDatabase,
+  openMemorySqliteStorage,
+  openOpfsSqliteStorage
+};
+//# sourceMappingURL=sqlite.js.map

package/dist/sqlite.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/sqlite.ts"],
+  "sourcesContent": ["import type { Storage } from '@earendil-works/pi-durable';\nimport {\n  type SqliteDatabase,\n  type SqliteExecutor,\n  SqliteStorage,\n  type SqliteValue,\n} from '@earendil-works/pi-durable/storage/sqlite';\nimport init, { type Database, type PreparedStatement } from '@sqlite.org/sqlite-wasm';\nimport { holdLock, type PoolAccess, settlePool, vfsName } from './opfs-pool.ts';\n\ntype Row = Record<string, unknown>;\n\nclass SerialQueue {\n  #tail: Promise<unknown> = Promise.resolve();\n\n  run<T>(operation: () => T | Promise<T>): Promise<T> {\n    const result = this.#tail.then(operation);\n    this.#tail = result.catch(() => {});\n    return result;\n  }\n}\n\nclass Statements {\n  readonly #db: Database;\n  readonly #cache = new Map<string, PreparedStatement>();\n\n  constructor(db: Database) {\n    this.#db = db;\n  }\n\n  bound(sql: string, params: readonly SqliteValue[]): PreparedStatement {\n    let statement = this.#cache.get(sql);\n    if (!statement) {\n      statement = this.#db.prepare(sql);\n      this.#cache.set(sql, statement);\n    }\n    statement.reset(true);\n    if (params.length > 0) statement.bind([...params]);\n    return statement;\n  }\n\n  finalize(): void {\n    for (const statement of this.#cache.values()) statement.finalize();\n    this.#cache.clear();\n  }\n}\n\nclass WasmSqliteExecutor implements SqliteExecutor {\n  protected readonly db: Database;\n  protected readonly statements: Statements;\n\n  constructor(db: Database, statements: Statements) {\n    this.db = db;\n    this.statements = statements;\n  }\n\n  async exec(sql: string): Promise<void> {\n    this.check();\n    this.db.exec(sql);\n  }\n\n  async run(sql: string, ...params: SqliteValue[]): Promise<void> {\n    this.check();\n    this.statements.bound(sql, params).stepReset();\n  }\n\n  async get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined> {\n    this.check();\n    const statement = this.statements.bound(sql, params);\n    const row = statement.step() ? (statement.get({}) as Row as T) : undefined;\n    statement.reset();\n    return row;\n  }\n\n  async all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]> {\n    this.check();\n    const statement = this.statements.bound(sql, params);\n    const rows: T[] = [];\n    while (statement.step()) rows.push(statement.get({}) as Row as T);\n    statement.reset();\n    return rows;\n  }\n\n  protected check(): void {}\n}\n\nclass WasmSqliteTransaction extends WasmSqliteExecutor {\n  active = true;\n\n  protected override check(): void {\n    if (!this.active) throw new Error('SQLite transaction handle is no longer active');\n  }\n}\n\nexport class WasmSqliteDatabase extends WasmSqliteExecutor implements SqliteDatabase {\n  readonly #queue = new SerialQueue();\n  readonly #closed: () => void;\n\n  constructor(db: Database, closed: () => void = () => {}) {\n    super(db, new Statements(db));\n    this.#closed = closed;\n  }\n\n  override exec(sql: string): Promise<void> {\n    return this.#queue.run(() => super.exec(sql));\n  }\n\n  override run(sql: string, ...params: SqliteValue[]): Promise<void> {\n    return this.#queue.run(() => super.run(sql, ...params));\n  }\n\n  override get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined> {\n    return this.#queue.run(() => super.get<T>(sql, ...params));\n  }\n\n  override all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]> {\n    return this.#queue.run(() => super.all<T>(sql, ...params));\n  }\n\n  transaction<T>(callback: (transaction: SqliteExecutor) => Promise<T>): Promise<T> {\n    return this.#queue.run(async () => {\n      const transaction = new WasmSqliteTransaction(this.db, this.statements);\n      this.db.exec('BEGIN IMMEDIATE');\n      try {\n        const result = await callback(transaction);\n        this.db.exec('COMMIT');\n        return result;\n      } catch (error) {\n        this.#rollback(error);\n        throw error;\n      } finally {\n        transaction.active = false;\n      }\n    });\n  }\n\n  close(): Promise<void> {\n    return this.#queue.run(() => {\n      try {\n        this.statements.finalize();\n        this.db.close();\n      } finally {\n        this.#closed();\n      }\n    });\n  }\n\n  #rollback(cause: unknown): void {\n    try {\n      this.db.exec('ROLLBACK');\n    } catch (error) {\n      throw new AggregateError([cause, error], 'SQLite rollback failed');\n    }\n  }\n}\n\nexport interface OpfsSqliteOptions extends PoolAccess {\n  directory?: string;\n  file?: string;\n  load?: typeof init;\n}\n\nexport const AGENT_DIRECTORY = '/.slicc/agent';\n\nexport async function openMemorySqliteStorage(): Promise<Storage> {\n  const sqlite3 = await init();\n  return SqliteStorage.open(new WasmSqliteDatabase(new sqlite3.oo1.DB(':memory:', 'c')));\n}\n\nexport async function openOpfsSqliteStorage(options: OpfsSqliteOptions = {}): Promise<Storage> {\n  const directory = options.directory ?? AGENT_DIRECTORY;\n  const release = await holdLock(\n    options.locks ?? navigator.locks,\n    `slicc-agent-sqlite:${directory}`\n  );\n  try {\n    await settlePool(directory, options);\n    const sqlite3 = await (options.load ?? init)();\n    const pool = await sqlite3.installOpfsSAHPoolVfs({ name: vfsName(directory), directory });\n    const db = new pool.OpfsSAHPoolDb(options.file ?? '/agent.sqlite');\n    db.exec('PRAGMA journal_mode = TRUNCATE');\n    return await SqliteStorage.open(new WasmSqliteDatabase(db, release));\n  } catch (error) {\n    release();\n    throw error;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';
 export { type AgentClient, type AgentReply, type AgentRequest, connectAgent, type MessageEndpoint, serveAgent, } from './port.ts';
+export { AGENT_DIRECTORY, type OpfsSqliteOptions, openMemorySqliteStorage, openOpfsSqliteStorage, WasmSqliteDatabase, } from './sqlite.ts';

package/dist/types/opfs-pool.d.ts

@@ -0,0 +1,9 @@
+export interface PoolAccess {
+    root?: () => Promise<FileSystemDirectoryHandle>;
+    locks?: LockManager;
+    attempts?: number;
+    delayMs?: number;
+}
+export declare function vfsName(directory: string): string;
+export declare function holdLock(locks: LockManager, name: string): Promise<() => void>;
+export declare function settlePool(directory: string, access?: PoolAccess): Promise<void>;

package/dist/types/sqlite.d.ts

@@ -0,0 +1,39 @@
+import type { Storage } from '@earendil-works/pi-durable';
+import { type SqliteDatabase, type SqliteExecutor, type SqliteValue } from '@earendil-works/pi-durable/storage/sqlite';
+import init, { type Database, type PreparedStatement } from '@sqlite.org/sqlite-wasm';
+import { type PoolAccess } from './opfs-pool.ts';
+declare class Statements {
+    #private;
+    constructor(db: Database);
+    bound(sql: string, params: readonly SqliteValue[]): PreparedStatement;
+    finalize(): void;
+}
+declare class WasmSqliteExecutor implements SqliteExecutor {
+    protected readonly db: Database;
+    protected readonly statements: Statements;
+    constructor(db: Database, statements: Statements);
+    exec(sql: string): Promise<void>;
+    run(sql: string, ...params: SqliteValue[]): Promise<void>;
+    get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined>;
+    all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]>;
+    protected check(): void;
+}
+export declare class WasmSqliteDatabase extends WasmSqliteExecutor implements SqliteDatabase {
+    #private;
+    constructor(db: Database, closed?: () => void);
+    exec(sql: string): Promise<void>;
+    run(sql: string, ...params: SqliteValue[]): Promise<void>;
+    get<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T | undefined>;
+    all<T extends object>(sql: string, ...params: SqliteValue[]): Promise<T[]>;
+    transaction<T>(callback: (transaction: SqliteExecutor) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+export interface OpfsSqliteOptions extends PoolAccess {
+    directory?: string;
+    file?: string;
+    load?: typeof init;
+}
+export declare const AGENT_DIRECTORY = "/.slicc/agent";
+export declare function openMemorySqliteStorage(): Promise<Storage>;
+export declare function openOpfsSqliteStorage(options?: OpfsSqliteOptions): Promise<Storage>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",
@@ -59,6 +59,7 @@
   "dependencies": {
     "@earendil-works/chord": "1.0.4",
     "@earendil-works/pi-ai": "1.0.4",
-    "@earendil-works/pi-durable": "1.0.4"
+    "@earendil-works/pi-durable": "1.0.4",
+    "@sqlite.org/sqlite-wasm": "3.53.4-build2"
   }
 }