@smithers-orchestrator/db 0.24.2 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/db",
-  "version": "0.24.2",
+  "version": "0.25.0",
   "description": "SQLite and Drizzle persistence adapter for Smithers workflows",
   "type": "module",
   "sideEffects": false,
@@ -30,10 +30,10 @@
     "drizzle-zod": "^0.8.3",
     "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/graph": "0.24.2",
-    "@smithers-orchestrator/errors": "0.24.2",
-    "@smithers-orchestrator/scheduler": "0.24.2",
-    "@smithers-orchestrator/observability": "0.24.2"
+    "@smithers-orchestrator/errors": "0.25.0",
+    "@smithers-orchestrator/graph": "0.25.0",
+    "@smithers-orchestrator/observability": "0.25.0",
+    "@smithers-orchestrator/scheduler": "0.25.0"
   },
   "devDependencies": {
     "@electric-sql/pglite": "0.5.1",

package/src/adapter/DB_RUN_ALLOWED_STATUSES.js

@@ -3,6 +3,7 @@ export const DB_RUN_ALLOWED_STATUSES = [
     "waiting-approval",
     "waiting-event",
     "waiting-timer",
+    "waiting-quota",
     "finished",
     "failed",
     "cancelled",

package/src/adapter.js

@@ -12,6 +12,7 @@
 
 import { getTableName } from "drizzle-orm";
 import { getTableColumns } from "drizzle-orm/utils";
+import { createHash } from "node:crypto";
 import { Effect, Exit, FiberId, Metric } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { getSqlMessageStorage } from "./sql-message-storage.js";
@@ -51,6 +52,9 @@ import { camelToSnake } from "./utils/camelToSnake.js";
 /**
  * @typedef {{ cacheKey: string; createdAtMs?: number; nodeId: string; outputTable: string }} CacheRowLike
  */
+/**
+ * @typedef {{ path: string; kind: string; content: string; contentHash: string; updatedAtMs: number; deletedAtMs?: number | null }} DocRow
+ */
 
 
 export const DB_ALERT_ID_MAX_LENGTH = 256;
@@ -68,6 +72,7 @@ export const DB_ALERT_ALLOWED_STATUSES = [
     "silenced",
 ];
 const FRAME_XML_CACHE_MAX = 512;
+const DOC_CONFLICT_KIND = "conflict";
 export const DB_RUN_ID_MAX_LENGTH = 256;
 export const DB_RUN_WORKFLOW_NAME_MAX_LENGTH = 256;
 export const DB_RUN_ALLOWED_STATUSES = [
@@ -75,6 +80,7 @@ export const DB_RUN_ALLOWED_STATUSES = [
     "waiting-approval",
     "waiting-event",
     "waiting-timer",
+    "waiting-quota",
     "finished",
     "failed",
     "cancelled",
@@ -87,6 +93,71 @@ const ACTIVE_ALERT_STATUSES = new Set([
     "acknowledged",
     "silenced",
 ]);
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function sha256Hex(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+/**
+ * @param {string} path
+ * @param {number} updatedAtMs
+ * @returns {string}
+ */
+function docConflictPath(path, updatedAtMs) {
+    const key = createHash("sha1").update(path).digest("hex").slice(0, 16);
+    return `conflicts/${key}-${updatedAtMs}.json`;
+}
+/**
+ * Decide whether an incoming doc write diverges from the row already on record.
+ *
+ * The single writer (`syncDocsFromDisk`) re-reads and re-upserts a file on every
+ * watcher settle, so a plain "the content hash changed" rule would mint a marker
+ * on every ordinary sequential save and turn the conflict feature into an
+ * unbounded per-save change-log. A real conflict is a divergent write: the
+ * content differs AND the incoming write does not strictly advance past the row
+ * we already hold (its `updatedAtMs` is the same or older — a stale or
+ * out-of-order writer). A strict forward edit (`row.updatedAtMs >
+ * existing.updatedAtMs`) is the happy path and records no marker.
+ *
+ * @param {DocRow} row
+ * @param {DocRow} existing
+ * @returns {DocRow | null}
+ */
+function buildDocConflictRow(row, existing) {
+    if (row.kind === DOC_CONFLICT_KIND || existing.kind === DOC_CONFLICT_KIND) {
+        return null;
+    }
+    if (row.deletedAtMs != null || existing.deletedAtMs != null) {
+        return null;
+    }
+    if (row.contentHash === existing.contentHash) {
+        return null;
+    }
+    if (row.updatedAtMs > existing.updatedAtMs) {
+        return null;
+    }
+    const updatedAtMs = row.updatedAtMs;
+    const content = JSON.stringify({
+        path: row.path,
+        kind: row.kind,
+        previousHash: existing.contentHash,
+        incomingHash: row.contentHash,
+        previousUpdatedAtMs: existing.updatedAtMs,
+        incomingUpdatedAtMs: row.updatedAtMs,
+        resolution: "last-write-wins",
+        recordedAtMs: updatedAtMs,
+    }, null, 2);
+    return {
+        path: docConflictPath(row.path, updatedAtMs),
+        kind: DOC_CONFLICT_KIND,
+        content,
+        contentHash: sha256Hex(content),
+        updatedAtMs,
+        deletedAtMs: null,
+    };
+}
 /**
  * @param {string} queryString
  * @returns {string}
@@ -324,23 +395,6 @@ function validateAlertRow(row) {
 function isAlertActiveStatus(status) {
     return status !== undefined && status !== null && ACTIVE_ALERT_STATUSES.has(status);
 }
-/**
- * Returns the row unchanged. Historically this helper relabeled
- * stale-heartbeat "running" rows as "continued", which is wrong: "continued"
- * is reserved for runs that successfully forked into a new run, and
- * `deriveRunState` then maps "continued" → "succeeded" — so a dead workflow
- * was being reported as a success. Heartbeat-based classification now lives
- * exclusively in `deriveRunState`, which correctly returns "stale" or
- * "orphaned". This shim is kept so the `listRuns` / `getRun` call sites
- * continue to compile; remove it once they call `deriveRunState` directly.
- *
- * @template T
- * @param {T} row
- * @returns {T}
- */
-function classifyRunRowStatus(row) {
-    return row;
-}
 /**
  * @template A, E
  * @param {Effect.Effect<A, E>} effect
@@ -590,10 +644,11 @@ export class SmithersDb {
         }
     }
     /**
-   * @param {string} queryString
+     * @param {string} queryString
+     * @param {unknown[]} [params]
    * @returns {RunnableEffect<unknown[], SmithersError>}
    */
-    rawQuery(queryString) {
+    rawQuery(queryString, params = []) {
         const self = this;
         return runnableEffect(Effect.gen(function* () {
             const validatedQuery = yield* Effect.try({
@@ -605,11 +660,11 @@ export class SmithersDb {
             });
             return yield* self.read(`raw query ${validatedQuery.slice(0, 20)}`, () => {
                 if (self.internalStorage.dialect === POSTGRES) {
-                    return self.internalStorage.queryAllRaw(validatedQuery);
+                    return self.internalStorage.queryAllRaw(validatedQuery, params);
                 }
                 const client = self.db.session.client;
                 const stmt = client.query(validatedQuery);
-                return Promise.resolve(stmt.all());
+                return Promise.resolve(stmt.all(...params));
             });
         }));
     }
@@ -899,11 +954,10 @@ export class SmithersDb {
    */
     getRun(runId) {
         return this.read(`get run ${runId}`, async () => {
-            const row = await this.internalStorage.queryOne(`SELECT *
+            return this.internalStorage.queryOne(`SELECT *
          FROM _smithers_runs
          WHERE run_id = ?
          LIMIT 1`, [runId]);
-            return row ? classifyRunRowStatus(row) : undefined;
         });
     }
     /**
@@ -962,7 +1016,7 @@ export class SmithersDb {
          ${whereSql}
          ORDER BY created_at_ms DESC
          LIMIT ?`, [...params, limit]);
-            return rows.map((row) => classifyRunRowStatus(row));
+            return rows;
         });
     }
     /**
@@ -1871,17 +1925,30 @@ export class SmithersDb {
             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({
-                    try: () => self.internalStorage.insertIgnore("_smithers_signals", {
-                        ...row,
-                        receivedBy: row.receivedBy ?? null,
-                        seq,
-                    }),
-                    catch: (cause) => toSmithersError(cause, "insert fallback signal row"),
-                });
-                return seq;
+                // Non-bun:sqlite (Postgres/pglite) fallback. Serialize the
+                // read-MAX-then-insert under the shared transaction turn so two
+                // concurrent allocations can't both read the same lastSeq and
+                // collide on the (run_id, seq) primary key — insertIgnore would
+                // otherwise silently drop the loser, losing a signal.
+                const releaseTurn = yield* self.acquireTransactionTurn();
+                return yield* Effect.gen(function* () {
+                    const lastSeq = (yield* Effect.tryPromise({
+                        try: () => self.internalStorage.getLastSignalSeq(row.runId),
+                        catch: (cause) => toSmithersError(cause, "get fallback last signal seq"),
+                    })) ?? -1;
+                    const seq = lastSeq + 1;
+                    yield* Effect.tryPromise({
+                        try: () => self.internalStorage.insertIgnore("_smithers_signals", {
+                            ...row,
+                            receivedBy: row.receivedBy ?? null,
+                            seq,
+                        }),
+                        catch: (cause) => toSmithersError(cause, "insert fallback signal row"),
+                    });
+                    return seq;
+                }).pipe(Effect.ensuring(Effect.sync(() => {
+                    releaseTurn();
+                })));
             }
             const releaseTurn = yield* self.acquireTransactionTurn();
             return yield* Effect.try({
@@ -2075,6 +2142,25 @@ export class SmithersDb {
            ) sub WHERE rn <= ?)`, [runId, runId, keep]));
     }
     /**
+   * Upsert a DB-backed markdown artifact. When an existing live row has a
+   * different content hash, last-write-wins still applies, but a conflict marker
+   * row is inserted so the UI can surface the mismatch.
+   * @param {DocRow} row
+   * @returns {RunnableEffect<void, SmithersError>}
+   */
+    upsertDocRow(row) {
+        return this.write(`upsert doc ${row.path}`, async () => {
+            const existing = /** @type {DocRow | undefined} */ (await this.internalStorage.queryOne(`SELECT *
+             FROM _smithers_docs
+             WHERE path = ?`, [row.path]));
+            const conflict = existing ? buildDocConflictRow(row, existing) : null;
+            if (conflict) {
+                await this.internalStorage.upsert("_smithers_docs", conflict, ["path"], ["kind", "content", "contentHash", "updatedAtMs", "deletedAtMs"]);
+            }
+            await this.internalStorage.upsert("_smithers_docs", row, ["path"], ["kind", "content", "contentHash", "updatedAtMs", "deletedAtMs"]);
+        });
+    }
+    /**
    * @param {Record<string, unknown>} row
    * @returns {RunnableEffect<void, SmithersError>}
    */
@@ -2104,13 +2190,28 @@ export class SmithersDb {
             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({
-                    try: () => self.internalStorage.insertIgnore("_smithers_events", { ...row, seq }),
-                    catch: (cause) => toSmithersError(cause, "insert fallback event row"),
-                });
-                return seq;
+                // Non-bun:sqlite (Postgres/pglite) fallback. Serialize the
+                // read-MAX-then-insert under the shared transaction turn — the
+                // same primitive the bun:sqlite path below relies on — so two
+                // concurrent allocations can't both read the same lastSeq and
+                // collide on the (run_id, seq) primary key. Without the turn,
+                // insertIgnore would silently drop the loser, losing an event
+                // from the durable log that replay/live-stream depend on.
+                const releaseTurn = yield* self.acquireTransactionTurn();
+                return yield* Effect.gen(function* () {
+                    const lastSeq = (yield* Effect.tryPromise({
+                        try: () => self.internalStorage.getLastEventSeq(row.runId),
+                        catch: (cause) => toSmithersError(cause, "get fallback last event seq"),
+                    })) ?? -1;
+                    const seq = lastSeq + 1;
+                    yield* Effect.tryPromise({
+                        try: () => self.internalStorage.insertIgnore("_smithers_events", { ...row, seq }),
+                        catch: (cause) => toSmithersError(cause, "insert fallback event row"),
+                    });
+                    return seq;
+                }).pipe(Effect.ensuring(Effect.sync(() => {
+                    releaseTurn();
+                })));
             }
             const releaseTurn = yield* self.acquireTransactionTurn();
             return yield* Effect.try({
@@ -2153,31 +2254,6 @@ export class SmithersDb {
     /**
    * @param {string} runId
    * @param {EventHistoryQuery} [query]
-   * @returns {{ whereSql: string; params: Array<string | number> }}
-   */
-    buildEventHistoryWhere(runId, query = {}) {
-        const clauses = ["run_id = ?", "seq > ?"];
-        const params = [runId, query.afterSeq ?? -1];
-        if (typeof query.sinceTimestampMs === "number") {
-            clauses.push("timestamp_ms >= ?");
-            params.push(query.sinceTimestampMs);
-        }
-        if (query.types && query.types.length > 0) {
-            clauses.push(`type IN (${query.types.map(() => "?").join(", ")})`);
-            params.push(...query.types);
-        }
-        if (query.nodeId) {
-            clauses.push("json_extract(payload_json, '$.nodeId') = ?");
-            params.push(query.nodeId);
-        }
-        return {
-            whereSql: clauses.join(" AND "),
-            params,
-        };
-    }
-    /**
-   * @param {string} runId
-   * @param {EventHistoryQuery} [query]
    * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
    */
     listEventHistory(runId, query = {}) {
@@ -2546,6 +2622,103 @@ export class SmithersDb {
         return this.write(`delete cron ${cronId}`, () => this.internalStorage.deleteWhere("_smithers_cron", "cron_id = ?", [cronId]));
     }
     // ---------------------------------------------------------------------------
+    // Memory facts
+    // ---------------------------------------------------------------------------
+    /**
+   * List cross-run memory facts, optionally scoped to a namespace. Reads the
+   * `_smithers_memory_facts` table written by `@smithers-orchestrator/memory`'s
+   * MemoryStore (`setFact`) — the SAME table the `smithers memory list` CLI reads
+   * — so a fact set by any run/workflow surfaces here. Columns are snake→camel
+   * cased by the storage layer (`value_json → valueJson`, etc.). A null/undefined
+   * namespace returns every namespace's facts; ordering is stable (namespace, key)
+   * so the gateway's `listMemoryFacts` RPC returns a deterministic list.
+   * @param {string | null} [namespace]
+   * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
+   */
+    listMemoryFacts(namespace = null) {
+        const ns = namespace ?? null;
+        return this.read("list memory facts", () => this.internalStorage.queryAll(`SELECT namespace, key, value_json, schema_sig, created_at_ms, updated_at_ms, ttl_ms
+         FROM _smithers_memory_facts
+         WHERE (? IS NULL OR namespace = ?)
+         ORDER BY namespace, key`, [ns, ns]));
+    }
+    // ---------------------------------------------------------------------------
+    // Docs (tickets / plans / specs / proposals)
+    // ---------------------------------------------------------------------------
+    /**
+   * List LIVE docs from `_smithers_docs` (tombstones — `deleted_at_ms IS NOT
+   * NULL` — are NEVER returned), optionally scoped to one `kind`. Backs the
+   * gateway's `listTickets` RPC and the file-watcher's reconcile read. Columns
+   * are snake→camel cased by the storage layer (`content_hash → contentHash`,
+   * etc.); newest-updated first so the surface shows recent edits on top.
+   * @param {string | null | { kind?: string; includeDeleted?: boolean; updatedAfterMs?: number; limit?: number }} [arg]
+   *   Either a positional `kind` filter (string) or an options object.
+   * @returns {RunnableEffect<Array<Record<string, unknown>>, SmithersError>}
+   */
+    listDocs(arg = null) {
+        const options = typeof arg === "string" ? { kind: arg } : (arg ?? {});
+        const clauses = [];
+        const params = [];
+        if (!options.includeDeleted) {
+            clauses.push("deleted_at_ms IS NULL");
+        }
+        if (options.kind) {
+            clauses.push("kind = ?");
+            params.push(options.kind);
+        }
+        if (typeof options.updatedAfterMs === "number" && Number.isFinite(options.updatedAfterMs)) {
+            clauses.push("updated_at_ms > ?");
+            params.push(Math.floor(options.updatedAfterMs));
+        }
+        const whereSql = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limit = Math.max(1, Math.min(10_000, Math.floor(options.limit ?? 4_096)));
+        // Newest-updated first so when the doc set exceeds the cap the LIMIT keeps
+        // the most recent edits (the gateway re-sorts before serving).
+        return this.read("list docs", () => this.internalStorage.queryAll(`SELECT path, kind, content, content_hash, status, updated_at_ms, deleted_at_ms
+         FROM _smithers_docs
+         ${whereSql}
+         ORDER BY updated_at_ms DESC, path ASC
+         LIMIT ?`, [...params, limit]));
+    }
+    /**
+   * Read a single doc row by path (INCLUDING a tombstone, so the watcher's
+   * last-write-wins can compare against a soft-deleted row). Returns `undefined`
+   * when the path was never written.
+   * @param {string} path
+   * @returns {RunnableEffect<Record<string, unknown> | undefined, SmithersError>}
+   */
+    getDoc(path, options = {}) {
+        // Returns a tombstone by default (the watcher's last-write-wins compares
+        // against soft-deleted rows). Pass `includeDeleted: false` to hide them.
+        const filter = options.includeDeleted === false ? " AND deleted_at_ms IS NULL" : "";
+        return this.read(`get doc ${path}`, () => this.internalStorage.queryOne(`SELECT path, kind, content, content_hash, status, updated_at_ms, deleted_at_ms
+         FROM _smithers_docs
+         WHERE path = ?${filter}`, [path]));
+    }
+    /**
+   * Upsert a doc row (insert-or-replace by `path`). The caller supplies the
+   * already-computed `contentHash` (`sha256(content)`) and `updatedAtMs` so the
+   * RPC handler and the file-watcher hash/stamp identically. Writing a row with
+   * `deletedAtMs: null` REVIVES a previously soft-deleted path (a re-create or a
+   * fresh file write), which is the intended last-write-wins behaviour.
+   * @param {Record<string, unknown>} row
+   * @returns {RunnableEffect<void, SmithersError>}
+   */
+    upsertDoc(row) {
+        return this.write(`upsert doc ${row.path}`, () => this.internalStorage.upsert("_smithers_docs", row, ["path"], ["kind", "content", "contentHash", "status", "updatedAtMs", "deletedAtMs"]));
+    }
+    /**
+   * Soft-delete a doc by stamping `deleted_at_ms` (a tombstone) rather than
+   * removing the row, so `listTickets` hides it while the watcher can still see
+   * it survived. `updated_at_ms` is bumped so the change orders correctly.
+   * @param {string} path
+   * @param {number} deletedAtMs
+   * @returns {RunnableEffect<void, SmithersError>}
+   */
+    softDeleteDoc(path, deletedAtMs) {
+        return this.write(`soft delete doc ${path}`, () => this.internalStorage.updateWhere("_smithers_docs", { deletedAtMs, updatedAtMs: deletedAtMs }, "path = ?", [path]));
+    }
+    // ---------------------------------------------------------------------------
     // Scorer results
     // ---------------------------------------------------------------------------
     /**

package/src/assertJsonPayloadWithinBounds.js

@@ -17,7 +17,7 @@ function validateJsonValue(field, value, bounds, path, seen) {
     if (typeof value === "string") {
         if (typeof bounds.maxStringLength === "number" &&
             value.length > bounds.maxStringLength) {
-            throw new SmithersError("INVALID_INPUT", `${field} contains a string exceeding ${bounds.maxStringLength} characters.`, {
+            throw new SmithersError("INVALID_INPUT", `${field} contains a string exceeding ${bounds.maxStringLength} characters (at ${path}: ${value.length} characters).`, {
                 field,
                 path,
                 maxLength: bounds.maxStringLength,

package/src/assertNoReservedColumns.js

@@ -0,0 +1,38 @@
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+import { camelToSnake } from "./utils/camelToSnake.js";
+
+const OUTPUT_RESERVED = new Set(["run_id", "node_id", "iteration"]);
+const INPUT_RESERVED = new Set(["run_id"]);
+
+/**
+ * Throw a clear error if a user schema field collides with a smithers internal
+ * key column. Output tables reserve `run_id`/`node_id`/`iteration`; input tables
+ * reserve only `run_id`. Without this guard a colliding field either crashes DDL
+ * with a raw `duplicate column name` (the SQL path) or silently overwrites the
+ * internal key column and corrupts the composite primary key (the drizzle path),
+ * with no diagnostic naming the offending field.
+ *
+ * @param {{ shape?: Record<string, unknown> }} schema
+ * @param {string} [tableName]
+ * @param {{ isInput?: boolean }} [opts]
+ * @returns {void}
+ */
+export function assertNoReservedColumns(schema, tableName, opts) {
+    const shape = schema?.shape;
+    if (!shape || typeof shape !== "object")
+        return;
+    const reserved = opts?.isInput ? INPUT_RESERVED : OUTPUT_RESERVED;
+    // camelToSnake handles both camelCase and already-snake keys
+    // (camelToSnake("node_id") === "node_id"), so one snake-set check catches
+    // `nodeId` AND a literal `node_id`.
+    const offenders = Object.keys(shape).filter((key) => reserved.has(camelToSnake(key)));
+    if (offenders.length === 0)
+        return;
+    const where = tableName ? ` for "${tableName}"` : "";
+    const reservedList = opts?.isInput
+        ? "run_id (camelCase runId)"
+        : "run_id, node_id and iteration (camelCase runId/nodeId/iteration)";
+    throw new SmithersError("INVALID_INPUT", `${opts?.isInput ? "Input" : "Output"} schema${where} uses reserved field name(s): ${offenders.join(", ")}. ` +
+        `smithers persists every ${opts?.isInput ? "input" : "node output"} with internal column(s) ${reservedList}. ` +
+        `Rename the conflicting field(s) - e.g. nodeId -> targetNodeId, runId -> sourceRunId, iteration -> attempt.`, { table: tableName, offenders });
+}

package/src/dialect.js

@@ -24,14 +24,6 @@
 export const SQLITE = /** @type {const} */ ("sqlite");
 export const POSTGRES = /** @type {const} */ ("postgres");
 
-/**
- * @param {unknown} value
- * @returns {value is Dialect}
- */
-export function isDialect(value) {
-    return value === SQLITE || value === POSTGRES;
-}
-
 /**
  * @param {string} identifier
  * @returns {string}
@@ -131,8 +123,8 @@ export function translatePlaceholders(dialect, sql) {
 
 /**
  * Map a single SQLite column type keyword (`INTEGER`, `REAL`, `BLOB`, `TEXT`) to
- * the dialect equivalent. Used by the Zod→DDL generator, which only ever emits
- * `INTEGER` or `TEXT`.
+ * the dialect equivalent. Used by the Zod→DDL generator for schema-derived
+ * columns such as `INTEGER`, `REAL`, and `TEXT`.
  *
  * @param {Dialect} dialect
  * @param {string} sqliteType
@@ -177,27 +169,6 @@ export function translateDdl(dialect, ddl) {
         .replace(/\bINTEGER\b/gi, "BIGINT");
 }
 
-/**
- * SQL that lists the column names of a table, normalized to rows shaped
- * `{ name: string }`.
- *
- * @param {Dialect} dialect
- * @param {string} table
- * @returns {{ sql: string; params: ReadonlyArray<string> }}
- */
-export function tableColumnsSql(dialect, table) {
-    if (dialect === POSTGRES) {
-        return {
-            sql: "SELECT column_name AS name FROM information_schema.columns WHERE table_name = ? AND table_schema = current_schema()",
-            params: [table],
-        };
-    }
-    return {
-        sql: `PRAGMA table_info(${quoteIdentifier(table)})`,
-        params: [],
-    };
-}
-
 /**
  * The statement that begins a write transaction. SQLite takes the write lock
  * eagerly with `BEGIN IMMEDIATE`; PostgreSQL uses a plain `BEGIN`.