@multiplier-labs/stepflow 0.3.4 → 0.3.6

package/src/storage/sqlite.ts

@@ -1,717 +0,0 @@
-/**
- * SQLite storage adapter using better-sqlite3.
- *
- * Provides durable persistence for workflow runs, steps, and events.
- *
- * ## Module layout
- *
- *   - `SQLiteStorageAdapter` (this file) owns the better-sqlite3 connection,
- *     the prepared-statement cache, and every method on `StorageAdapter`. It
- *     is the only adapter class — unlike the Postgres adapter there is no
- *     transaction-scoped twin, so no abstract CRUD base class is required.
- *
- *   - `sqlite-core.ts` holds the pure row-type interfaces and row mappers
- *     (`mapRunRow`, `mapStepRow`, `mapEventRow`). The mappers route every
- *     JSON-column parse through `safeParseField` / `safeParseOptionalField`
- *     in `src/utils/safe-json.ts`, sharing the corruption-counter +
- *     structured-warn behavior with the Postgres core (audit M2 / L3,
- *     PR #52). The split mirrors `postgres-core.ts` so both adapters
- *     expose mappers in the same shape.
- */
-
-import type Database from 'better-sqlite3';
-import { generateId } from '../utils/id';
-import type {
-  StorageAdapter,
-  WorkflowRunRecord,
-  WorkflowRunStepRecord,
-  WorkflowEventRecord,
-  ListRunsOptions,
-  ListEventsOptions,
-  PaginatedResult,
-} from './types';
-import type { Logger } from '../core/types';
-import { sanitizeErrorForStorage } from '../utils/logger';
-import type { MapperContext } from '../utils/safe-json';
-import {
-  mapRunRow,
-  mapStepRow,
-  mapEventRow,
-  type SQLiteRunRow,
-  type SQLiteStepRow,
-  type SQLiteEventRow,
-} from './sqlite-core';
-
-// ============================================================================
-// Schema SQL
-// ============================================================================
-
-/**
- * SQL statements to create the workflow tables.
- * These create the workflow tables in your database.
- */
-const CREATE_TABLES_SQL = `
--- Workflow runs table
-CREATE TABLE IF NOT EXISTS workflow_runs (
-  id TEXT PRIMARY KEY,
-  kind TEXT NOT NULL,
-  status TEXT NOT NULL,
-  parent_run_id TEXT,
-  input_json TEXT NOT NULL,
-  metadata_json TEXT NOT NULL,
-  context_json TEXT NOT NULL,
-  completed_steps_json TEXT,
-  error_json TEXT,
-  created_at TEXT NOT NULL,
-  started_at TEXT,
-  finished_at TEXT
-);
-
-CREATE INDEX IF NOT EXISTS idx_workflow_runs_kind_status ON workflow_runs(kind, status);
-CREATE INDEX IF NOT EXISTS idx_workflow_runs_parent ON workflow_runs(parent_run_id);
-CREATE INDEX IF NOT EXISTS idx_workflow_runs_created ON workflow_runs(created_at);
-CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
-
--- Workflow run steps table
-CREATE TABLE IF NOT EXISTS workflow_run_steps (
-  id TEXT PRIMARY KEY,
-  run_id TEXT NOT NULL,
-  step_key TEXT NOT NULL,
-  step_name TEXT,
-  status TEXT NOT NULL,
-  attempt INTEGER NOT NULL DEFAULT 1,
-  result_json TEXT,
-  error_json TEXT,
-  started_at TEXT,
-  finished_at TEXT,
-  FOREIGN KEY (run_id) REFERENCES workflow_runs(id) ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS idx_workflow_run_steps_run ON workflow_run_steps(run_id);
-CREATE INDEX IF NOT EXISTS idx_workflow_run_steps_run_key ON workflow_run_steps(run_id, step_key);
-
--- Workflow events table
-CREATE TABLE IF NOT EXISTS workflow_events (
-  id TEXT PRIMARY KEY,
-  run_id TEXT NOT NULL,
-  step_key TEXT,
-  event_type TEXT NOT NULL,
-  level TEXT NOT NULL,
-  payload_json TEXT,
-  timestamp TEXT NOT NULL,
-  FOREIGN KEY (run_id) REFERENCES workflow_runs(id) ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS idx_workflow_events_run ON workflow_events(run_id);
-CREATE INDEX IF NOT EXISTS idx_workflow_events_run_ts ON workflow_events(run_id, timestamp);
-`;
-
-/**
- * Columns added to {@link CREATE_TABLES_SQL} after the initial schema, expressed
- * as `ALTER TABLE ADD COLUMN` migrations. SQLite's `CREATE TABLE IF NOT EXISTS`
- * does not reconcile column lists against existing tables, so a deploy that ran
- * an older version of this adapter will be missing any column added later. The
- * adapter applies these on startup so existing databases stay usable across
- * upgrades.
- *
- * Append-only: SQLite does not support DROP COLUMN or general ALTER COLUMN, so
- * removing or changing an entry here would break upgrades from older versions.
- * Only add new entries when a column is added to {@link CREATE_TABLES_SQL}.
- */
-const SCHEMA_MIGRATIONS: ReadonlyArray<{ table: string; column: string; type: string }> = [
-  { table: 'workflow_runs', column: 'completed_steps_json', type: 'TEXT' },
-];
-
-// ============================================================================
-// Configuration
-// ============================================================================
-
-/**
- * Configuration options for the SQLite storage adapter.
- */
-export interface SQLiteStorageConfig {
-  /**
-   * The better-sqlite3 database instance.
-   * Can be an in-memory database (`:memory:`) or a file path.
-   */
-  db: Database.Database;
-
-  /**
-   * Whether to automatically create tables on initialization.
-   * Default: true
-   */
-  autoCreateTables?: boolean;
-
-  /**
-   * @deprecated This option is not currently supported and will be ignored.
-   * Table names are always prefixed with 'workflow_'.
-   */
-  tablePrefix?: string;
-
-  /**
-   * Optional structured logger used to surface JSON corruption events.
-   * Without one, parse failures still increment the corruption counter
-   * exposed via `getJsonParseCorruptionCount()` but produce no log output.
-   */
-  logger?: Logger;
-}
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/**
- * better-sqlite3 raises `SqliteError { code: 'SQLITE_ERROR', message:
- * 'duplicate column name: <name>' }` when an `ALTER TABLE ADD COLUMN` targets
- * a column that already exists. Treat that as a benign no-op so concurrent
- * startups (or any race between the {@link runMigrations} existence check and
- * the ALTER) don't crash. All other errors propagate.
- */
-function isDuplicateColumnError(err: unknown): boolean {
-  if (!err || typeof err !== 'object') return false;
-  const code = (err as { code?: unknown }).code;
-  const message = (err as { message?: unknown }).message;
-  return (
-    code === 'SQLITE_ERROR' &&
-    typeof message === 'string' &&
-    message.toLowerCase().includes('duplicate column name')
-  );
-}
-
-/**
- * Resolve to `true` if `p` settles within a few microtask ticks of being
- * inspected, otherwise `false`. Used by the deprecated async `transaction()`
- * to detect callbacks that suspend on real async I/O — by the time we ask,
- * the synchronous COMMIT has already run, so a still-pending promise means
- * any post-await operations land outside the transaction.
- */
-async function isPromiseSettled(p: Promise<unknown>): Promise<boolean> {
-  let settled = false;
-  p.then(
-    () => {
-      settled = true;
-    },
-    () => {
-      settled = true;
-    }
-  );
-  // Drain a handful of microtask ticks. `await Promise.resolve()` callbacks
-  // and other already-resolved continuations finish in 1-2 ticks; anything
-  // still pending after this is doing real async I/O (timers, network, etc.).
-  for (let i = 0; i < 5 && !settled; i++) {
-    await Promise.resolve();
-  }
-  return settled;
-}
-
-// ============================================================================
-// SQLite Storage Adapter
-// ============================================================================
-
-/**
- * SQLite implementation of StorageAdapter using better-sqlite3.
- *
- * Features:
- * - Synchronous operations (better-sqlite3 is sync by design)
- * - Automatic table creation
- * - Transaction support
- * - Customizable table prefix
- *
- * @example
- * ```typescript
- * import Database from 'better-sqlite3';
- * import { SQLiteStorageAdapter } from 'stepflow/storage';
- *
- * const db = new Database('./workflows.db');
- * const storage = new SQLiteStorageAdapter({ db });
- *
- * const engine = new WorkflowEngine({ storage });
- * ```
- */
-export class SQLiteStorageAdapter implements StorageAdapter {
-  private db: Database.Database;
-  private prefix: string;
-  private logger: Logger | undefined;
-
-  // Prepared statements (cached for performance)
-  private stmts: {
-    insertRun: Database.Statement;
-    getRun: Database.Statement;
-    updateRun: Database.Statement;
-    listRuns: Database.Statement;
-    countRuns: Database.Statement;
-    insertStep: Database.Statement;
-    getStep: Database.Statement;
-    updateStep: Database.Statement;
-    getStepsForRun: Database.Statement;
-    insertEvent: Database.Statement;
-    getEventsForRun: Database.Statement;
-    deleteOldRuns: Database.Statement;
-    deleteStepsForRuns: Database.Statement;
-    deleteEventsForRuns: Database.Statement;
-    getInterruptedRuns: Database.Statement;
-    getLastCompletedStep: Database.Statement;
-  } | null = null;
-
-  constructor(config: SQLiteStorageConfig) {
-    this.db = config.db;
-    this.prefix = config.tablePrefix ?? 'workflow';
-    this.logger = config.logger;
-
-    // Enable foreign keys
-    this.db.pragma('foreign_keys = ON');
-
-    // Create tables if needed
-    if (config.autoCreateTables !== false) {
-      this.createTables();
-    }
-
-    // Always reconcile column-level migrations: the prepared statements below
-    // reference the latest schema, so an adapter sitting on top of an older
-    // table layout (e.g., a database created by a previous version, or a
-    // caller-managed schema with `autoCreateTables: false` that has not been
-    // hand-upgraded) would crash on the first INSERT/SELECT. Migrations are
-    // idempotent and skip tables that don't exist.
-    this.runMigrations();
-
-    // Prepare statements
-    this.prepareStatements();
-  }
-
-  /**
-   * Create the workflow tables if they don't exist.
-   */
-  private createTables(): void {
-    this.db.exec(CREATE_TABLES_SQL);
-  }
-
-  /**
-   * Apply additive schema migrations to existing tables.
-   *
-   * `CREATE TABLE IF NOT EXISTS` is a no-op when the table already exists, so
-   * any column added to {@link CREATE_TABLES_SQL} after the initial schema is
-   * silently absent on databases created by older versions of this adapter.
-   * Without this step, the first INSERT/SELECT crashes with
-   * `SqliteError: table X has no column named Y`. This mirrors the
-   * `ALTER TABLE ADD COLUMN IF NOT EXISTS` block in `postgres.ts`'s
-   * `createTables()`.
-   *
-   * For each entry in {@link SCHEMA_MIGRATIONS}: if the table exists and the
-   * column does not, run `ALTER TABLE ADD COLUMN`. The ALTER is wrapped in a
-   * try/catch that tolerates `duplicate column` errors so concurrent startups
-   * (or any race between the existence check and the ALTER) do not crash.
-   * Other SQLite errors propagate.
-   */
-  private runMigrations(): void {
-    for (const { table, column, type } of SCHEMA_MIGRATIONS) {
-      const tableInfo = this.db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
-      // PRAGMA table_info on a missing table returns []; CREATE TABLE handles that case.
-      if (tableInfo.length === 0) continue;
-      if (tableInfo.some((col) => col.name === column)) continue;
-
-      try {
-        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
-      } catch (err) {
-        if (isDuplicateColumnError(err)) continue;
-        throw err;
-      }
-    }
-  }
-
-  /**
-   * Prepare all SQL statements for better performance.
-   */
-  private prepareStatements(): void {
-    this.stmts = {
-      insertRun: this.db.prepare(`
-        INSERT INTO workflow_runs (id, kind, status, parent_run_id, input_json, metadata_json, context_json, completed_steps_json, error_json, created_at, started_at, finished_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `),
-      getRun: this.db.prepare(`
-        SELECT * FROM workflow_runs WHERE id = ?
-      `),
-      updateRun: this.db.prepare(`
-        UPDATE workflow_runs
-        SET status = COALESCE(?, status),
-            context_json = COALESCE(?, context_json),
-            completed_steps_json = COALESCE(?, completed_steps_json),
-            error_json = COALESCE(?, error_json),
-            started_at = COALESCE(?, started_at),
-            finished_at = COALESCE(?, finished_at)
-        WHERE id = ?
-      `),
-      // json_each() is a SQLite table-valued function that expands a JSON array into rows.
-      // We use it here to support filtering by multiple statuses in a single prepared statement:
-      // the caller passes a JSON array like '["running","failed"]', and json_each unpacks it
-      // so the IN clause can match against each value. When status is NULL, the entire
-      // condition is bypassed via the (? IS NULL OR ...) guard.
-      listRuns: this.db.prepare(`
-        SELECT * FROM workflow_runs
-        WHERE (? IS NULL OR kind = ?)
-          AND (? IS NULL OR status IN (SELECT value FROM json_each(?)))
-          AND (? IS NULL OR parent_run_id = ?)
-        ORDER BY created_at DESC
-        LIMIT ? OFFSET ?
-      `),
-      countRuns: this.db.prepare(`
-        SELECT COUNT(*) as count FROM workflow_runs
-        WHERE (? IS NULL OR kind = ?)
-          AND (? IS NULL OR status IN (SELECT value FROM json_each(?)))
-          AND (? IS NULL OR parent_run_id = ?)
-      `),
-      insertStep: this.db.prepare(`
-        INSERT INTO workflow_run_steps (id, run_id, step_key, step_name, status, attempt, result_json, error_json, started_at, finished_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `),
-      getStep: this.db.prepare(`
-        SELECT * FROM workflow_run_steps WHERE id = ?
-      `),
-      updateStep: this.db.prepare(`
-        UPDATE workflow_run_steps
-        SET status = COALESCE(?, status),
-            attempt = COALESCE(?, attempt),
-            result_json = COALESCE(?, result_json),
-            error_json = COALESCE(?, error_json),
-            finished_at = COALESCE(?, finished_at)
-        WHERE id = ?
-      `),
-      getStepsForRun: this.db.prepare(`
-        SELECT * FROM workflow_run_steps WHERE run_id = ? ORDER BY started_at ASC
-      `),
-      insertEvent: this.db.prepare(`
-        INSERT INTO workflow_events (id, run_id, step_key, event_type, level, payload_json, timestamp)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `),
-      getEventsForRun: this.db.prepare(`
-        SELECT * FROM workflow_events
-        WHERE run_id = ?
-          AND (? IS NULL OR step_key = ?)
-          AND (? IS NULL OR level = ?)
-        ORDER BY timestamp ASC
-        LIMIT ? OFFSET ?
-      `),
-      deleteOldRuns: this.db.prepare(`
-        DELETE FROM workflow_runs WHERE created_at < ?
-      `),
-      deleteStepsForRuns: this.db.prepare(`
-        DELETE FROM workflow_run_steps WHERE run_id IN (SELECT id FROM workflow_runs WHERE created_at < ?)
-      `),
-      deleteEventsForRuns: this.db.prepare(`
-        DELETE FROM workflow_events WHERE run_id IN (SELECT id FROM workflow_runs WHERE created_at < ?)
-      `),
-      getInterruptedRuns: this.db.prepare(`
-        SELECT * FROM workflow_runs
-        WHERE status IN ('queued', 'running')
-        ORDER BY created_at ASC
-      `),
-      getLastCompletedStep: this.db.prepare(`
-        SELECT * FROM workflow_run_steps
-        WHERE run_id = ? AND status = 'succeeded'
-        ORDER BY finished_at DESC
-        LIMIT 1
-      `),
-    };
-  }
-
-  // ============================================================================
-  // Run Operations
-  // ============================================================================
-
-  async createRun(run: Omit<WorkflowRunRecord, 'id' | 'createdAt'>): Promise<WorkflowRunRecord> {
-    const id = generateId();
-    const createdAt = new Date();
-
-    this.stmts!.insertRun.run(
-      id,
-      run.kind,
-      run.status,
-      run.parentRunId ?? null,
-      JSON.stringify(run.input),
-      JSON.stringify(run.metadata),
-      JSON.stringify(run.context),
-      run.completedSteps ? JSON.stringify(run.completedSteps) : null,
-      run.error ? JSON.stringify(sanitizeErrorForStorage(run.error)) : null,
-      createdAt.toISOString(),
-      run.startedAt?.toISOString() ?? null,
-      run.finishedAt?.toISOString() ?? null
-    );
-
-    return {
-      ...run,
-      id,
-      createdAt,
-    };
-  }
-
-  async getRun(runId: string): Promise<WorkflowRunRecord | null> {
-    const row = this.stmts!.getRun.get(runId) as SQLiteRunRow | undefined;
-    return row ? mapRunRow(row, this.mapperCtx) : null;
-  }
-
-  async updateRun(runId: string, updates: Partial<WorkflowRunRecord>): Promise<void> {
-    this.stmts!.updateRun.run(
-      updates.status ?? null,
-      updates.context ? JSON.stringify(updates.context) : null,
-      updates.completedSteps ? JSON.stringify(updates.completedSteps) : null,
-      updates.error ? JSON.stringify(sanitizeErrorForStorage(updates.error)) : null,
-      updates.startedAt?.toISOString() ?? null,
-      updates.finishedAt?.toISOString() ?? null,
-      runId
-    );
-  }
-
-  async listRuns(options: ListRunsOptions = {}): Promise<PaginatedResult<WorkflowRunRecord>> {
-    const limit = options.limit ?? 50;
-    const offset = options.offset ?? 0;
-    const kind = options.kind ?? null;
-    const status = options.status ?? null;
-    const statusJson = status ? JSON.stringify(Array.isArray(status) ? status : [status]) : null;
-    const parentRunId = options.parentRunId ?? null;
-
-    const rows = this.stmts!.listRuns.all(
-      kind, kind,
-      statusJson, statusJson,
-      parentRunId, parentRunId,
-      limit, offset
-    ) as SQLiteRunRow[];
-
-    const countResult = this.stmts!.countRuns.get(
-      kind, kind,
-      statusJson, statusJson,
-      parentRunId, parentRunId
-    ) as { count: number };
-
-    return {
-      items: rows.map(row => mapRunRow(row, this.mapperCtx)),
-      total: countResult.count,
-      limit,
-      offset,
-    };
-  }
-
-  // ============================================================================
-  // Step Operations
-  // ============================================================================
-
-  async createStep(step: Omit<WorkflowRunStepRecord, 'id'>): Promise<WorkflowRunStepRecord> {
-    const id = generateId();
-
-    this.stmts!.insertStep.run(
-      id,
-      step.runId,
-      step.stepKey,
-      step.stepName,
-      step.status,
-      step.attempt,
-      step.result !== undefined ? JSON.stringify(step.result) : null,
-      step.error ? JSON.stringify(sanitizeErrorForStorage(step.error)) : null,
-      step.startedAt?.toISOString() ?? null,
-      step.finishedAt?.toISOString() ?? null
-    );
-
-    return { ...step, id };
-  }
-
-  async getStep(stepId: string): Promise<WorkflowRunStepRecord | null> {
-    const row = this.stmts!.getStep.get(stepId) as SQLiteStepRow | undefined;
-    return row ? mapStepRow(row, this.mapperCtx) : null;
-  }
-
-  async updateStep(stepId: string, updates: Partial<WorkflowRunStepRecord>): Promise<void> {
-    this.stmts!.updateStep.run(
-      updates.status ?? null,
-      updates.attempt ?? null,
-      updates.result !== undefined ? JSON.stringify(updates.result) : null,
-      updates.error ? JSON.stringify(sanitizeErrorForStorage(updates.error)) : null,
-      updates.finishedAt?.toISOString() ?? null,
-      stepId
-    );
-  }
-
-  async getStepsForRun(runId: string): Promise<WorkflowRunStepRecord[]> {
-    const rows = this.stmts!.getStepsForRun.all(runId) as SQLiteStepRow[];
-    return rows.map(row => mapStepRow(row, this.mapperCtx));
-  }
-
-  // ============================================================================
-  // Event Operations
-  // ============================================================================
-
-  async saveEvent(event: Omit<WorkflowEventRecord, 'id'>): Promise<void> {
-    const id = generateId();
-
-    this.stmts!.insertEvent.run(
-      id,
-      event.runId,
-      event.stepKey ?? null,
-      event.eventType,
-      event.level,
-      event.payload !== undefined ? JSON.stringify(event.payload) : null,
-      event.timestamp.toISOString()
-    );
-  }
-
-  async getEventsForRun(runId: string, options: ListEventsOptions = {}): Promise<WorkflowEventRecord[]> {
-    const limit = options.limit ?? 1000;
-    const offset = options.offset ?? 0;
-    const stepKey = options.stepKey ?? null;
-    const level = options.level ?? null;
-
-    const rows = this.stmts!.getEventsForRun.all(
-      runId,
-      stepKey, stepKey,
-      level, level,
-      limit, offset
-    ) as SQLiteEventRow[];
-
-    return rows.map(row => mapEventRow(row, this.mapperCtx));
-  }
-
-  // ============================================================================
-  // Transaction Support
-  // ============================================================================
-
-  /**
-   * Execute a function within a database transaction (async interface).
-   *
-   * @deprecated Use {@link transactionSync} instead. better-sqlite3 transactions
-   * are synchronous: COMMIT happens the moment the callback returns control to
-   * `db.transaction(fn)()`. If the callback awaits real async I/O (network,
-   * timers, etc.), the COMMIT has already happened by the time the awaited work
-   * runs, so its operations are **not** transactional.
-   *
-   * To make the footgun visible the adapter installs a runtime guard: when the
-   * callback's promise has not settled by the time the COMMIT returns, the
-   * deprecated method emits a `console.warn` so that the misuse surfaces in
-   * production logs. The promise is still returned so existing callers keep
-   * working — switch to `transactionSync` to silence the warning.
-   */
-  async transaction<T>(fn: (tx: StorageAdapter) => Promise<T>): Promise<T> {
-    let fnPromise!: Promise<T>;
-    this.transactionSync(() => {
-      fnPromise = fn(this);
-    });
-
-    // COMMIT has already executed at this point. If the callback's promise is
-    // still pending, the callback is doing async work outside the transaction
-    // boundary — log a warning so the misuse is visible in production logs.
-    if (!(await isPromiseSettled(fnPromise))) {
-      console.warn(
-        '[SQLiteStorageAdapter] transaction() callback did not settle synchronously. ' +
-        'better-sqlite3 transactions are synchronous and the COMMIT has already executed; ' +
-        'any async work inside the callback is NOT transactional. ' +
-        'Use transactionSync() with purely synchronous operations instead.'
-      );
-    }
-
-    return fnPromise;
-  }
-
-  /**
-   * Execute a synchronous transaction (preferred for better-sqlite3).
-   * Use this when you need transaction guarantees.
-   *
-   * @example
-   * ```typescript
-   * storage.transactionSync(() => {
-   *   // Multiple operations in a single transaction
-   *   const run = storage.createRunSync(...);
-   *   storage.updateRunSync(run.id, ...);
-   * });
-   * ```
-   */
-  transactionSync<T>(fn: () => T): T {
-    return this.db.transaction(fn)();
-  }
-
-  // ============================================================================
-  // Cleanup Operations
-  // ============================================================================
-
-  /**
-   * Delete runs older than the specified date.
-   * Also deletes associated steps and events (via CASCADE).
-   */
-  async deleteOldRuns(olderThan: Date): Promise<number> {
-    const isoDate = olderThan.toISOString();
-
-    // Due to CASCADE, steps and events are deleted automatically
-    // But we do it explicitly for databases without CASCADE support
-    return this.db.transaction(() => {
-      this.stmts!.deleteEventsForRuns.run(isoDate);
-      this.stmts!.deleteStepsForRuns.run(isoDate);
-      const result = this.stmts!.deleteOldRuns.run(isoDate);
-      return result.changes;
-    })();
-  }
-
-  // ============================================================================
-  // Resume Support
-  // ============================================================================
-
-  /**
-   * Get all runs that were interrupted (status is 'running' or 'queued').
-   * These runs can potentially be resumed.
-   */
-  async getInterruptedRuns(): Promise<WorkflowRunRecord[]> {
-    const rows = this.stmts!.getInterruptedRuns.all() as SQLiteRunRow[];
-    return rows.map(row => mapRunRow(row, this.mapperCtx));
-  }
-
-  /**
-   * Get the last completed step for a run.
-   * Useful for resuming from a checkpoint.
-   */
-  async getLastCompletedStep(runId: string): Promise<WorkflowRunStepRecord | null> {
-    const row = this.stmts!.getLastCompletedStep.get(runId) as SQLiteStepRow | undefined;
-    return row ? mapStepRow(row, this.mapperCtx) : null;
-  }
-
-  // ============================================================================
-  // Row Mapping
-  // ============================================================================
-  //
-  // The pure row mappers (`mapRunRow`, `mapStepRow`, `mapEventRow`) live in
-  // `./sqlite-core.ts`. Each call site here builds a `MapperContext` once via
-  // `this.mapperCtx` and hands it to the mapper, which extends it with
-  // `rowId` + `column` per JSON-parse so corruption logs identify the bad row
-  // (audit M2 / L3 — PR #52).
-
-  /** Mapper context paired with the adapter's component label + optional logger. */
-  private get mapperCtx(): MapperContext {
-    return { component: 'SQLiteStorageAdapter', logger: this.logger };
-  }
-
-  // ============================================================================
-  // Utility Methods
-  // ============================================================================
-
-  /**
-   * Close the database connection.
-   */
-  close(): void {
-    this.db.close();
-  }
-
-  /**
-   * Get database statistics.
-   */
-  getStats(): { runs: number; steps: number; events: number } {
-    const runsCount = this.db.prepare('SELECT COUNT(*) as count FROM workflow_runs').get() as { count: number };
-    const stepsCount = this.db.prepare('SELECT COUNT(*) as count FROM workflow_run_steps').get() as { count: number };
-    const eventsCount = this.db.prepare('SELECT COUNT(*) as count FROM workflow_events').get() as { count: number };
-
-    return {
-      runs: runsCount.count,
-      steps: stepsCount.count,
-      events: eventsCount.count,
-    };
-  }
-}
-
-// ============================================================================
-// SQLite Row Types
-// ============================================================================
-//
-// `SQLiteRunRow`, `SQLiteStepRow`, and `SQLiteEventRow` now live in
-// `./sqlite-core.ts` alongside their pure row mappers.