db4ai 0.2.0 → 0.3.1

package/dist/chunk-FUF4HJTC.js

@@ -0,0 +1,758 @@
+// cli/runtime/index.ts
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+function computeHash(obj) {
+  const sortedJson = stableStringify(obj);
+  return crypto.createHash("sha256").update(sortedJson).digest("hex").slice(0, 16);
+}
+function stableStringify(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(stableStringify).join(",") + "]";
+  }
+  const keys = Object.keys(obj).sort();
+  const pairs = keys.map(
+    (key) => JSON.stringify(key) + ":" + stableStringify(obj[key])
+  );
+  return "{" + pairs.join(",") + "}";
+}
+function ensureDirectoryExists(filePath) {
+  const dir = path.dirname(filePath);
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  } catch {
+  }
+}
+var ConnectionPool = class {
+  static instances = /* @__PURE__ */ new Map();
+  /**
+   * Acquire a database connection. Creates a new one or returns existing.
+   */
+  static acquire(dbPath) {
+    const normalizedPath = path.resolve(dbPath);
+    const existing = this.instances.get(normalizedPath);
+    if (existing) {
+      existing.refCount++;
+      return existing.db;
+    }
+    ensureDirectoryExists(normalizedPath);
+    let db;
+    try {
+      db = new Database(normalizedPath);
+    } catch {
+      db = new Database(":memory:");
+    }
+    try {
+      db.pragma("journal_mode = WAL");
+    } catch {
+    }
+    this.instances.set(normalizedPath, { db, refCount: 1 });
+    return db;
+  }
+  /**
+   * Release a database connection. Closes when ref count reaches 0.
+   */
+  static release(dbPath) {
+    const normalizedPath = path.resolve(dbPath);
+    const entry = this.instances.get(normalizedPath);
+    if (!entry) return;
+    entry.refCount--;
+    if (entry.refCount <= 0) {
+      entry.db.close();
+      this.instances.delete(normalizedPath);
+    }
+  }
+  /**
+   * Force close all connections (for testing cleanup).
+   */
+  static closeAll() {
+    for (const [path2, entry] of this.instances) {
+      entry.db.close();
+      this.instances.delete(path2);
+    }
+  }
+};
+var SCHEMA_VERSION = 2;
+var SCHEMA_SQL = `
+  -- Things table (entities)
+  CREATE TABLE IF NOT EXISTS things (
+    rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+    type TEXT NOT NULL,
+    id TEXT NOT NULL,
+    data TEXT NOT NULL,
+    content_hash TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    created_by_action INTEGER,
+    FOREIGN KEY (created_by_action) REFERENCES actions(rowid)
+  );
+
+  -- Indexes for things table
+  CREATE INDEX IF NOT EXISTS idx_things_type_id ON things(type, id);
+  CREATE INDEX IF NOT EXISTS idx_things_content_hash ON things(content_hash);
+  CREATE INDEX IF NOT EXISTS idx_things_type ON things(type);
+  -- Optimized index for latest version lookups (covering index)
+  CREATE INDEX IF NOT EXISTS idx_things_type_id_rowid ON things(type, id, rowid DESC);
+  -- Index for content hash deduplication queries
+  CREATE INDEX IF NOT EXISTS idx_things_type_id_hash ON things(type, id, content_hash);
+
+  -- Relationships table (edges)
+  CREATE TABLE IF NOT EXISTS relationships (
+    rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+    from_rowid INTEGER NOT NULL,
+    to_rowid INTEGER NOT NULL,
+    type TEXT NOT NULL,
+    path TEXT NOT NULL,
+    label TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    created_by_action INTEGER,
+    FOREIGN KEY (from_rowid) REFERENCES things(rowid),
+    FOREIGN KEY (to_rowid) REFERENCES things(rowid),
+    FOREIGN KEY (created_by_action) REFERENCES actions(rowid),
+    UNIQUE (from_rowid, to_rowid, path)
+  );
+
+  -- Indexes for relationships table
+  CREATE INDEX IF NOT EXISTS idx_relationships_from ON relationships(from_rowid);
+  CREATE INDEX IF NOT EXISTS idx_relationships_to ON relationships(to_rowid);
+  CREATE INDEX IF NOT EXISTS idx_relationships_type ON relationships(type);
+  -- Optimized composite index for filtered traversals
+  CREATE INDEX IF NOT EXISTS idx_relationships_from_type ON relationships(from_rowid, type);
+  CREATE INDEX IF NOT EXISTS idx_relationships_to_type ON relationships(to_rowid, type);
+
+  -- Actions table (for caching and tracking)
+  CREATE TABLE IF NOT EXISTS actions (
+    rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+    type TEXT NOT NULL,
+    input_hash TEXT NOT NULL,
+    input TEXT NOT NULL,
+    output TEXT,
+    model TEXT,
+    status TEXT NOT NULL DEFAULT 'pending',
+    error TEXT,
+    duration_ms INTEGER,
+    cost_tokens INTEGER,
+    created_at INTEGER NOT NULL
+  );
+
+  -- Indexes for actions table
+  CREATE INDEX IF NOT EXISTS idx_actions_input_hash ON actions(input_hash);
+  CREATE INDEX IF NOT EXISTS idx_actions_status ON actions(status);
+  -- Optimized composite index for cache lookups (input_hash + status)
+  CREATE INDEX IF NOT EXISTS idx_actions_hash_status ON actions(input_hash, status);
+
+  -- Events table (audit log)
+  CREATE TABLE IF NOT EXISTS events (
+    rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+    type TEXT NOT NULL,
+    action TEXT NOT NULL,
+    entity_type TEXT NOT NULL,
+    entity_id TEXT NOT NULL,
+    entity_rowid INTEGER NOT NULL,
+    data TEXT NOT NULL,
+    changes TEXT,
+    timestamp INTEGER NOT NULL,
+    action_id INTEGER,
+    correlation_id TEXT,
+    FOREIGN KEY (action_id) REFERENCES actions(rowid)
+  );
+
+  -- Indexes for events table
+  CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+  CREATE INDEX IF NOT EXISTS idx_events_action ON events(action);
+  CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+  CREATE INDEX IF NOT EXISTS idx_events_correlation_id ON events(correlation_id);
+  -- Optimized composite index for entity-based event lookups
+  CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity_type, entity_id);
+  -- Composite index for filtered event queries
+  CREATE INDEX IF NOT EXISTS idx_events_type_action ON events(type, action);
+
+  -- Schema version tracking
+  CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER NOT NULL
+  );
+`;
+var MIGRATION_V1_TO_V2 = `
+  -- Add new optimized indexes for version 2
+  CREATE INDEX IF NOT EXISTS idx_things_type_id_rowid ON things(type, id, rowid DESC);
+  CREATE INDEX IF NOT EXISTS idx_things_type_id_hash ON things(type, id, content_hash);
+  CREATE INDEX IF NOT EXISTS idx_relationships_from_type ON relationships(from_rowid, type);
+  CREATE INDEX IF NOT EXISTS idx_relationships_to_type ON relationships(to_rowid, type);
+  CREATE INDEX IF NOT EXISTS idx_actions_hash_status ON actions(input_hash, status);
+  CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity_type, entity_id);
+  CREATE INDEX IF NOT EXISTS idx_events_type_action ON events(type, action);
+`;
+var LocalDB = class {
+  db;
+  usePool;
+  path;
+  version = SCHEMA_VERSION;
+  things;
+  relationships;
+  actions;
+  events;
+  constructor(dbPath, options) {
+    this.path = dbPath || path.join(process.cwd(), ".db4", "local.db");
+    this.usePool = options?.usePool ?? false;
+    if (this.usePool) {
+      this.db = ConnectionPool.acquire(this.path);
+    } else {
+      ensureDirectoryExists(this.path);
+      try {
+        this.db = new Database(this.path);
+      } catch {
+        this.db = new Database(":memory:");
+      }
+      try {
+        this.db.pragma("journal_mode = WAL");
+      } catch {
+      }
+    }
+    this.initSchema();
+    this.things = new ThingsAPI(this.db);
+    this.relationships = new RelationshipsAPI(this.db);
+    this.actions = new ActionsAPI(this.db);
+    this.events = new EventsAPI(this.db);
+  }
+  initSchema() {
+    const tableCheck = this.db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'`).get();
+    if (!tableCheck) {
+      this.db.exec(SCHEMA_SQL);
+      this.db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(SCHEMA_VERSION);
+    } else {
+      this.runMigrations();
+    }
+  }
+  /**
+   * Run any pending database migrations.
+   */
+  runMigrations() {
+    const row = this.db.prepare("SELECT version FROM schema_version LIMIT 1").get();
+    const currentVersion = row?.version ?? 1;
+    if (currentVersion < SCHEMA_VERSION) {
+      if (currentVersion < 2) {
+        this.db.exec(MIGRATION_V1_TO_V2);
+      }
+      this.db.prepare("UPDATE schema_version SET version = ?").run(SCHEMA_VERSION);
+    }
+  }
+  /**
+   * Closes the database connection.
+   */
+  close() {
+    if (this.usePool) {
+      ConnectionPool.release(this.path);
+    } else {
+      this.db.close();
+    }
+  }
+  /**
+   * Runs VACUUM to reclaim disk space.
+   */
+  vacuum() {
+    this.db.exec("VACUUM");
+    return Promise.resolve();
+  }
+};
+var ThingsAPI = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Upsert a thing. Returns existing rowid if content_hash matches,
+   * otherwise creates a new version.
+   */
+  async upsert(params) {
+    const { type, id, data, created_by_action } = params;
+    const dataJson = JSON.stringify(data);
+    const content_hash = computeHash({ type, id, data });
+    const created_at = Date.now();
+    const existing = this.db.prepare("SELECT rowid FROM things WHERE type = ? AND id = ? AND content_hash = ?").get(type, id, content_hash);
+    if (existing) {
+      return { rowid: existing.rowid, created: false };
+    }
+    const result = this.db.prepare(
+      `INSERT INTO things (type, id, data, content_hash, created_at, created_by_action)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(type, id, dataJson, content_hash, created_at, created_by_action || null);
+    return { rowid: result.lastInsertRowid, created: true };
+  }
+  /**
+   * Get the latest version of a thing by type and id.
+   */
+  async get(params) {
+    const { type, id } = params;
+    const row = this.db.prepare(
+      `SELECT rowid, type, id, data, content_hash, created_at, created_by_action
+         FROM things
+         WHERE type = ? AND id = ?
+         ORDER BY rowid DESC
+         LIMIT 1`
+    ).get(type, id);
+    if (!row) return null;
+    return {
+      rowid: row.rowid,
+      type: row.type,
+      id: row.id,
+      data: JSON.parse(row.data),
+      content_hash: row.content_hash,
+      created_at: row.created_at,
+      created_by_action: row.created_by_action ?? void 0
+    };
+  }
+  /**
+   * Get a specific version by rowid.
+   */
+  async getByRowid(rowid) {
+    const row = this.db.prepare(
+      `SELECT rowid, type, id, data, content_hash, created_at, created_by_action
+         FROM things
+         WHERE rowid = ?`
+    ).get(rowid);
+    if (!row) return null;
+    return {
+      rowid: row.rowid,
+      type: row.type,
+      id: row.id,
+      data: JSON.parse(row.data),
+      content_hash: row.content_hash,
+      created_at: row.created_at,
+      created_by_action: row.created_by_action ?? void 0
+    };
+  }
+  /**
+   * List things with optional filters.
+   */
+  async list(params = {}) {
+    const { type, limit, offset, where, order = "asc" } = params;
+    let sql = `
+      SELECT t.rowid, t.type, t.id, t.data, t.content_hash, t.created_at, t.created_by_action
+      FROM things t
+      INNER JOIN (
+        SELECT type, id, MAX(rowid) as max_rowid
+        FROM things
+        ${type ? "WHERE type = ?" : ""}
+        GROUP BY type, id
+      ) latest ON t.rowid = latest.max_rowid
+    `;
+    const queryParams = [];
+    if (type) {
+      queryParams.push(type);
+    }
+    if (where && Object.keys(where).length > 0) {
+      const whereConditions = Object.keys(where).map((key) => {
+        const value = where[key];
+        queryParams.push(value);
+        return `json_extract(t.data, '$.${key}') = ?`;
+      });
+      sql += ` WHERE ${whereConditions.join(" AND ")}`;
+    }
+    sql += ` ORDER BY t.rowid ${order === "desc" ? "DESC" : "ASC"}`;
+    if (limit !== void 0) {
+      sql += ` LIMIT ?`;
+      queryParams.push(limit);
+    }
+    if (offset !== void 0) {
+      sql += ` OFFSET ?`;
+      queryParams.push(offset);
+    }
+    const rows = this.db.prepare(sql).all(...queryParams);
+    return rows.map((row) => ({
+      rowid: row.rowid,
+      type: row.type,
+      id: row.id,
+      data: JSON.parse(row.data),
+      content_hash: row.content_hash,
+      created_at: row.created_at,
+      created_by_action: row.created_by_action ?? void 0
+    }));
+  }
+  /**
+   * Delete a thing by rowid.
+   */
+  async delete(rowid) {
+    this.db.prepare("DELETE FROM things WHERE rowid = ?").run(rowid);
+  }
+};
+var RelationshipsAPI = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create or update a relationship edge.
+   * If (from_rowid, to_rowid, path) already exists, updates it.
+   */
+  async create(params) {
+    const { from_rowid, to_rowid, type, path: path2, label, created_by_action } = params;
+    const created_at = Date.now();
+    const existing = this.db.prepare(
+      `SELECT rowid FROM relationships
+         WHERE from_rowid = ? AND to_rowid = ? AND path = ?`
+    ).get(from_rowid, to_rowid, path2);
+    if (existing) {
+      this.db.prepare(
+        `UPDATE relationships
+         SET type = ?, label = ?, created_by_action = ?
+         WHERE rowid = ?`
+      ).run(type, label, created_by_action || null, existing.rowid);
+      const row = this.db.prepare(
+        `SELECT rowid, from_rowid, to_rowid, type, path, label, created_at, created_by_action
+           FROM relationships WHERE rowid = ?`
+      ).get(existing.rowid);
+      return {
+        rowid: row.rowid,
+        from_rowid: row.from_rowid,
+        to_rowid: row.to_rowid,
+        type: row.type,
+        path: row.path,
+        label: row.label,
+        created_at: row.created_at,
+        created_by_action: row.created_by_action ?? void 0
+      };
+    }
+    const result = this.db.prepare(
+      `INSERT INTO relationships (from_rowid, to_rowid, type, path, label, created_at, created_by_action)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(from_rowid, to_rowid, type, path2, label, created_at, created_by_action || null);
+    return {
+      rowid: result.lastInsertRowid,
+      from_rowid,
+      to_rowid,
+      type,
+      path: path2,
+      label,
+      created_at,
+      created_by_action
+    };
+  }
+  /**
+   * List all relationships.
+   */
+  async list() {
+    const rows = this.db.prepare(
+      `SELECT rowid, from_rowid, to_rowid, type, path, label, created_at, created_by_action
+         FROM relationships`
+    ).all();
+    return rows.map((row) => ({
+      rowid: row.rowid,
+      from_rowid: row.from_rowid,
+      to_rowid: row.to_rowid,
+      type: row.type,
+      path: row.path,
+      label: row.label,
+      created_at: row.created_at,
+      created_by_action: row.created_by_action ?? void 0
+    }));
+  }
+  /**
+   * Traverse forward from an entity.
+   */
+  async traverse(params) {
+    const { from_rowid, type } = params;
+    let sql = `
+      SELECT rowid, from_rowid, to_rowid, type, path, label, created_at, created_by_action
+      FROM relationships
+      WHERE from_rowid = ?
+    `;
+    const queryParams = [from_rowid];
+    if (type) {
+      sql += " AND type = ?";
+      queryParams.push(type);
+    }
+    const rows = this.db.prepare(sql).all(...queryParams);
+    return rows.map((row) => ({
+      rowid: row.rowid,
+      from_rowid: row.from_rowid,
+      to_rowid: row.to_rowid,
+      type: row.type,
+      path: row.path,
+      label: row.label,
+      created_at: row.created_at,
+      created_by_action: row.created_by_action ?? void 0
+    }));
+  }
+  /**
+   * Find incoming edges to an entity.
+   */
+  async incoming(params) {
+    const { to_rowid, type } = params;
+    let sql = `
+      SELECT rowid, from_rowid, to_rowid, type, path, label, created_at, created_by_action
+      FROM relationships
+      WHERE to_rowid = ?
+    `;
+    const queryParams = [to_rowid];
+    if (type) {
+      sql += " AND type = ?";
+      queryParams.push(type);
+    }
+    const rows = this.db.prepare(sql).all(...queryParams);
+    return rows.map((row) => ({
+      rowid: row.rowid,
+      from_rowid: row.from_rowid,
+      to_rowid: row.to_rowid,
+      type: row.type,
+      path: row.path,
+      label: row.label,
+      created_at: row.created_at,
+      created_by_action: row.created_by_action ?? void 0
+    }));
+  }
+  /**
+   * Traverse multiple hops from an entity (BFS).
+   */
+  async traverseMultiHop(params) {
+    const { from_rowid, depth, type } = params;
+    const visited = /* @__PURE__ */ new Set([from_rowid]);
+    const results = [];
+    let currentLevel = [from_rowid];
+    for (let d = 1; d <= depth && currentLevel.length > 0; d++) {
+      const nextLevel = [];
+      for (const nodeId of currentLevel) {
+        const edges = await this.traverse({ from_rowid: nodeId, type });
+        for (const edge of edges) {
+          if (!visited.has(edge.to_rowid)) {
+            visited.add(edge.to_rowid);
+            results.push({ to_rowid: edge.to_rowid, depth: d });
+            nextLevel.push(edge.to_rowid);
+          }
+        }
+      }
+      currentLevel = nextLevel;
+    }
+    return results;
+  }
+};
+var ActionsAPI = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create a new action in pending status.
+   */
+  async create(params) {
+    const { type, input, model } = params;
+    const inputJson = JSON.stringify(input);
+    const input_hash = computeHash(input);
+    const created_at = Date.now();
+    const result = this.db.prepare(
+      `INSERT INTO actions (type, input_hash, input, model, status, created_at)
+         VALUES (?, ?, ?, ?, 'pending', ?)`
+    ).run(type, input_hash, inputJson, model || null, created_at);
+    return {
+      rowid: result.lastInsertRowid,
+      type,
+      input_hash,
+      input,
+      model,
+      status: "pending",
+      created_at
+    };
+  }
+  /**
+   * Find a completed action by input hash (cache lookup).
+   * Only returns actions with status='complete'.
+   */
+  async findByHash(input_hash) {
+    const row = this.db.prepare(
+      `SELECT rowid, type, input_hash, input, output, model, status, error, duration_ms, cost_tokens, created_at
+         FROM actions
+         WHERE input_hash = ? AND status = 'complete'
+         ORDER BY rowid DESC
+         LIMIT 1`
+    ).get(input_hash);
+    if (!row) return null;
+    return {
+      rowid: row.rowid,
+      type: row.type,
+      input_hash: row.input_hash,
+      input: JSON.parse(row.input),
+      output: row.output ? JSON.parse(row.output) : void 0,
+      model: row.model ?? void 0,
+      status: row.status,
+      error: row.error ?? void 0,
+      duration_ms: row.duration_ms ?? void 0,
+      cost_tokens: row.cost_tokens ?? void 0,
+      created_at: row.created_at
+    };
+  }
+  /**
+   * Complete an action with output.
+   */
+  async complete(params) {
+    const { rowid, output, duration_ms, cost_tokens } = params;
+    const outputJson = JSON.stringify(output);
+    const existing = this.db.prepare("SELECT status FROM actions WHERE rowid = ?").get(rowid);
+    if (!existing) {
+      throw new Error(`Action with rowid ${rowid} not found`);
+    }
+    if (existing.status !== "pending") {
+      throw new Error(`Cannot complete action with status '${existing.status}'`);
+    }
+    this.db.prepare(
+      `UPDATE actions
+         SET status = 'complete', output = ?, duration_ms = ?, cost_tokens = ?
+         WHERE rowid = ?`
+    ).run(outputJson, duration_ms || null, cost_tokens || null, rowid);
+    const row = this.db.prepare(
+      `SELECT rowid, type, input_hash, input, output, model, status, error, duration_ms, cost_tokens, created_at
+         FROM actions WHERE rowid = ?`
+    ).get(rowid);
+    return {
+      rowid: row.rowid,
+      type: row.type,
+      input_hash: row.input_hash,
+      input: JSON.parse(row.input),
+      output: row.output ? JSON.parse(row.output) : void 0,
+      model: row.model ?? void 0,
+      status: row.status,
+      error: row.error ?? void 0,
+      duration_ms: row.duration_ms ?? void 0,
+      cost_tokens: row.cost_tokens ?? void 0,
+      created_at: row.created_at
+    };
+  }
+  /**
+   * Mark an action as failed.
+   */
+  async fail(params) {
+    const { rowid, error } = params;
+    const existing = this.db.prepare("SELECT status FROM actions WHERE rowid = ?").get(rowid);
+    if (!existing) {
+      throw new Error(`Action with rowid ${rowid} not found`);
+    }
+    if (existing.status !== "pending") {
+      throw new Error(`Cannot fail action with status '${existing.status}'`);
+    }
+    this.db.prepare(`UPDATE actions SET status = 'error', error = ? WHERE rowid = ?`).run(error, rowid);
+    const row = this.db.prepare(
+      `SELECT rowid, type, input_hash, input, output, model, status, error, duration_ms, cost_tokens, created_at
+         FROM actions WHERE rowid = ?`
+    ).get(rowid);
+    return {
+      rowid: row.rowid,
+      type: row.type,
+      input_hash: row.input_hash,
+      input: JSON.parse(row.input),
+      output: row.output ? JSON.parse(row.output) : void 0,
+      model: row.model ?? void 0,
+      status: row.status,
+      error: row.error ?? void 0,
+      duration_ms: row.duration_ms ?? void 0,
+      cost_tokens: row.cost_tokens ?? void 0,
+      created_at: row.created_at
+    };
+  }
+};
+var EventsAPI = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Emit an event.
+   */
+  async emit(params) {
+    const {
+      type,
+      action,
+      entity_type,
+      entity_id,
+      entity_rowid,
+      data,
+      changes,
+      action_id,
+      correlation_id
+    } = params;
+    const timestamp = Date.now();
+    const dataJson = JSON.stringify(data);
+    const changesJson = changes ? JSON.stringify(changes) : null;
+    const result = this.db.prepare(
+      `INSERT INTO events (type, action, entity_type, entity_id, entity_rowid, data, changes, timestamp, action_id, correlation_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      type,
+      action,
+      entity_type,
+      entity_id,
+      entity_rowid,
+      dataJson,
+      changesJson,
+      timestamp,
+      action_id || null,
+      correlation_id || null
+    );
+    return {
+      rowid: result.lastInsertRowid,
+      type,
+      action,
+      entity_type,
+      entity_id,
+      entity_rowid,
+      data,
+      changes,
+      timestamp,
+      action_id,
+      correlation_id
+    };
+  }
+  /**
+   * List events with optional filters.
+   */
+  async list(params = {}) {
+    const { type, action, since, correlation_id, limit } = params;
+    let sql = `
+      SELECT rowid, type, action, entity_type, entity_id, entity_rowid, data, changes, timestamp, action_id, correlation_id
+      FROM events
+      WHERE 1=1
+    `;
+    const queryParams = [];
+    if (type) {
+      sql += " AND type = ?";
+      queryParams.push(type);
+    }
+    if (action) {
+      sql += " AND action = ?";
+      queryParams.push(action);
+    }
+    if (since !== void 0) {
+      sql += " AND timestamp > ?";
+      queryParams.push(since);
+    }
+    if (correlation_id) {
+      sql += " AND correlation_id = ?";
+      queryParams.push(correlation_id);
+    }
+    sql += " ORDER BY timestamp ASC";
+    if (limit !== void 0) {
+      sql += " LIMIT ?";
+      queryParams.push(limit);
+    }
+    const rows = this.db.prepare(sql).all(...queryParams);
+    return rows.map((row) => ({
+      rowid: row.rowid,
+      type: row.type,
+      action: row.action,
+      entity_type: row.entity_type,
+      entity_id: row.entity_id,
+      entity_rowid: row.entity_rowid,
+      data: JSON.parse(row.data),
+      changes: row.changes ? JSON.parse(row.changes) : void 0,
+      timestamp: row.timestamp,
+      action_id: row.action_id ?? void 0,
+      correlation_id: row.correlation_id ?? void 0
+    }));
+  }
+};
+var runtime_default = LocalDB;
+
+export {
+  ConnectionPool,
+  LocalDB,
+  runtime_default
+};
+//# sourceMappingURL=chunk-FUF4HJTC.js.map