@drej/sqlite 0.2.0 → 0.3.0

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+import { CheckpointInfo, EnvironmentRecord, IStorageAdapter, LedgerEntry, ListSandboxOptions, SandboxDetails } from "@drej/core";
+
+//#region src/adapter.d.ts
+declare class SQLiteAdapter implements IStorageAdapter {
+  private readonly db;
+  constructor(path: string);
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  append(entry: LedgerEntry): Promise<void>;
+  readAll(name: string, sandboxId: string): Promise<LedgerEntry[]>;
+  lastCheckpoint(name: string, sandboxId: string): Promise<LedgerEntry | null>;
+  listSandboxDetails(name: string, opts?: ListSandboxOptions): Promise<SandboxDetails[]>;
+  listAllSandboxDetails(opts?: ListSandboxOptions): Promise<SandboxDetails[]>;
+  getSandboxDetails(name: string, sandboxId: string): Promise<SandboxDetails | null>;
+  deleteSandbox(name: string, sandboxId: string): Promise<void>;
+  listCheckpoints(name: string, sandboxId: string): Promise<CheckpointInfo[]>;
+  getEnvironment(name: string): Promise<EnvironmentRecord | null>;
+  saveEnvironment(record: EnvironmentRecord): Promise<void>;
+  deleteEnvironment(name: string): Promise<void>;
+  listEnvironments(): Promise<EnvironmentRecord[]>;
+}
+//#endregion
+export { SQLiteAdapter };

package/dist/index.mjs

@@ -0,0 +1,155 @@
+import { Database } from "bun:sqlite";
+import { SandboxStatus } from "@drej/core";
+//#region src/migrations.ts
+const MIGRATION_SQL = `
+CREATE TABLE IF NOT EXISTS drej_events (
+  id          INTEGER  PRIMARY KEY AUTOINCREMENT,
+  sandbox_id  TEXT     NOT NULL,
+  name        TEXT     NOT NULL,
+  step_idx    INTEGER  NOT NULL,
+  branch      INTEGER,
+  event       TEXT     NOT NULL,
+  payload     TEXT,
+  error       TEXT,
+  ts          INTEGER  NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS drej_events_sandbox_id ON drej_events(sandbox_id);
+CREATE INDEX IF NOT EXISTS drej_events_name ON drej_events(name);
+
+CREATE TABLE IF NOT EXISTS drej_environments (
+  name        TEXT    PRIMARY KEY,
+  snapshot_id TEXT    NOT NULL,
+  image       TEXT    NOT NULL,
+  built_at    INTEGER NOT NULL
+);
+`;
+//#endregion
+//#region src/adapter.ts
+const AGG_SQL = (whereClause) => `
+  WITH agg AS (
+    SELECT
+      name,
+      sandbox_id,
+      MIN(CASE WHEN event = 'sandbox_created' THEN ts END) AS started_at,
+      MAX(CASE WHEN event = 'sandbox_closed'  THEN ts END) AS completed_at,
+      MAX(CASE WHEN event = 'sandbox_closed'  THEN 1 ELSE 0 END) AS is_closed,
+      CAST(COUNT(CASE WHEN event = 'exec_complete' THEN 1 END) AS INTEGER) AS exec_count
+    FROM drej_events
+    ${whereClause}
+    GROUP BY name, sandbox_id
+  )
+  SELECT * FROM agg WHERE started_at IS NOT NULL ORDER BY started_at DESC
+`;
+function aggRowToDetails(row) {
+	return {
+		name: row.name,
+		sandboxId: row.sandbox_id,
+		status: row.is_closed ? SandboxStatus.Completed : SandboxStatus.Running,
+		startedAt: row.started_at,
+		completedAt: row.completed_at ?? void 0,
+		execCount: row.exec_count
+	};
+}
+function applyOpts(details, opts) {
+	let result = details;
+	if (opts?.before != null) result = result.filter((d) => d.startedAt < opts.before);
+	if (opts?.status != null) result = result.filter((d) => d.status === opts.status);
+	if (opts?.limit != null) result = result.slice(0, opts.limit);
+	return result;
+}
+function rowToEntry(row) {
+	return {
+		sandboxId: row.sandbox_id,
+		name: row.name,
+		stepIndex: row.step_idx,
+		branch: row.branch ?? void 0,
+		event: row.event,
+		payload: row.payload !== null ? JSON.parse(row.payload) : void 0,
+		error: row.error ?? void 0,
+		ts: row.ts
+	};
+}
+var SQLiteAdapter = class {
+	db;
+	constructor(path) {
+		this.db = new Database(path, { create: true });
+	}
+	async connect() {
+		this.db.exec(MIGRATION_SQL);
+		this.db.exec("PRAGMA journal_mode = WAL;");
+	}
+	async close() {
+		this.db.close();
+	}
+	async append(entry) {
+		this.db.prepare(`INSERT INTO drej_events (sandbox_id, name, step_idx, branch, event, payload, error, ts)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(entry.sandboxId, entry.name, entry.stepIndex, entry.branch ?? null, entry.event, entry.payload !== void 0 ? JSON.stringify(entry.payload) : null, entry.error ?? null, entry.ts);
+	}
+	async readAll(name, sandboxId) {
+		return this.db.prepare(`SELECT sandbox_id, name, step_idx, branch, event, payload, error, ts
+         FROM drej_events
+         WHERE name = ? AND sandbox_id = ?
+         ORDER BY ts ASC`).all(name, sandboxId).map(rowToEntry);
+	}
+	async lastCheckpoint(name, sandboxId) {
+		const row = this.db.prepare(`SELECT sandbox_id, name, step_idx, branch, event, payload, error, ts
+         FROM drej_events
+         WHERE name = ? AND sandbox_id = ? AND event = 'checkpoint_created'
+         ORDER BY ts DESC
+         LIMIT 1`).get(name, sandboxId);
+		return row ? rowToEntry(row) : null;
+	}
+	async listSandboxDetails(name, opts) {
+		return applyOpts(this.db.prepare(AGG_SQL("WHERE name = ?")).all(name).map(aggRowToDetails), opts);
+	}
+	async listAllSandboxDetails(opts) {
+		return applyOpts(this.db.prepare(AGG_SQL("")).all().map(aggRowToDetails), opts);
+	}
+	async getSandboxDetails(name, sandboxId) {
+		const row = this.db.prepare(AGG_SQL("WHERE name = ? AND sandbox_id = ?")).get(name, sandboxId);
+		return row ? aggRowToDetails(row) : null;
+	}
+	async deleteSandbox(name, sandboxId) {
+		this.db.prepare(`DELETE FROM drej_events WHERE name = ? AND sandbox_id = ?`).run(name, sandboxId);
+	}
+	async listCheckpoints(name, sandboxId) {
+		return this.db.prepare(`SELECT sandbox_id, name, step_idx, branch, event, payload, error, ts
+         FROM drej_events
+         WHERE name = ? AND sandbox_id = ? AND event = 'checkpoint_created'
+         ORDER BY ts ASC`).all(name, sandboxId).map((r) => {
+			const p = r.payload !== null ? JSON.parse(r.payload) : { snapshotId: "" };
+			return {
+				snapshotId: p.snapshotId,
+				tag: p.name,
+				createdAt: r.ts
+			};
+		});
+	}
+	async getEnvironment(name) {
+		const row = this.db.prepare("SELECT name, snapshot_id, image, built_at FROM drej_environments WHERE name = ?").get(name);
+		return row ? {
+			name: row.name,
+			snapshotId: row.snapshot_id,
+			image: row.image,
+			builtAt: row.built_at
+		} : null;
+	}
+	async saveEnvironment(record) {
+		this.db.prepare(`INSERT INTO drej_environments (name, snapshot_id, image, built_at) VALUES (?, ?, ?, ?)
+         ON CONFLICT(name) DO UPDATE SET snapshot_id = excluded.snapshot_id, image = excluded.image, built_at = excluded.built_at`).run(record.name, record.snapshotId, record.image, record.builtAt);
+	}
+	async deleteEnvironment(name) {
+		this.db.prepare("DELETE FROM drej_environments WHERE name = ?").run(name);
+	}
+	async listEnvironments() {
+		return this.db.prepare("SELECT name, snapshot_id, image, built_at FROM drej_environments ORDER BY built_at DESC").all().map((r) => ({
+			name: r.name,
+			snapshotId: r.snapshot_id,
+			image: r.image,
+			builtAt: r.built_at
+		}));
+	}
+};
+//#endregion
+export { SQLiteAdapter };

package/package.json

@@ -1,18 +1,31 @@
 {
   "name": "@drej/sqlite",
-  "version": "0.2.0",
+  "version": "0.3.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
-  "main": "./src/index.ts",
-  "dependencies": {
-    "@drej/core": "workspace:*"
-  },
   "scripts": {
+    "build": "tsdown",
     "test": "bun test"
   },
+  "dependencies": {
+    "@drej/core": "workspace:*"
+  },
   "devDependencies": {
     "bun-types": "1.3.14",
+    "tsdown": "0.22.3",
     "typescript": "6.0.3"
   }
 }

package/CHANGELOG.md

@@ -1,69 +0,0 @@
-# @drej/sqlite
-
-## 0.2.0
-
-### Minor Changes
-
-- 2fd33e0: feat: run management API
-
-  Add `RunStatus` enum, `RunDetails` type, and `ListRunsOptions` for filtering. Replace `listRuns()` with `listRunDetails()`, `listAllRunDetails()`, `getRunDetails()`, and `deleteRun()` on both `IStorageAdapter` and `DrejClient`. Add `WorkflowRun.status` property that tracks execution state as events are consumed.
-
-### Patch Changes
-
-- Updated dependencies [22b8a32]
-- Updated dependencies [799b6dd]
-- Updated dependencies [8d9d8bb]
-- Updated dependencies [2fd33e0]
-- Updated dependencies [0d94c2a]
-  - @drej/core@0.3.0
-
-## 0.1.2
-
-### Patch Changes
-
-- Updated dependencies [4c0ad93]
-- Updated dependencies [b04f8eb]
-- Updated dependencies [a971b7b]
-- Updated dependencies [ce173be]
-- Updated dependencies [86c2dde]
-- Updated dependencies [82094ae]
-  - @drej/core@0.2.0
-
-## 0.1.1
-
-### Patch Changes
-
-- 0ea4c33: Rename npm scope from `@drej/*` to `@drej/*` and add TSDoc to all public API surfaces.
-
-  - All workspace packages now published under `@drej/*` (e.g. `@drej/sqlite`, `@drej/postgres`)
-  - `DrejClient`, `WorkflowBuilder`, `SandboxStepBuilder`, `IStorageAdapter`, `LedgerEvent`, `SandboxOpts` and all their members now have hover documentation visible in VS Code
-
-- Updated dependencies [0ea4c33]
-  - @drej/core@0.1.1
-
-## 0.1.0
-
-### Minor Changes
-
-- 5d77498: Introduce `@drej/sqlite` storage adapter.
-
-  `SQLiteAdapter` implements `IStorageAdapter` via Bun's built-in `bun:sqlite` — zero extra dependencies and no infrastructure required. Data persists across restarts, making it suitable for local development and single-process production workloads.
-
-  ```ts
-  import { DrejClient } from "drej";
-  import { SQLiteAdapter } from "@drej/sqlite";
-
-  const client = new DrejClient({
-    baseUrl: "http://localhost:8080",
-    adapter: new SQLiteAdapter("./drej.db"),
-  });
-  await client.connect();
-  ```
-
-  WAL mode is enabled on `connect()` for safe concurrent reads alongside ongoing writes.
-
-### Patch Changes
-
-- Updated dependencies [82e77fd]
-- Updated dependencies [5d77498]
-  - @drej/core@0.1.0

package/src/adapter.ts

@@ -1,167 +0,0 @@
-import { Database } from "bun:sqlite";
-import type { IStorageAdapter, LedgerEntry, LedgerEvent, RunDetails, ListRunsOptions } from "@drej/core";
-import { RunStatus } from "@drej/core";
-import { MIGRATION_SQL } from "./migrations";
-
-type Row = {
-  run_id: string;
-  wf_name: string;
-  step_idx: number;
-  branch: number | null;
-  event: string;
-  payload: string | null;
-  error: string | null;
-  ts: number;
-};
-
-type AggRow = {
-  wf_name: string;
-  run_id: string;
-  started_at: number | null;
-  completed_at: number | null;
-  terminal_event: string | null;
-  error_msg: string | null;
-  step_count: number;
-};
-
-const AGG_SQL = (whereClause: string) => `
-  WITH agg AS (
-    SELECT
-      wf_name,
-      run_id,
-      MIN(CASE WHEN event = 'run_started' THEN ts END) AS started_at,
-      MAX(CASE WHEN event IN ('workflow_complete', 'workflow_failed') THEN ts END) AS completed_at,
-      MAX(CASE WHEN event IN ('workflow_complete', 'workflow_failed') THEN event END) AS terminal_event,
-      MAX(CASE WHEN event = 'workflow_failed' THEN error END) AS error_msg,
-      CAST(COUNT(CASE WHEN event = 'step_complete' THEN 1 END) AS INTEGER) AS step_count
-    FROM drej_events
-    ${whereClause}
-    GROUP BY wf_name, run_id
-  )
-  SELECT * FROM agg WHERE started_at IS NOT NULL ORDER BY started_at DESC
-`;
-
-function terminalToStatus(event: string | null): RunStatus {
-  if (event === "workflow_complete") return RunStatus.Completed;
-  if (event === "workflow_failed") return RunStatus.Failed;
-  return RunStatus.Running;
-}
-
-function aggRowToDetails(row: AggRow): RunDetails {
-  return {
-    workflowName: row.wf_name,
-    runId: row.run_id,
-    status: terminalToStatus(row.terminal_event),
-    startedAt: row.started_at!,
-    completedAt: row.completed_at ?? undefined,
-    stepCount: row.step_count,
-    error: row.error_msg ?? undefined,
-  };
-}
-
-function applyOpts(details: RunDetails[], opts?: ListRunsOptions): RunDetails[] {
-  let result = details;
-  if (opts?.before != null) result = result.filter((d) => d.startedAt < opts.before!);
-  if (opts?.status != null) result = result.filter((d) => d.status === opts.status);
-  if (opts?.limit != null) result = result.slice(0, opts.limit);
-  return result;
-}
-
-function rowToEntry(row: Row): LedgerEntry {
-  return {
-    runId: row.run_id,
-    workflowName: row.wf_name,
-    stepIndex: row.step_idx,
-    branch: row.branch ?? undefined,
-    event: row.event as LedgerEvent,
-    payload: row.payload !== null ? (JSON.parse(row.payload) as unknown) : undefined,
-    error: row.error ?? undefined,
-    ts: row.ts,
-  };
-}
-
-export class SQLiteAdapter implements IStorageAdapter {
-  private readonly db: Database;
-
-  constructor(path: string) {
-    this.db = new Database(path, { create: true });
-  }
-
-  async connect(): Promise<void> {
-    this.db.exec(MIGRATION_SQL);
-    // WAL mode prevents writer from blocking readers on concurrent access
-    this.db.exec("PRAGMA journal_mode = WAL;");
-  }
-
-  async close(): Promise<void> {
-    this.db.close();
-  }
-
-  async append(entry: LedgerEntry): Promise<void> {
-    this.db
-      .prepare(
-        `INSERT INTO drej_events (run_id, wf_name, step_idx, branch, event, payload, error, ts)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-      )
-      .run(
-        entry.runId,
-        entry.workflowName,
-        entry.stepIndex,
-        entry.branch ?? null,
-        entry.event,
-        entry.payload !== undefined ? JSON.stringify(entry.payload) : null,
-        entry.error ?? null,
-        entry.ts,
-      );
-  }
-
-  async readAll(workflowName: string, runId: string): Promise<LedgerEntry[]> {
-    const rows = this.db
-      .prepare<Row, [string, string]>(
-        `SELECT run_id, wf_name, step_idx, branch, event, payload, error, ts
-         FROM drej_events
-         WHERE wf_name = ? AND run_id = ?
-         ORDER BY ts ASC`,
-      )
-      .all(workflowName, runId);
-    return rows.map(rowToEntry);
-  }
-
-  async lastCheckpoint(workflowName: string, runId: string): Promise<LedgerEntry | null> {
-    const row = this.db
-      .prepare<Row, [string, string]>(
-        `SELECT run_id, wf_name, step_idx, branch, event, payload, error, ts
-         FROM drej_events
-         WHERE wf_name = ? AND run_id = ? AND event = 'checkpoint'
-         ORDER BY ts DESC
-         LIMIT 1`,
-      )
-      .get(workflowName, runId);
-    return row ? rowToEntry(row) : null;
-  }
-
-  async listRunDetails(workflowName: string, opts?: ListRunsOptions): Promise<RunDetails[]> {
-    const rows = this.db
-      .prepare<AggRow, [string]>(AGG_SQL("WHERE wf_name = ?"))
-      .all(workflowName);
-    return applyOpts(rows.map(aggRowToDetails), opts);
-  }
-
-  async listAllRunDetails(opts?: ListRunsOptions): Promise<RunDetails[]> {
-    const rows = this.db.prepare<AggRow, []>(AGG_SQL("")).all();
-    return applyOpts(rows.map(aggRowToDetails), opts);
-  }
-
-  async getRunDetails(workflowName: string, runId: string): Promise<RunDetails | null> {
-    const row = this.db
-      .prepare<AggRow, [string, string]>(AGG_SQL("WHERE wf_name = ? AND run_id = ?"))
-      .get(workflowName, runId);
-    return row ? aggRowToDetails(row) : null;
-  }
-
-  async deleteRun(workflowName: string, runId: string): Promise<void> {
-    this.db
-      .prepare<void, [string, string]>(`DELETE FROM drej_events WHERE wf_name = ? AND run_id = ?`)
-      .run(workflowName, runId);
-  }
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { SQLiteAdapter } from "./adapter";

package/src/migrations.ts

@@ -1,16 +0,0 @@
-export const MIGRATION_SQL = `
-CREATE TABLE IF NOT EXISTS drej_events (
-  id       INTEGER  PRIMARY KEY AUTOINCREMENT,
-  run_id   TEXT     NOT NULL,
-  wf_name  TEXT     NOT NULL,
-  step_idx INTEGER  NOT NULL,
-  branch   INTEGER,
-  event    TEXT     NOT NULL,
-  payload  TEXT,
-  error    TEXT,
-  ts       INTEGER  NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS drej_events_run_id ON drej_events(run_id);
-CREATE INDEX IF NOT EXISTS drej_events_wf_name ON drej_events(wf_name);
-`;

package/test/adapter.test.ts

@@ -1,189 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { LedgerEvent, RunStatus, type LedgerEntry } from "@drej/core";
-import { SQLiteAdapter } from "../src/adapter.ts";
-
-function entry(overrides?: Partial<LedgerEntry>): LedgerEntry {
-  return {
-    ts: Date.now(),
-    workflowName: "test-wf",
-    runId: "run-1",
-    stepIndex: 0,
-    event: LedgerEvent.StepStart,
-    ...overrides,
-  };
-}
-
-describe("SQLiteAdapter", () => {
-  let db: SQLiteAdapter;
-
-  beforeEach(async () => {
-    db = new SQLiteAdapter(":memory:");
-    await db.connect();
-  });
-
-  afterEach(async () => {
-    await db.close();
-  });
-
-  // ── append / readAll ────────────────────────────────────────────────────────
-
-  describe("append / readAll", () => {
-    it("stores and retrieves an entry", async () => {
-      await db.append(entry({ event: LedgerEvent.StepStart }));
-      const rows = await db.readAll("test-wf", "run-1");
-      expect(rows).toHaveLength(1);
-      expect(rows[0].event).toBe(LedgerEvent.StepStart);
-    });
-
-    it("returns entries in ascending timestamp order", async () => {
-      await db.append(entry({ ts: 2000, event: LedgerEvent.StepComplete }));
-      await db.append(entry({ ts: 1000, event: LedgerEvent.StepStart }));
-      const rows = await db.readAll("test-wf", "run-1");
-      expect(rows[0].ts).toBe(1000);
-      expect(rows[1].ts).toBe(2000);
-    });
-
-    it("scopes to the given workflow name and run id", async () => {
-      await db.append(entry({ workflowName: "wf-a", runId: "r1" }));
-      await db.append(entry({ workflowName: "wf-b", runId: "r2" }));
-      expect(await db.readAll("wf-a", "r1")).toHaveLength(1);
-      expect(await db.readAll("wf-b", "r2")).toHaveLength(1);
-      expect(await db.readAll("wf-a", "r2")).toHaveLength(0);
-    });
-
-    it("serialises and deserialises JSON payload", async () => {
-      await db.append(entry({ payload: { key: "value", n: 42 } }));
-      const rows = await db.readAll("test-wf", "run-1");
-      expect(rows[0].payload).toEqual({ key: "value", n: 42 });
-    });
-
-    it("preserves null payload as undefined", async () => {
-      await db.append(entry({ payload: undefined }));
-      const rows = await db.readAll("test-wf", "run-1");
-      expect(rows[0].payload).toBeUndefined();
-    });
-
-    it("preserves the branch field", async () => {
-      await db.append(entry({ branch: 2 }));
-      const rows = await db.readAll("test-wf", "run-1");
-      expect(rows[0].branch).toBe(2);
-    });
-
-    it("returns undefined branch when not set", async () => {
-      await db.append(entry());
-      const rows = await db.readAll("test-wf", "run-1");
-      expect(rows[0].branch).toBeUndefined();
-    });
-  });
-
-  // ── lastCheckpoint ──────────────────────────────────────────────────────────
-
-  describe("lastCheckpoint", () => {
-    it("returns null when no checkpoint exists", async () => {
-      expect(await db.lastCheckpoint("test-wf", "run-1")).toBeNull();
-    });
-
-    it("returns the most recent checkpoint", async () => {
-      await db.append(entry({ ts: 1000, event: LedgerEvent.Checkpoint, payload: { step: 1 } }));
-      await db.append(entry({ ts: 2000, event: LedgerEvent.Checkpoint, payload: { step: 2 } }));
-      const cp = await db.lastCheckpoint("test-wf", "run-1");
-      expect((cp!.payload as any).step).toBe(2);
-    });
-
-    it("ignores non-checkpoint events", async () => {
-      await db.append(entry({ event: LedgerEvent.StepStart }));
-      expect(await db.lastCheckpoint("test-wf", "run-1")).toBeNull();
-    });
-  });
-
-  // ── run details ─────────────────────────────────────────────────────────────
-
-  async function seedRun(wf: string, runId: string, terminal: LedgerEvent.WorkflowComplete | LedgerEvent.WorkflowFailed, error?: string) {
-    const ts = Date.now();
-    await db.append(entry({ workflowName: wf, runId, ts, stepIndex: -1, event: LedgerEvent.RunStarted }));
-    await db.append(entry({ workflowName: wf, runId, ts: ts + 1, stepIndex: 0, event: LedgerEvent.StepComplete }));
-    await db.append(entry({ workflowName: wf, runId, ts: ts + 2, stepIndex: -1, event: terminal, error }));
-  }
-
-  describe("getRunDetails", () => {
-    it("returns null for an unknown run", async () => {
-      expect(await db.getRunDetails("wf", "no-such-run")).toBeNull();
-    });
-
-    it("returns Completed status", async () => {
-      await seedRun("wf", "run-1", LedgerEvent.WorkflowComplete);
-      const d = await db.getRunDetails("wf", "run-1");
-      expect(d?.status).toBe(RunStatus.Completed);
-      expect(d?.stepCount).toBe(1);
-    });
-
-    it("returns Failed status with error message", async () => {
-      await seedRun("wf", "run-1", LedgerEvent.WorkflowFailed, "boom");
-      const d = await db.getRunDetails("wf", "run-1");
-      expect(d?.status).toBe(RunStatus.Failed);
-      expect(d?.error).toBe("boom");
-    });
-
-    it("returns Running when no terminal event present", async () => {
-      await db.append(entry({ stepIndex: -1, event: LedgerEvent.RunStarted }));
-      const d = await db.getRunDetails("test-wf", "run-1");
-      expect(d?.status).toBe(RunStatus.Running);
-    });
-  });
-
-  describe("listRunDetails", () => {
-    it("scopes to a single workflow", async () => {
-      await seedRun("wf-a", "r1", LedgerEvent.WorkflowComplete);
-      await seedRun("wf-b", "r2", LedgerEvent.WorkflowComplete);
-      const results = await db.listRunDetails("wf-a");
-      expect(results).toHaveLength(1);
-      expect(results[0].workflowName).toBe("wf-a");
-    });
-
-    it("filters by status", async () => {
-      await seedRun("wf", "r1", LedgerEvent.WorkflowComplete);
-      await seedRun("wf", "r2", LedgerEvent.WorkflowFailed);
-      const completed = await db.listRunDetails("wf", { status: RunStatus.Completed });
-      expect(completed).toHaveLength(1);
-      expect(completed[0].runId).toBe("r1");
-    });
-
-    it("respects the limit option", async () => {
-      await seedRun("wf", "r1", LedgerEvent.WorkflowComplete);
-      await seedRun("wf", "r2", LedgerEvent.WorkflowComplete);
-      expect(await db.listRunDetails("wf", { limit: 1 })).toHaveLength(1);
-    });
-  });
-
-  describe("listAllRunDetails", () => {
-    it("returns runs across all workflows", async () => {
-      await seedRun("wf-a", "r1", LedgerEvent.WorkflowComplete);
-      await seedRun("wf-b", "r2", LedgerEvent.WorkflowComplete);
-      expect(await db.listAllRunDetails()).toHaveLength(2);
-    });
-
-    it("filters by status across workflows", async () => {
-      await seedRun("wf-a", "r1", LedgerEvent.WorkflowComplete);
-      await seedRun("wf-b", "r2", LedgerEvent.WorkflowFailed);
-      const failed = await db.listAllRunDetails({ status: RunStatus.Failed });
-      expect(failed).toHaveLength(1);
-      expect(failed[0].workflowName).toBe("wf-b");
-    });
-  });
-
-  describe("deleteRun", () => {
-    it("removes all entries for the run", async () => {
-      await seedRun("wf", "run-1", LedgerEvent.WorkflowComplete);
-      await db.deleteRun("wf", "run-1");
-      expect(await db.readAll("wf", "run-1")).toHaveLength(0);
-      expect(await db.getRunDetails("wf", "run-1")).toBeNull();
-    });
-
-    it("does not affect other runs", async () => {
-      await seedRun("wf", "r1", LedgerEvent.WorkflowComplete);
-      await seedRun("wf", "r2", LedgerEvent.WorkflowComplete);
-      await db.deleteRun("wf", "r1");
-      expect(await db.getRunDetails("wf", "r2")).not.toBeNull();
-    });
-  });
-});

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "noEmit": true,
-    "skipLibCheck": true,
-    "allowImportingTsExtensions": true,
-    "types": ["bun-types"]
-  },
-  "include": ["src"]
-}