@smithers-orchestrator/db 0.16.8 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/db",
-  "version": "0.16.8",
+  "version": "0.17.0",
   "description": "SQLite and Drizzle persistence adapter for Smithers workflows",
   "type": "module",
   "sideEffects": false,
@@ -24,12 +24,14 @@
     "@effect/sql": "^0.51.0",
     "drizzle-orm": "^0.45.2",
     "drizzle-zod": "^0.8.3",
+    "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/errors": "0.16.8",
-    "@smithers-orchestrator/graph": "0.16.8",
-    "@smithers-orchestrator/driver": "0.16.8",
-    "@smithers-orchestrator/scheduler": "0.16.8",
-    "@smithers-orchestrator/observability": "0.16.8"
+    "@smithers-orchestrator/errors": "0.17.0",
+    "@smithers-orchestrator/graph": "0.17.0",
+    "@smithers-orchestrator/memory": "0.17.0",
+    "@smithers-orchestrator/scorers": "0.17.0",
+    "@smithers-orchestrator/observability": "0.17.0",
+    "@smithers-orchestrator/scheduler": "0.17.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/SqlMessageStorage.js

@@ -34,8 +34,6 @@ const CREATE_TABLE_STATEMENTS = [
     error_json TEXT,
     config_json TEXT
   )`,
-    `CREATE INDEX IF NOT EXISTS _smithers_runs_status_heartbeat_idx
-    ON _smithers_runs (status, heartbeat_at_ms)`,
     `CREATE TABLE IF NOT EXISTS _smithers_nodes (
     run_id TEXT NOT NULL,
     node_id TEXT NOT NULL,
@@ -143,8 +141,6 @@ const CREATE_TABLE_STATEMENTS = [
     received_by TEXT,
     PRIMARY KEY (run_id, seq)
   )`,
-    `CREATE INDEX IF NOT EXISTS _smithers_signals_lookup_idx
-    ON _smithers_signals (run_id, signal_name, correlation_id, received_at_ms)`,
     `CREATE TABLE IF NOT EXISTS _smithers_cache (
     cache_key TEXT PRIMARY KEY,
     created_at_ms INTEGER NOT NULL,
@@ -177,8 +173,6 @@ const CREATE_TABLE_STATEMENTS = [
     result TEXT NOT NULL,
     duration_ms INTEGER
   )`,
-    `CREATE INDEX IF NOT EXISTS _smithers_time_travel_audit_lookup_idx
-    ON _smithers_time_travel_audit (run_id, caller, timestamp_ms)`,
     `CREATE TABLE IF NOT EXISTS _smithers_sandboxes (
     run_id TEXT NOT NULL,
     sandbox_id TEXT NOT NULL,
@@ -322,6 +316,14 @@ const CREATE_TABLE_STATEMENTS = [
     created_at_ms INTEGER NOT NULL
   )`,
 ];
+const CREATE_INDEX_STATEMENTS = [
+    `CREATE INDEX IF NOT EXISTS _smithers_runs_status_heartbeat_idx
+    ON _smithers_runs (status, heartbeat_at_ms)`,
+    `CREATE INDEX IF NOT EXISTS _smithers_signals_lookup_idx
+    ON _smithers_signals (run_id, signal_name, correlation_id, received_at_ms)`,
+    `CREATE INDEX IF NOT EXISTS _smithers_time_travel_audit_lookup_idx
+    ON _smithers_time_travel_audit (run_id, caller, timestamp_ms)`,
+];
 const MIGRATION_STATEMENTS = [
     `ALTER TABLE _smithers_attempts ADD COLUMN response_text TEXT`,
     `ALTER TABLE _smithers_attempts ADD COLUMN jj_cwd TEXT`,
@@ -643,6 +645,9 @@ export class SqlMessageStorage {
                     // Ignore if another caller added it first.
                 }
             }
+            for (const statement of CREATE_INDEX_STATEMENTS) {
+                sqlite.run(statement);
+            }
         });
     }
     /**

package/src/adapter/SmithersDb.js

@@ -2,7 +2,7 @@ import { getTableName, sql } from "drizzle-orm";
 import { Effect, Exit, FiberId, Metric } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { getSqlMessageStorage } from "../sql-message-storage.js";
-import { alertsAcknowledgedTotal, alertsFiredTotal, dbQueryDuration, dbTransactionDuration, dbTransactionRetries, dbTransactionRollbacks, } from "@smithers-orchestrator/observability/metrics";
+import { alertsAcknowledgedTotal, alertsFiredTotal, dbQueryDuration, dbTransactionDuration, dbTransactionRollbacks, } from "@smithers-orchestrator/observability/metrics";
 import { assertOptionalStringMaxLength, assertPositiveFiniteNumber, } from "../input-bounds.js";
 import { FRAME_KEYFRAME_INTERVAL, applyFrameDeltaJson, encodeFrameDelta, normalizeFrameEncoding, serializeFrameDelta, } from "../frame-codec.js";
 import { getKeyColumns } from "../output.js";
@@ -64,7 +64,6 @@ import { alertsActive } from "@smithers-orchestrator/observability/metrics";
 
 
 const FRAME_XML_CACHE_MAX = 512;
-const RUN_HEARTBEAT_STALE_MS = 30_000;
 const RAW_QUERY_ALLOWED_PREFIX = /^(?:select|with|explain|values)\b/i;
 const RAW_QUERY_FORBIDDEN_KEYWORDS = /\b(?:drop|delete|insert|update|alter|create|attach|detach|pragma)\b/i;
 const ACTIVE_ALERT_STATUSES = new Set([
@@ -337,6 +336,73 @@ function runnableEffect(effect) {
     }
     return runnable;
 }
+/**
+ * @typedef {{ depth: number; ownerThread: string | null; tail: Promise<unknown> }} SqliteTransactionState
+ */
+/** @type {WeakMap<object, SqliteTransactionState>} */
+// Cross-adapter coordination: one sqlite connection cannot run overlapping BEGIN IMMEDIATE statements.
+const sqliteTransactionStateByClient = (() => {
+    const key = Symbol.for("smithers.sqliteTransactionStateByClient");
+    const registry = /** @type {Record<PropertyKey, unknown>} */ (globalThis);
+    const existing = registry[key];
+    if (existing instanceof WeakMap) {
+        return /** @type {WeakMap<object, SqliteTransactionState>} */ (existing);
+    }
+    const stateByClient = new WeakMap();
+    Object.defineProperty(globalThis, key, {
+        configurable: false,
+        enumerable: false,
+        value: stateByClient,
+    });
+    return stateByClient;
+})();
+/**
+ * @param {unknown} client
+ * @returns {object}
+ */
+function assertSqliteClientKey(client) {
+    if ((typeof client !== "object" && typeof client !== "function") ||
+        client === null) {
+        throw new Error("SmithersDb requires an object sqlite client for transaction coordination.");
+    }
+    return /** @type {object} */ (client);
+}
+/**
+ * @param {unknown} db
+ * @returns {object}
+ */
+function resolveSqliteClientKey(db) {
+    const source = /** @type {{ session?: { client?: unknown }; $client?: unknown }} */ (db);
+    return assertSqliteClientKey(source?.session?.client ?? source?.$client ?? db);
+}
+/**
+ * @param {unknown} client
+ * @returns {SqliteTransactionState}
+ */
+function getSqliteTransactionState(client) {
+    const key = assertSqliteClientKey(client);
+    let state = sqliteTransactionStateByClient.get(key);
+    if (!state) {
+        state = {
+            depth: 0,
+            ownerThread: null,
+            tail: Promise.resolve(),
+        };
+        sqliteTransactionStateByClient.set(key, state);
+    }
+    return state;
+}
+/**
+ * @param {unknown} db
+ * @returns {{ run: (sql: string) => unknown; query: (sql: string) => { run: (...args: unknown[]) => unknown; get: (...args: unknown[]) => Record<string, unknown> | null | undefined; all: () => Array<Record<string, unknown>> }; exec: (sql: string) => unknown; $client?: unknown }}
+ */
+function resolveSqliteTransactionClient(db) {
+    const candidate = /** @type {{ run?: unknown; query?: unknown; exec?: unknown; $client?: unknown }} */ (resolveSqliteClientKey(db));
+    if (typeof candidate.run !== "function") {
+        throw new Error("SmithersDb.withTransaction requires Bun SQLite client transaction primitives.");
+    }
+    return /** @type {{ run: (sql: string) => unknown; query: (sql: string) => { run: (...args: unknown[]) => unknown; get: (...args: unknown[]) => Record<string, unknown> | null | undefined; all: () => Array<Record<string, unknown>> }; exec: (sql: string) => unknown; $client?: unknown }} */ (candidate);
+}
 export class SmithersDb {
     /** @type {BunSQLiteDatabase<Record<string, unknown>>} */
     db;
@@ -433,8 +499,12 @@ export class SmithersDb {
    * @returns {boolean}
    */
     ownsActiveTransaction(currentFiberThread) {
-        return (this.transactionDepth > 0 &&
-            this.transactionOwnerThread === currentFiberThread);
+        const state = getSqliteTransactionState(resolveSqliteClientKey(this.db));
+        this.transactionDepth = state.depth;
+        this.transactionOwnerThread = state.ownerThread;
+        this.transactionTail = state.tail;
+        return (state.depth > 0 &&
+            state.ownerThread === currentFiberThread);
     }
     /**
    * @template A
@@ -508,11 +578,7 @@ export class SmithersDb {
     getSqliteTransactionClient() {
         return Effect.try({
             try: () => {
-                const candidate = this.db.session?.client ?? this.db.$client;
-                if (!candidate || typeof candidate.run !== "function") {
-                    throw new Error("SmithersDb.withTransaction requires Bun SQLite client transaction primitives.");
-                }
-                return candidate;
+                return resolveSqliteTransactionClient(this.db);
             },
             catch: (cause) => toSmithersError(cause, "resolve sqlite transaction client", {
                 code: "DB_WRITE_FAILED",
@@ -526,12 +592,14 @@ export class SmithersDb {
     acquireTransactionTurn() {
         return Effect.tryPromise({
             try: async () => {
+                const state = getSqliteTransactionState(resolveSqliteClientKey(this.db));
                 let release;
                 const gate = new Promise((resolve) => {
                     release = resolve;
                 });
-                const previous = this.transactionTail.catch(() => undefined);
-                this.transactionTail = previous.then(() => gate);
+                const previous = state.tail.catch(() => undefined);
+                state.tail = previous.then(() => gate);
+                this.transactionTail = state.tail;
                 await previous;
                 return release;
             },
@@ -560,6 +628,7 @@ export class SmithersDb {
                 }));
             }
             const releaseTurn = yield* self.acquireTransactionTurn();
+            const transactionState = getSqliteTransactionState(resolveSqliteClientKey(self.db));
             const start = performance.now();
             return yield* Effect.gen(function* () {
                 const client = yield* self.getSqliteTransactionClient();
@@ -586,8 +655,11 @@ export class SmithersDb {
                 yield* Effect.try({
                     try: () => {
                         client.run("BEGIN IMMEDIATE");
-                        self.transactionDepth += 1;
-                        self.transactionOwnerThread = currentFiberThread;
+                        transactionState.depth += 1;
+                        transactionState.ownerThread = currentFiberThread;
+                        self.transactionDepth = transactionState.depth;
+                        self.transactionOwnerThread = transactionState.ownerThread;
+                        self.transactionTail = transactionState.tail;
                     },
                     catch: (cause) => toSmithersError(cause, "begin sqlite transaction", {
                         code: "DB_WRITE_FAILED",
@@ -614,10 +686,13 @@ export class SmithersDb {
                 }
                 return operationExit.value;
             }).pipe(Effect.ensuring(Effect.gen(function* () {
-                self.transactionDepth = Math.max(0, self.transactionDepth - 1);
-                if (self.transactionDepth === 0) {
-                    self.transactionOwnerThread = null;
+                transactionState.depth = Math.max(0, transactionState.depth - 1);
+                if (transactionState.depth === 0) {
+                    transactionState.ownerThread = null;
                 }
+                self.transactionDepth = transactionState.depth;
+                self.transactionOwnerThread = transactionState.ownerThread;
+                self.transactionTail = transactionState.tail;
                 yield* Metric.update(dbTransactionDuration, performance.now() - start);
             }))).pipe(Effect.ensuring(Effect.sync(() => {
                 releaseTurn();
@@ -1577,10 +1652,10 @@ export class SmithersDb {
             if (existing?.seq !== undefined) {
                 return existing.seq;
             }
-            const client = self.db.$client;
-            if (!client ||
-                typeof client.exec !== "function" ||
-                typeof client.query !== "function") {
+            const client = /** @type {{ exec?: unknown; query?: unknown; run?: unknown }} */ (resolveSqliteClientKey(self.db));
+            if (typeof client.exec !== "function" ||
+                typeof client.query !== "function" ||
+                typeof client.run !== "function") {
                 const lastSeq = (yield* self.getLastSignalSeq(row.runId)) ?? -1;
                 const seq = lastSeq + 1;
                 yield* Effect.tryPromise({
@@ -1593,6 +1668,7 @@ export class SmithersDb {
                 });
                 return seq;
             }
+            const releaseTurn = yield* self.acquireTransactionTurn();
             return yield* Effect.try({
                 try: () => {
                     client.run("BEGIN IMMEDIATE");
@@ -1618,7 +1694,9 @@ export class SmithersDb {
                     }
                 },
                 catch: (cause) => toSmithersError(cause, "insert signal transaction"),
-            });
+            }).pipe(Effect.ensuring(Effect.sync(() => {
+                releaseTurn();
+            })));
         }), { label }).pipe(Effect.annotateLogs({
             runId: row.runId,
             signalName: row.signalName,
@@ -1738,10 +1816,10 @@ export class SmithersDb {
             if (existing?.seq !== undefined) {
                 return existing.seq;
             }
-            const client = self.db.$client;
-            if (!client ||
-                typeof client.exec !== "function" ||
-                typeof client.query !== "function") {
+            const client = /** @type {{ exec?: unknown; query?: unknown; run?: unknown }} */ (resolveSqliteClientKey(self.db));
+            if (typeof client.exec !== "function" ||
+                typeof client.query !== "function" ||
+                typeof client.run !== "function") {
                 const lastSeq = (yield* self.getLastEventSeq(row.runId)) ?? -1;
                 const seq = lastSeq + 1;
                 yield* Effect.tryPromise({
@@ -1750,6 +1828,7 @@ export class SmithersDb {
                 });
                 return seq;
             }
+            const releaseTurn = yield* self.acquireTransactionTurn();
             return yield* Effect.try({
                 try: () => {
                     client.run("BEGIN IMMEDIATE");
@@ -1775,7 +1854,9 @@ export class SmithersDb {
                     }
                 },
                 catch: (cause) => toSmithersError(cause, "insert event transaction"),
-            });
+            }).pipe(Effect.ensuring(Effect.sync(() => {
+                releaseTurn();
+            })));
         }), { label }).pipe(Effect.annotateLogs({ dbOperation: label }), Effect.withLogSpan(`db:${label}`)));
     }
     /**

package/src/adapter.js

@@ -14,7 +14,7 @@ import { getTableName, sql } from "drizzle-orm";
 import { Effect, Exit, FiberId, Metric } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { getSqlMessageStorage } from "./sql-message-storage.js";
-import { alertsAcknowledgedTotal, alertsActive, alertsFiredTotal, dbQueryDuration, dbTransactionDuration, dbTransactionRetries, dbTransactionRollbacks, } from "@smithers-orchestrator/observability/metrics";
+import { alertsAcknowledgedTotal, alertsActive, alertsFiredTotal, dbQueryDuration, dbTransactionDuration, dbTransactionRollbacks, } from "@smithers-orchestrator/observability/metrics";
 import { assertOptionalStringMaxLength, assertPositiveFiniteNumber, } from "./input-bounds.js";
 import { FRAME_KEYFRAME_INTERVAL, applyFrameDeltaJson, encodeFrameDelta, normalizeFrameEncoding, serializeFrameDelta, } from "./frame-codec.js";
 import { getKeyColumns } from "./output.js";
@@ -77,7 +77,6 @@ export const DB_RUN_ALLOWED_STATUSES = [
     "cancelled",
     "continued",
 ];
-const RUN_HEARTBEAT_STALE_MS = 30_000;
 const RAW_QUERY_ALLOWED_PREFIX = /^(?:select|with|explain|values)\b/i;
 const RAW_QUERY_FORBIDDEN_KEYWORDS = /\b(?:drop|delete|insert|update|alter|create|attach|detach|pragma)\b/i;
 const ACTIVE_ALERT_STATUSES = new Set([
@@ -354,6 +353,73 @@ function runnableEffect(effect) {
     }
     return runnable;
 }
+/**
+ * @typedef {{ depth: number; ownerThread: string | null; tail: Promise<unknown> }} SqliteTransactionState
+ */
+/** @type {WeakMap<object, SqliteTransactionState>} */
+// Cross-adapter coordination: one sqlite connection cannot run overlapping BEGIN IMMEDIATE statements.
+const sqliteTransactionStateByClient = (() => {
+    const key = Symbol.for("smithers.sqliteTransactionStateByClient");
+    const registry = /** @type {Record<PropertyKey, unknown>} */ (globalThis);
+    const existing = registry[key];
+    if (existing instanceof WeakMap) {
+        return /** @type {WeakMap<object, SqliteTransactionState>} */ (existing);
+    }
+    const stateByClient = new WeakMap();
+    Object.defineProperty(globalThis, key, {
+        configurable: false,
+        enumerable: false,
+        value: stateByClient,
+    });
+    return stateByClient;
+})();
+/**
+ * @param {unknown} client
+ * @returns {object}
+ */
+function assertSqliteClientKey(client) {
+    if ((typeof client !== "object" && typeof client !== "function") ||
+        client === null) {
+        throw new Error("SmithersDb requires an object sqlite client for transaction coordination.");
+    }
+    return /** @type {object} */ (client);
+}
+/**
+ * @param {unknown} db
+ * @returns {object}
+ */
+function resolveSqliteClientKey(db) {
+    const source = /** @type {{ session?: { client?: unknown }; $client?: unknown }} */ (db);
+    return assertSqliteClientKey(source?.session?.client ?? source?.$client ?? db);
+}
+/**
+ * @param {unknown} client
+ * @returns {SqliteTransactionState}
+ */
+function getSqliteTransactionState(client) {
+    const key = assertSqliteClientKey(client);
+    let state = sqliteTransactionStateByClient.get(key);
+    if (!state) {
+        state = {
+            depth: 0,
+            ownerThread: null,
+            tail: Promise.resolve(),
+        };
+        sqliteTransactionStateByClient.set(key, state);
+    }
+    return state;
+}
+/**
+ * @param {unknown} db
+ * @returns {{ run: (sql: string) => unknown; query: (sql: string) => { run: (...args: unknown[]) => unknown; get: (...args: unknown[]) => Record<string, unknown> | null | undefined; all: () => Array<Record<string, unknown>> }; exec: (sql: string) => unknown; $client?: unknown }}
+ */
+function resolveSqliteTransactionClient(db) {
+    const candidate = /** @type {{ run?: unknown; query?: unknown; exec?: unknown; $client?: unknown }} */ (resolveSqliteClientKey(db));
+    if (typeof candidate.run !== "function") {
+        throw new Error("SmithersDb.withTransaction requires Bun SQLite client transaction primitives.");
+    }
+    return /** @type {{ run: (sql: string) => unknown; query: (sql: string) => { run: (...args: unknown[]) => unknown; get: (...args: unknown[]) => Record<string, unknown> | null | undefined; all: () => Array<Record<string, unknown>> }; exec: (sql: string) => unknown; $client?: unknown }} */ (candidate);
+}
 export class SmithersDb {
     /** @type {BunSQLiteDatabase<Record<string, unknown>>} */
     db;
@@ -450,8 +516,12 @@ export class SmithersDb {
    * @returns {boolean}
    */
     ownsActiveTransaction(currentFiberThread) {
-        return (this.transactionDepth > 0 &&
-            this.transactionOwnerThread === currentFiberThread);
+        const state = getSqliteTransactionState(resolveSqliteClientKey(this.db));
+        this.transactionDepth = state.depth;
+        this.transactionOwnerThread = state.ownerThread;
+        this.transactionTail = state.tail;
+        return (state.depth > 0 &&
+            state.ownerThread === currentFiberThread);
     }
     /**
    * @template A
@@ -525,11 +595,7 @@ export class SmithersDb {
     getSqliteTransactionClient() {
         return Effect.try({
             try: () => {
-                const candidate = this.db.session?.client ?? this.db.$client;
-                if (!candidate || typeof candidate.run !== "function") {
-                    throw new Error("SmithersDb.withTransaction requires Bun SQLite client transaction primitives.");
-                }
-                return candidate;
+                return resolveSqliteTransactionClient(this.db);
             },
             catch: (cause) => toSmithersError(cause, "resolve sqlite transaction client", {
                 code: "DB_WRITE_FAILED",
@@ -543,12 +609,14 @@ export class SmithersDb {
     acquireTransactionTurn() {
         return Effect.tryPromise({
             try: async () => {
+                const state = getSqliteTransactionState(resolveSqliteClientKey(this.db));
                 let release;
                 const gate = new Promise((resolve) => {
                     release = resolve;
                 });
-                const previous = this.transactionTail.catch(() => undefined);
-                this.transactionTail = previous.then(() => gate);
+                const previous = state.tail.catch(() => undefined);
+                state.tail = previous.then(() => gate);
+                this.transactionTail = state.tail;
                 await previous;
                 return release;
             },
@@ -577,6 +645,7 @@ export class SmithersDb {
                 }));
             }
             const releaseTurn = yield* self.acquireTransactionTurn();
+            const transactionState = getSqliteTransactionState(resolveSqliteClientKey(self.db));
             const start = performance.now();
             return yield* Effect.gen(function* () {
                 const client = yield* self.getSqliteTransactionClient();
@@ -603,8 +672,11 @@ export class SmithersDb {
                 yield* Effect.try({
                     try: () => {
                         client.run("BEGIN IMMEDIATE");
-                        self.transactionDepth += 1;
-                        self.transactionOwnerThread = currentFiberThread;
+                        transactionState.depth += 1;
+                        transactionState.ownerThread = currentFiberThread;
+                        self.transactionDepth = transactionState.depth;
+                        self.transactionOwnerThread = transactionState.ownerThread;
+                        self.transactionTail = transactionState.tail;
                     },
                     catch: (cause) => toSmithersError(cause, "begin sqlite transaction", {
                         code: "DB_WRITE_FAILED",
@@ -631,10 +703,13 @@ export class SmithersDb {
                 }
                 return operationExit.value;
             }).pipe(Effect.ensuring(Effect.gen(function* () {
-                self.transactionDepth = Math.max(0, self.transactionDepth - 1);
-                if (self.transactionDepth === 0) {
-                    self.transactionOwnerThread = null;
+                transactionState.depth = Math.max(0, transactionState.depth - 1);
+                if (transactionState.depth === 0) {
+                    transactionState.ownerThread = null;
                 }
+                self.transactionDepth = transactionState.depth;
+                self.transactionOwnerThread = transactionState.ownerThread;
+                self.transactionTail = transactionState.tail;
                 yield* Metric.update(dbTransactionDuration, performance.now() - start);
             }))).pipe(Effect.ensuring(Effect.sync(() => {
                 releaseTurn();
@@ -1594,10 +1669,10 @@ export class SmithersDb {
             if (existing?.seq !== undefined) {
                 return existing.seq;
             }
-            const client = self.db.$client;
-            if (!client ||
-                typeof client.exec !== "function" ||
-                typeof client.query !== "function") {
+            const client = /** @type {{ exec?: unknown; query?: unknown; run?: unknown }} */ (resolveSqliteClientKey(self.db));
+            if (typeof client.exec !== "function" ||
+                typeof client.query !== "function" ||
+                typeof client.run !== "function") {
                 const lastSeq = (yield* self.getLastSignalSeq(row.runId)) ?? -1;
                 const seq = lastSeq + 1;
                 yield* Effect.tryPromise({
@@ -1610,6 +1685,7 @@ export class SmithersDb {
                 });
                 return seq;
             }
+            const releaseTurn = yield* self.acquireTransactionTurn();
             return yield* Effect.try({
                 try: () => {
                     client.run("BEGIN IMMEDIATE");
@@ -1635,7 +1711,9 @@ export class SmithersDb {
                     }
                 },
                 catch: (cause) => toSmithersError(cause, "insert signal transaction"),
-            });
+            }).pipe(Effect.ensuring(Effect.sync(() => {
+                releaseTurn();
+            })));
         }), { label }).pipe(Effect.annotateLogs({
             runId: row.runId,
             signalName: row.signalName,
@@ -1755,10 +1833,10 @@ export class SmithersDb {
             if (existing?.seq !== undefined) {
                 return existing.seq;
             }
-            const client = self.db.$client;
-            if (!client ||
-                typeof client.exec !== "function" ||
-                typeof client.query !== "function") {
+            const client = /** @type {{ exec?: unknown; query?: unknown; run?: unknown }} */ (resolveSqliteClientKey(self.db));
+            if (typeof client.exec !== "function" ||
+                typeof client.query !== "function" ||
+                typeof client.run !== "function") {
                 const lastSeq = (yield* self.getLastEventSeq(row.runId)) ?? -1;
                 const seq = lastSeq + 1;
                 yield* Effect.tryPromise({
@@ -1767,6 +1845,7 @@ export class SmithersDb {
                 });
                 return seq;
             }
+            const releaseTurn = yield* self.acquireTransactionTurn();
             return yield* Effect.try({
                 try: () => {
                     client.run("BEGIN IMMEDIATE");
@@ -1792,7 +1871,9 @@ export class SmithersDb {
                     }
                 },
                 catch: (cause) => toSmithersError(cause, "insert event transaction"),
-            });
+            }).pipe(Effect.ensuring(Effect.sync(() => {
+                releaseTurn();
+            })));
         }), { label }).pipe(Effect.annotateLogs({ dbOperation: label }), Effect.withLogSpan(`db:${label}`)));
     }
     /**

package/src/ensureSqlMessageStorage.js

@@ -1,4 +1,3 @@
-import { Database } from "bun:sqlite";
 import { getSqlMessageStorage } from "./getSqlMessageStorage.js";
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
 

package/src/ensureSqlMessageStorageEffect.js

@@ -1,5 +1,3 @@
-import { Database } from "bun:sqlite";
-import { Effect } from "effect";
 import { getSqlMessageStorage } from "./getSqlMessageStorage.js";
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
 

package/src/getSqlMessageStorage.js

@@ -1,4 +1,3 @@
-import { Database } from "bun:sqlite";
 import { SqlMessageStorage } from "./SqlMessageStorage.js";
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
 

package/src/index.d.ts

@@ -9,7 +9,6 @@ import { Database } from 'bun:sqlite';
 import * as SqlClient from '@effect/sql/SqlClient';
 import { SqlError } from '@effect/sql/SqlError';
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
-import * as _smithers_driver_OutputSnapshot from '@smithers-orchestrator/driver/OutputSnapshot';
 
 type SchemaRegistryEntry$1 = {
     table: Table$1;
@@ -5018,7 +5017,7 @@ declare function loadOutputsEffect(db: BunSQLiteDatabase<Record<string, unknown>
  * @returns {Promise<OutputSnapshot>}
  */
 declare function loadOutputs(db: BunSQLiteDatabase<Record<string, unknown>>, schema: Record<string, _Table | unknown>, runId: string): Promise<OutputSnapshot>;
-type OutputSnapshot = _smithers_driver_OutputSnapshot.OutputSnapshot;
+type OutputSnapshot = Record<string, Array<unknown>>;
 type BunSQLiteDatabase = drizzle_orm_bun_sqlite.BunSQLiteDatabase;
 type _Table = drizzle_orm.Table;
 
@@ -5156,6 +5155,13 @@ type SqliteWriteRetryOptions = SqliteWriteRetryOptions$2;
  */
 declare function zodToCreateTableSQL(tableName: any, schema: any, opts: any): string;
 
+declare function zodSchemaColumns(schema: any): {
+    name: any;
+    sqliteType: string;
+}[];
+
+declare function syncZodTableSchema(sqlite: any, tableName: any, schema: any, opts: any): void;
+
 /**
  * Generates a Drizzle sqliteTable from a Zod object schema.
  *
@@ -5200,4 +5206,4 @@ declare function camelToSnake(str: any): any;
 
 type SchemaRegistryEntry = SchemaRegistryEntry$1;
 
-export { type AlertRow, type AlertSeverity, type AlertStatus, type AnyColumn, type ApprovalRow, type AttemptRow, type CacheRow, type CacheRowLike, type CountRow, DB_ALERT_ALLOWED_SEVERITIES, DB_ALERT_ALLOWED_STATUSES, DB_ALERT_ID_MAX_LENGTH, DB_ALERT_MESSAGE_MAX_LENGTH, DB_ALERT_POLICY_NAME_MAX_LENGTH, DB_RUN_ALLOWED_STATUSES, DB_RUN_ID_MAX_LENGTH, DB_RUN_WORKFLOW_NAME_MAX_LENGTH, type EventHistoryQuery, FRAME_KEYFRAME_INTERVAL, type FrameDelta, type FrameDeltaOp, type FrameEncoding, type FrameRow, type HumanRequestRow, type JsonBounds, type JsonPath, type JsonPathSegment, NODE_DIFF_MAX_BYTES, NodeDiffCache, type NodeDiffCacheResult, type NodeDiffCacheRow$1 as NodeDiffCacheRow, NodeDiffTooLargeError, type NodeRow, type OutputKey, type OutputSnapshot, type PendingHumanRequestRow, type RalphRow, type RunAncestryRow, type RunRow, type RunnableEffect, type SchemaRegistryEntry, type SignalQuery, type SignalRow, SmithersDb, type SmithersError$1 as SmithersError, SqlMessageStorage, type SqlMessageStorageEventHistoryQuery, type SqliteParam, type SqliteWriteRetryOptions, type StaleRunRecord, type _BunSQLiteDatabase, type _NodeDiffCacheRow, type _OutputKey, type _SmithersDb, type _SmithersError, applyFrameDelta, applyFrameDeltaJson, assertJsonPayloadWithinBounds, assertMaxBytes, assertMaxJsonDepth, assertMaxStringLength, assertOptionalArrayMaxLength, assertOptionalStringMaxLength, assertPositiveFiniteInteger, assertPositiveFiniteNumber, buildKeyWhere, buildOutputRow, camelToSnake, describeSchemaShape, encodeFrameDelta, ensureSmithersTables, ensureSmithersTablesEffect, ensureSqlMessageStorage, ensureSqlMessageStorageEffect, getAgentOutputSchema, getKeyColumns, getSqlMessageStorage, isRetryableSqliteWriteError, loadInput, loadInputEffect, loadOutputs, loadOutputsEffect, normalizeFrameEncoding, parseFrameDelta, schemaSignature, selectOutputRow, selectOutputRowEffect, serializeFrameDelta, smithersAlerts, smithersApprovals, smithersAttempts, smithersCache, smithersCron, smithersEvents, smithersFrames, smithersHumanRequests, smithersNodeDiffs, smithersNodes, smithersRalph, smithersRuns, smithersSandboxes, smithersSignals, smithersTimeTravelAudit, smithersToolCalls, smithersVectors, stripAutoColumns, unwrapZodType, upsertOutputRow, upsertOutputRowEffect, validateExistingOutput, validateInput, validateOutput, withSqliteWriteRetry, withSqliteWriteRetryEffect, zodToCreateTableSQL, zodToTable };
+export { type AlertRow, type AlertSeverity, type AlertStatus, type AnyColumn, type ApprovalRow, type AttemptRow, type CacheRow, type CacheRowLike, type CountRow, DB_ALERT_ALLOWED_SEVERITIES, DB_ALERT_ALLOWED_STATUSES, DB_ALERT_ID_MAX_LENGTH, DB_ALERT_MESSAGE_MAX_LENGTH, DB_ALERT_POLICY_NAME_MAX_LENGTH, DB_RUN_ALLOWED_STATUSES, DB_RUN_ID_MAX_LENGTH, DB_RUN_WORKFLOW_NAME_MAX_LENGTH, type EventHistoryQuery, FRAME_KEYFRAME_INTERVAL, type FrameDelta, type FrameDeltaOp, type FrameEncoding, type FrameRow, type HumanRequestRow, type JsonBounds, type JsonPath, type JsonPathSegment, NODE_DIFF_MAX_BYTES, NodeDiffCache, type NodeDiffCacheResult, type NodeDiffCacheRow$1 as NodeDiffCacheRow, NodeDiffTooLargeError, type NodeRow, type OutputKey, type OutputSnapshot, type PendingHumanRequestRow, type RalphRow, type RunAncestryRow, type RunRow, type RunnableEffect, type SchemaRegistryEntry, type SignalQuery, type SignalRow, SmithersDb, type SmithersError$1 as SmithersError, SqlMessageStorage, type SqlMessageStorageEventHistoryQuery, type SqliteParam, type SqliteWriteRetryOptions, type StaleRunRecord, type _BunSQLiteDatabase, type _NodeDiffCacheRow, type _OutputKey, type _SmithersDb, type _SmithersError, applyFrameDelta, applyFrameDeltaJson, assertJsonPayloadWithinBounds, assertMaxBytes, assertMaxJsonDepth, assertMaxStringLength, assertOptionalArrayMaxLength, assertOptionalStringMaxLength, assertPositiveFiniteInteger, assertPositiveFiniteNumber, buildKeyWhere, buildOutputRow, camelToSnake, describeSchemaShape, encodeFrameDelta, ensureSmithersTables, ensureSmithersTablesEffect, ensureSqlMessageStorage, ensureSqlMessageStorageEffect, getAgentOutputSchema, getKeyColumns, getSqlMessageStorage, isRetryableSqliteWriteError, loadInput, loadInputEffect, loadOutputs, loadOutputsEffect, normalizeFrameEncoding, parseFrameDelta, schemaSignature, selectOutputRow, selectOutputRowEffect, serializeFrameDelta, smithersAlerts, smithersApprovals, smithersAttempts, smithersCache, smithersCron, smithersEvents, smithersFrames, smithersHumanRequests, smithersNodeDiffs, smithersNodes, smithersRalph, smithersRuns, smithersSandboxes, smithersSignals, smithersTimeTravelAudit, smithersToolCalls, smithersVectors, stripAutoColumns, syncZodTableSchema, unwrapZodType, upsertOutputRow, upsertOutputRowEffect, validateExistingOutput, validateInput, validateOutput, withSqliteWriteRetry, withSqliteWriteRetryEffect, zodSchemaColumns, zodToCreateTableSQL, zodToTable };

package/src/input.js

@@ -1,5 +1,4 @@
 import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
 /** @typedef {import("drizzle-orm").Table} _Table */
 
 /**

package/src/internal-schema/index.js

@@ -13,7 +13,9 @@ export { smithersSandboxes } from "./smithersSandboxes.js";
 export { smithersToolCalls } from "./smithersToolCalls.js";
 export { smithersEvents } from "./smithersEvents.js";
 export { smithersRalph } from "./smithersRalph.js";
-export { smithersScorers } from "@smithers-orchestrator/scorers/schema";
-export { smithersMemoryFacts, smithersMemoryThreads, smithersMemoryMessages, } from "@smithers-orchestrator/memory/schema";
+export { smithersScorers } from "./smithersScorers.js";
+export { smithersMemoryFacts } from "./smithersMemoryFacts.js";
+export { smithersMemoryThreads } from "./smithersMemoryThreads.js";
+export { smithersMemoryMessages } from "./smithersMemoryMessages.js";
 export { smithersVectors } from "./smithersVectors.js";
 export { smithersCron } from "./smithersCron.js";

package/src/internal-schema/smithersMemoryFacts.js

@@ -0,0 +1,13 @@
+import { integer, sqliteTable, text, primaryKey } from "drizzle-orm/sqlite-core";
+
+export const smithersMemoryFacts = sqliteTable("_smithers_memory_facts", {
+    namespace: text("namespace").notNull(),
+    key: text("key").notNull(),
+    valueJson: text("value_json").notNull(),
+    schemaSig: text("schema_sig"),
+    createdAtMs: integer("created_at_ms").notNull(),
+    updatedAtMs: integer("updated_at_ms").notNull(),
+    ttlMs: integer("ttl_ms"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.namespace, t.key] }),
+}));

package/src/internal-schema/smithersMemoryMessages.js

@@ -0,0 +1,11 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const smithersMemoryMessages = sqliteTable("_smithers_memory_messages", {
+    id: text("id").primaryKey(),
+    threadId: text("thread_id").notNull(),
+    role: text("role").notNull(),
+    contentJson: text("content_json").notNull(),
+    runId: text("run_id"),
+    nodeId: text("node_id"),
+    createdAtMs: integer("created_at_ms").notNull(),
+});

package/src/internal-schema/smithersMemoryThreads.js

@@ -0,0 +1,10 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const smithersMemoryThreads = sqliteTable("_smithers_memory_threads", {
+    threadId: text("thread_id").primaryKey(),
+    namespace: text("namespace").notNull(),
+    title: text("title"),
+    metadataJson: text("metadata_json"),
+    createdAtMs: integer("created_at_ms").notNull(),
+    updatedAtMs: integer("updated_at_ms").notNull(),
+});

package/src/internal-schema/smithersScorers.js

@@ -0,0 +1,20 @@
+import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const smithersScorers = sqliteTable("_smithers_scorers", {
+    id: text("id").primaryKey(),
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    attempt: integer("attempt").notNull().default(0),
+    scorerId: text("scorer_id").notNull(),
+    scorerName: text("scorer_name").notNull(),
+    source: text("source").notNull(),
+    score: real("score").notNull(),
+    reason: text("reason"),
+    metaJson: text("meta_json"),
+    inputJson: text("input_json"),
+    outputJson: text("output_json"),
+    latencyMs: real("latency_ms"),
+    scoredAtMs: integer("scored_at_ms").notNull(),
+    durationMs: real("duration_ms"),
+});

package/src/internal-schema.js

@@ -220,8 +220,10 @@ export const smithersRalph = sqliteTable("_smithers_ralph", {
 }, (t) => ({
     pk: primaryKey({ columns: [t.runId, t.ralphId] }),
 }));
-export { smithersScorers } from "@smithers-orchestrator/scorers/schema";
-export { smithersMemoryFacts, smithersMemoryThreads, smithersMemoryMessages, } from "@smithers-orchestrator/memory/schema";
+export { smithersScorers } from "./internal-schema/smithersScorers.js";
+export { smithersMemoryFacts } from "./internal-schema/smithersMemoryFacts.js";
+export { smithersMemoryThreads } from "./internal-schema/smithersMemoryThreads.js";
+export { smithersMemoryMessages } from "./internal-schema/smithersMemoryMessages.js";
 export const smithersVectors = sqliteTable("_smithers_vectors", {
     id: text("id").primaryKey(),
     namespace: text("namespace").notNull(),

package/src/loadOutputsEffect.js

@@ -2,8 +2,7 @@ import { eq, getTableName } from "drizzle-orm";
 import { getTableColumns } from "drizzle-orm/utils";
 import { Effect, Option } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
-import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
-/** @typedef {import("@smithers-orchestrator/driver/OutputSnapshot").OutputSnapshot} OutputSnapshot */
+/** @typedef {Record<string, Array<unknown>>} OutputSnapshot */
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
 /** @typedef {import("drizzle-orm").Table} Table */
 

package/src/output/buildOutputRow.js

@@ -26,7 +26,7 @@ export function buildOutputRow(table, runId, nodeId, iteration, payload) {
         };
     }
     return {
-        ...(payload ?? {}),
+        ...payload,
         runId,
         nodeId,
         iteration,

package/src/output/describeSchemaShape.js

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { getAgentOutputSchema } from "./getAgentOutputSchema.js";
 /** @typedef {import("drizzle-orm").Table} Table */
 

package/src/output/getAgentOutputSchema.js

@@ -8,6 +8,6 @@ export function getAgentOutputSchema(table) {
     const baseSchema = createInsertSchema(table);
     // Remove the key columns that smithers populates automatically
     const shape = baseSchema.shape;
-    const { runId, nodeId, iteration, ...rest } = shape;
+    const { runId: _runId, nodeId: _nodeId, iteration: _iteration, ...rest } = shape;
     return z.object(rest);
 }

package/src/output/validateExistingOutput.js

@@ -1,5 +1,4 @@
 import { createSelectSchema } from "drizzle-zod";
-import { z } from "zod";
 /** @typedef {import("drizzle-orm").Table} Table */
 
 /**

package/src/output/validateOutput.js

@@ -1,5 +1,4 @@
 import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
 /** @typedef {import("drizzle-orm").Table} Table */
 
 /**

package/src/output.js

@@ -28,7 +28,7 @@ export function buildOutputRow(table, runId, nodeId, iteration, payload) {
         return { runId, nodeId, iteration, payload: (payload ?? null) };
     }
     return {
-        ...(/** @type {Record<string, unknown>} */ (payload ?? {})),
+        ...(/** @type {Record<string, unknown>} */ (payload)),
         runId, nodeId, iteration,
     };
 }

package/src/snapshot.js

@@ -3,7 +3,7 @@ import { getTableColumns } from "drizzle-orm/utils";
 import { Effect, Option } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
-/** @typedef {import("@smithers-orchestrator/driver/OutputSnapshot").OutputSnapshot} OutputSnapshot */
+/** @typedef {Record<string, Array<unknown>>} OutputSnapshot */
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
 /** @typedef {import("drizzle-orm").Table} _Table */
 

package/src/sql-message-storage.js

@@ -34,8 +34,6 @@ const CREATE_TABLE_STATEMENTS = [
     error_json TEXT,
     config_json TEXT
   )`,
-    `CREATE INDEX IF NOT EXISTS _smithers_runs_status_heartbeat_idx
-    ON _smithers_runs (status, heartbeat_at_ms)`,
     `CREATE TABLE IF NOT EXISTS _smithers_nodes (
     run_id TEXT NOT NULL,
     node_id TEXT NOT NULL,
@@ -143,8 +141,6 @@ const CREATE_TABLE_STATEMENTS = [
     received_by TEXT,
     PRIMARY KEY (run_id, seq)
   )`,
-    `CREATE INDEX IF NOT EXISTS _smithers_signals_lookup_idx
-    ON _smithers_signals (run_id, signal_name, correlation_id, received_at_ms)`,
     `CREATE TABLE IF NOT EXISTS _smithers_cache (
     cache_key TEXT PRIMARY KEY,
     created_at_ms INTEGER NOT NULL,
@@ -177,8 +173,6 @@ const CREATE_TABLE_STATEMENTS = [
     result TEXT NOT NULL,
     duration_ms INTEGER
   )`,
-    `CREATE INDEX IF NOT EXISTS _smithers_time_travel_audit_lookup_idx
-    ON _smithers_time_travel_audit (run_id, caller, timestamp_ms)`,
     `CREATE TABLE IF NOT EXISTS _smithers_sandboxes (
     run_id TEXT NOT NULL,
     sandbox_id TEXT NOT NULL,
@@ -322,6 +316,14 @@ const CREATE_TABLE_STATEMENTS = [
     created_at_ms INTEGER NOT NULL
   )`,
 ];
+const CREATE_INDEX_STATEMENTS = [
+    `CREATE INDEX IF NOT EXISTS _smithers_runs_status_heartbeat_idx
+    ON _smithers_runs (status, heartbeat_at_ms)`,
+    `CREATE INDEX IF NOT EXISTS _smithers_signals_lookup_idx
+    ON _smithers_signals (run_id, signal_name, correlation_id, received_at_ms)`,
+    `CREATE INDEX IF NOT EXISTS _smithers_time_travel_audit_lookup_idx
+    ON _smithers_time_travel_audit (run_id, caller, timestamp_ms)`,
+];
 const MIGRATION_STATEMENTS = [
     `ALTER TABLE _smithers_attempts ADD COLUMN response_text TEXT`,
     `ALTER TABLE _smithers_attempts ADD COLUMN jj_cwd TEXT`,
@@ -643,6 +645,9 @@ export class SqlMessageStorage {
                     // Ignore if another caller added it first.
                 }
             }
+            for (const statement of CREATE_INDEX_STATEMENTS) {
+                sqlite.run(statement);
+            }
         });
     }
     /**

package/src/storage/StorageService.js

@@ -2,6 +2,6 @@
 /** @typedef {import("./StorageServiceShape.ts").StorageServiceShape} StorageServiceShape */
 // @smithers-type-exports-end
 
-import { Context, Effect } from "effect";
+import { Context } from "effect";
 export class StorageService extends Context.Tag("StorageService")() {
 }

package/src/zodToCreateTableSQL.js

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { unwrapZodType } from "./unwrapZodType.js";
 import { camelToSnake } from "./utils/camelToSnake.js";
 /**
@@ -7,6 +6,32 @@ import { camelToSnake } from "./utils/camelToSnake.js";
 function getZodBaseTypeName(zodType) {
     return zodType._zod?.def?.type ?? "unknown";
 }
+function sqliteTypeFor(zodFieldSchema) {
+    const baseType = unwrapZodType(zodFieldSchema);
+    const baseTypeName = getZodBaseTypeName(baseType);
+    if (baseTypeName === "number" ||
+        baseTypeName === "int" ||
+        baseTypeName === "float" ||
+        baseTypeName === "boolean") {
+        return "INTEGER";
+    }
+    return "TEXT";
+}
+function quoteIdentifier(identifier) {
+    return `"${String(identifier).replaceAll(`"`, `""`)}"`;
+}
+/**
+ * Returns the user-defined columns derived from a Zod schema (excluding the
+ * fixed run_id/node_id/iteration prefix). Each entry is `{ name, sqliteType }`.
+ */
+export function zodSchemaColumns(schema) {
+    const out = [];
+    const shape = schema.shape;
+    for (const [key] of Object.entries(shape)) {
+        out.push({ name: camelToSnake(key), sqliteType: sqliteTypeFor(shape[key]) });
+    }
+    return out;
+}
 /**
  * Generates a CREATE TABLE IF NOT EXISTS SQL statement from a Zod schema.
  * Used for runtime table creation without Drizzle migrations.
@@ -19,23 +44,42 @@ export function zodToCreateTableSQL(tableName, schema, opts) {
             `node_id TEXT NOT NULL`,
             `iteration INTEGER NOT NULL DEFAULT 0`,
         ];
-    const shape = schema.shape;
-    for (const [key] of Object.entries(shape)) {
-        const colName = camelToSnake(key);
-        const baseType = unwrapZodType(shape[key]);
-        const baseTypeName = getZodBaseTypeName(baseType);
-        if (baseTypeName === "number" ||
-            baseTypeName === "int" ||
-            baseTypeName === "float" ||
-            baseTypeName === "boolean") {
-            colDefs.push(`"${colName}" INTEGER`);
-        }
-        else {
-            colDefs.push(`"${colName}" TEXT`);
-        }
+    for (const { name, sqliteType } of zodSchemaColumns(schema)) {
+        colDefs.push(`"${name}" ${sqliteType}`);
     }
     if (!opts?.isInput) {
         colDefs.push(`PRIMARY KEY (run_id, node_id, iteration)`);
     }
-    return `CREATE TABLE IF NOT EXISTS "${tableName}" (${colDefs.join(", ")})`;
+    return `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(tableName)} (${colDefs.join(", ")})`;
+}
+/**
+ * Ensures `tableName` exists with all columns implied by `schema`, adding
+ * any missing columns via ALTER TABLE. Idempotent and safe to call on every
+ * boot — fixes the case where the schema evolves but the table was created
+ * by an earlier version (CREATE TABLE IF NOT EXISTS would silently no-op).
+ *
+ * `sqlite` must be a `bun:sqlite` Database (or compatible) exposing
+ * `.run(sql)` and `.query(sql).all()`.
+ */
+export function syncZodTableSchema(sqlite, tableName, schema, opts) {
+    sqlite.run(zodToCreateTableSQL(tableName, schema, opts));
+    let existing;
+    const quotedTable = quoteIdentifier(tableName);
+    try {
+        existing = sqlite.query(`PRAGMA table_info(${quotedTable})`).all();
+    }
+    catch {
+        return;
+    }
+    const have = new Set(existing.map((row) => row?.name).filter((n) => typeof n === "string"));
+    for (const { name, sqliteType } of zodSchemaColumns(schema)) {
+        if (have.has(name))
+            continue;
+        try {
+            sqlite.run(`ALTER TABLE ${quotedTable} ADD COLUMN ${quoteIdentifier(name)} ${sqliteType}`);
+        }
+        catch {
+            // Concurrent boot, or column added since the PRAGMA snapshot — ignore.
+        }
+    }
 }

package/src/zodToTable.js

@@ -1,5 +1,4 @@
 import { sqliteTable, text, integer, primaryKey, } from "drizzle-orm/sqlite-core";
-import { z } from "zod";
 import { unwrapZodType } from "./unwrapZodType.js";
 import { camelToSnake } from "./utils/camelToSnake.js";
 /**