@yieldstar/sqlite-runtime 0.5.0

package/dist/index-x891hxwg.js

@@ -0,0 +1,796 @@
+// src/dao/step-response-dao.ts
+class StepResponsesDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS step_responses (
+        execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        step_attempt INTEGER NOT NULL,
+        step_done BOOL NOT NULL,
+        step_response JSONB,
+        PRIMARY KEY (execution_id, step_key, step_attempt)
+      );
+      CREATE INDEX IF NOT EXISTS idx_execution_step_attempt 
+      ON step_responses(execution_id, step_key, step_attempt DESC);
+    `);
+  }
+  getAllSteps() {
+    const query = this.db.query(`SELECT * FROM step_responses`);
+    return query.all();
+  }
+  deleteAll() {
+    const query = this.db.query(`DELETE FROM step_responses`);
+    query.run();
+  }
+  getLatestStepResponse(executionId, stepKey) {
+    const query = this.db.query(`SELECT * FROM step_responses 
+       WHERE execution_id = $executionId 
+       AND step_key = $stepKey
+       ORDER BY step_attempt DESC LIMIT 1`);
+    const result = query.get({
+      $executionId: executionId,
+      $stepKey: stepKey
+    });
+    return result;
+  }
+  insertStepResponse(executionId, stepKey, stepAttempt, stepDone, stepResponseJson) {
+    const query = this.db.query(`INSERT INTO step_responses (execution_id, step_key, step_attempt, step_done, step_response) 
+        VALUES ($executionId, $stepKey, $stepAttempt, $stepDone, $stepResponse)`);
+    query.run({
+      $executionId: executionId,
+      $stepKey: stepKey,
+      $stepAttempt: stepAttempt,
+      $stepDone: stepDone,
+      $stepResponse: stepResponseJson
+    });
+  }
+}
+
+// src/sqlite-heap.ts
+class SqliteHeapClient {
+  stepResponsesDao;
+  constructor(db) {
+    this.stepResponsesDao = new StepResponsesDao(db);
+  }
+  async getAllSteps() {
+    return this.stepResponsesDao.getAllSteps();
+  }
+  async deleteAll() {
+    this.stepResponsesDao.deleteAll();
+  }
+  async readStep(params) {
+    const result = this.stepResponsesDao.getLatestStepResponse(params.executionId, params.stepKey);
+    if (!result?.step_response) {
+      return null;
+    }
+    return {
+      stepResponseJson: result.step_response,
+      meta: {
+        attempt: result.step_attempt,
+        done: Boolean(result.step_done)
+      }
+    };
+  }
+  async writeStep(params) {
+    this.stepResponsesDao.insertStepResponse(params.executionId, params.stepKey, params.stepAttempt, params.stepDone, params.stepResponseJson);
+  }
+}
+// src/sqlite-store.ts
+import { v7 as uuidv7 } from "uuid";
+import {
+  cloneStoreState,
+  CasStoreClient,
+  storePathsIntersect,
+  validateStoreState
+} from "@yieldstar/core";
+class SqliteStoreClient extends CasStoreClient {
+  db;
+  schedulerClient;
+  writeLock = Promise.resolve();
+  constructor(params) {
+    super();
+    this.db = params.db;
+    this.schedulerClient = params.schedulerClient;
+    this.setupDb();
+    this.enqueueWrite(() => this.drainWakeOutboxBestEffort());
+  }
+  enqueueWrite(fn) {
+    const result = this.writeLock.then(fn, fn);
+    this.writeLock = result.catch(() => {});
+    return result;
+  }
+  async getOrCreateStore(params) {
+    const existing = this.getStoreRow(params.definition.name, params.id);
+    if (existing) {
+      return {
+        state: JSON.parse(existing.state),
+        instanceId: existing.instance_id,
+        version: existing.version
+      };
+    }
+    if (!params.initial) {
+      throw new Error(`Store "${params.definition.name}:${params.id}" does not exist`);
+    }
+    const initialValue = params.initial;
+    const initial = typeof initialValue === "function" ? await initialValue() : initialValue;
+    const state = await validateStoreState(params.definition, initial);
+    return this.enqueueWrite(async () => {
+      this.db.run("BEGIN IMMEDIATE");
+      try {
+        const existingTx = this.getStoreRow(params.definition.name, params.id);
+        if (existingTx) {
+          this.db.run("COMMIT");
+          return {
+            state: JSON.parse(existingTx.state),
+            instanceId: existingTx.instance_id,
+            version: existingTx.version
+          };
+        }
+        const instanceId = uuidv7();
+        this.db.query(`INSERT INTO stores (instance_id, store_name, store_id, version, state)
+             VALUES ($instanceId, $storeName, $storeId, 0, $state)`).run({
+          $instanceId: instanceId,
+          $storeName: params.definition.name,
+          $storeId: params.id,
+          $state: JSON.stringify(state)
+        });
+        this.db.run("COMMIT");
+        return {
+          state: cloneStoreState(state),
+          instanceId,
+          version: 0
+        };
+      } catch (err) {
+        this.db.run("ROLLBACK");
+        throw err;
+      }
+      throw new Error("Store creation transaction returned unexpectedly");
+    });
+  }
+  async getStore(params) {
+    const row = this.getStoreRow(params.definition.name, params.id);
+    if (!row) {
+      throw new Error(`Store "${params.definition.name}:${params.id}" does not exist`);
+    }
+    return {
+      state: JSON.parse(row.state),
+      instanceId: row.instance_id,
+      version: row.version
+    };
+  }
+  async getAppliedStoreStep(params) {
+    const row = this.getAppliedStepRow({
+      storeName: params.definition.name,
+      storeId: params.id,
+      stepId: params.stepId
+    });
+    return row ? { result: JSON.parse(row.result) } : undefined;
+  }
+  commitStoreMutation(mutation) {
+    return this.enqueueWrite(async () => {
+      this.db.run("BEGIN IMMEDIATE");
+      try {
+        if (mutation.stepId) {
+          const applied = this.getAppliedStepRow({
+            storeName: mutation.definition.name,
+            storeId: mutation.id,
+            stepId: mutation.stepId
+          });
+          if (applied) {
+            this.db.run("COMMIT");
+            return {
+              status: "already-applied",
+              result: JSON.parse(applied.result)
+            };
+          }
+        }
+        const row = this.getStoreRow(mutation.definition.name, mutation.id);
+        if (!row) {
+          throw new Error(`Store "${mutation.definition.name}:${mutation.id}" does not exist`);
+        }
+        if (row.instance_id !== mutation.expected.instanceId || row.version !== mutation.expected.version) {
+          this.db.run("COMMIT");
+          return {
+            status: "conflict",
+            snapshot: {
+              state: JSON.parse(row.state),
+              instanceId: row.instance_id,
+              version: row.version
+            }
+          };
+        }
+        const version = mutation.expected.version + 1;
+        const changed = this.db.query(`UPDATE stores
+             SET version = $version, state = $state
+             WHERE instance_id = $instanceId AND version = $expectedVersion`).run({
+          $instanceId: mutation.expected.instanceId,
+          $expectedVersion: mutation.expected.version,
+          $version: version,
+          $state: JSON.stringify(mutation.nextState)
+        });
+        if (Number(changed.changes) !== 1) {
+          throw new Error("Store changed during its mutation transaction");
+        }
+        if (mutation.stepId) {
+          this.insertAppliedStepRow({
+            storeName: mutation.definition.name,
+            storeId: mutation.id,
+            stepId: mutation.stepId,
+            result: JSON.stringify(mutation.result)
+          });
+        }
+        const waiters = this.selectMatchingWaiters({
+          storeName: mutation.definition.name,
+          storeId: mutation.id,
+          version,
+          changedPaths: mutation.changedPaths
+        });
+        for (const waiter of waiters) {
+          this.insertWakeOutboxRow({
+            storeName: mutation.definition.name,
+            storeId: mutation.id,
+            executionId: waiter.executionId,
+            stepKey: waiter.stepKey
+          });
+        }
+        this.db.run("COMMIT");
+      } catch (error) {
+        this.db.run("ROLLBACK");
+        throw error;
+      }
+      await this.drainWakeOutboxBestEffort();
+      return { status: "committed" };
+    });
+  }
+  async listStores(definition) {
+    const rows = this.db.query(`SELECT store_id FROM stores
+         WHERE store_name = $storeName
+         ORDER BY store_id ASC`).all({ $storeName: definition.name });
+    return rows.map((row) => row.store_id);
+  }
+  async deleteStore(params) {
+    return this.enqueueWrite(async () => {
+      const bindings = {
+        $storeName: params.definition.name,
+        $storeId: params.id
+      };
+      this.db.run("BEGIN IMMEDIATE");
+      try {
+        this.db.query(`DELETE FROM stores WHERE store_name = $storeName AND store_id = $storeId`).run(bindings);
+        this.db.query(`DELETE FROM store_waiters WHERE store_name = $storeName AND store_id = $storeId`).run(bindings);
+        this.db.query(`DELETE FROM store_wake_outbox WHERE store_name = $storeName AND store_id = $storeId`).run(bindings);
+        this.db.run("COMMIT");
+      } catch (err) {
+        this.db.run("ROLLBACK");
+        throw err;
+      }
+    });
+  }
+  async deleteStoreFrom(params) {
+    return this.enqueueWrite(async () => {
+      const bindings = {
+        $storeName: params.definition.name,
+        $storeId: params.id
+      };
+      this.db.run("BEGIN IMMEDIATE");
+      try {
+        if (params.stepId) {
+          const applied = this.getAppliedStepRow({
+            storeName: params.definition.name,
+            storeId: params.id,
+            stepId: params.stepId
+          });
+          if (applied) {
+            this.db.run("COMMIT");
+            return JSON.parse(applied.result);
+          }
+        }
+        this.assertSnapshotHasInstanceId(params.snapshot);
+        const row = this.getStoreRow(params.definition.name, params.id);
+        if (!row) {
+          this.db.run("COMMIT");
+          return {
+            deleted: false,
+            reason: "not-found",
+            expectedInstanceId: params.snapshot.instanceId,
+            expectedVersion: params.snapshot.version
+          };
+        }
+        if (row.instance_id !== params.snapshot.instanceId || row.version !== params.snapshot.version) {
+          this.db.run("COMMIT");
+          return {
+            deleted: false,
+            reason: "conflict",
+            expectedInstanceId: params.snapshot.instanceId,
+            actualInstanceId: row.instance_id,
+            expectedVersion: params.snapshot.version,
+            actualVersion: row.version
+          };
+        }
+        this.db.query(`DELETE FROM store_waiters WHERE store_name = $storeName AND store_id = $storeId`).run(bindings);
+        this.db.query(`DELETE FROM store_wake_outbox WHERE store_name = $storeName AND store_id = $storeId`).run(bindings);
+        this.db.query(`DELETE FROM stores WHERE instance_id = $instanceId`).run({ $instanceId: row.instance_id });
+        const result = { deleted: true };
+        if (params.stepId) {
+          this.insertAppliedStepRow({
+            storeName: params.definition.name,
+            storeId: params.id,
+            stepId: params.stepId,
+            result: JSON.stringify(result)
+          });
+        }
+        this.db.run("COMMIT");
+        return result;
+      } catch (err) {
+        this.db.run("ROLLBACK");
+        throw err;
+      }
+    });
+  }
+  async registerWaiter(waiter) {
+    return this.enqueueWrite(async () => {
+      let versionAdvanced = false;
+      this.db.run("BEGIN IMMEDIATE");
+      try {
+        this.db.query(`INSERT INTO store_waiters
+               (workflow_id, execution_id, step_key, event, store_name, store_id, since_version, read_paths)
+             VALUES
+               ($workflowId, $executionId, $stepKey, $event, $storeName, $storeId, $sinceVersion, $readPaths)
+             ON CONFLICT(store_name, store_id, execution_id, step_key)
+             DO UPDATE SET
+               event = excluded.event,
+               since_version = excluded.since_version,
+               read_paths = excluded.read_paths`).run({
+          $workflowId: waiter.workflowId,
+          $executionId: waiter.executionId,
+          $stepKey: waiter.stepKey,
+          $event: JSON.stringify(serializeEvent(waiter.event)),
+          $storeName: waiter.storeName,
+          $storeId: waiter.storeId,
+          $sinceVersion: waiter.sinceVersion,
+          $readPaths: JSON.stringify(waiter.readPaths)
+        });
+        const row = this.getStoreRow(waiter.storeName, waiter.storeId);
+        if (!row || row.instance_id !== waiter.instanceId || row.version > waiter.sinceVersion) {
+          versionAdvanced = true;
+          this.insertWakeOutboxRow({
+            storeName: waiter.storeName,
+            storeId: waiter.storeId,
+            executionId: waiter.executionId,
+            stepKey: waiter.stepKey
+          });
+        }
+        this.db.run("COMMIT");
+      } catch (err) {
+        this.db.run("ROLLBACK");
+        throw err;
+      }
+      if (versionAdvanced) {
+        await this.drainWakeOutboxBestEffort();
+      }
+    });
+  }
+  setupDb() {
+    this.createStoresTable();
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS store_waiters (
+        workflow_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        event TEXT NOT NULL,
+        store_name TEXT NOT NULL,
+        store_id TEXT NOT NULL,
+        since_version INTEGER NOT NULL,
+        read_paths TEXT NOT NULL,
+        PRIMARY KEY (store_name, store_id, execution_id, step_key)
+      );
+
+      CREATE TABLE IF NOT EXISTS store_applied_steps (
+        store_name TEXT NOT NULL,
+        store_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        result TEXT NOT NULL,
+        PRIMARY KEY (store_name, store_id, execution_id, step_key)
+      );
+
+      CREATE TABLE IF NOT EXISTS store_wake_outbox (
+        store_name TEXT NOT NULL,
+        store_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        PRIMARY KEY (store_name, store_id, execution_id, step_key)
+      );
+    `);
+  }
+  createStoresTable() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS stores (
+        instance_id TEXT PRIMARY KEY,
+        store_name TEXT NOT NULL,
+        store_id TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        state TEXT NOT NULL,
+        UNIQUE (store_name, store_id)
+      )
+    `);
+  }
+  getAppliedStepRow(params) {
+    return this.db.query(`SELECT result FROM store_applied_steps
+         WHERE store_name = $storeName
+           AND store_id = $storeId
+           AND execution_id = $executionId
+           AND step_key = $stepKey`).get({
+      $storeName: params.storeName,
+      $storeId: params.storeId,
+      $executionId: params.stepId.executionId,
+      $stepKey: params.stepId.stepKey
+    });
+  }
+  insertAppliedStepRow(params) {
+    this.db.query(`INSERT INTO store_applied_steps
+           (store_name, store_id, execution_id, step_key, result)
+         VALUES
+           ($storeName, $storeId, $executionId, $stepKey, $result)`).run({
+      $storeName: params.storeName,
+      $storeId: params.storeId,
+      $executionId: params.stepId.executionId,
+      $stepKey: params.stepId.stepKey,
+      $result: params.result
+    });
+  }
+  getStoreRow(storeName, storeId) {
+    return this.db.query(`SELECT instance_id, state, version FROM stores
+         WHERE store_name = $storeName AND store_id = $storeId`).get({
+      $storeName: storeName,
+      $storeId: storeId
+    });
+  }
+  selectMatchingWaiters(params) {
+    const waiters = [];
+    const rows = this.db.query(`SELECT * FROM store_waiters
+         WHERE store_name = $storeName AND store_id = $storeId`).all({
+      $storeName: params.storeName,
+      $storeId: params.storeId
+    });
+    for (const row of rows) {
+      if (row.since_version >= params.version)
+        continue;
+      const readPaths = JSON.parse(row.read_paths);
+      if (!storePathsIntersect(readPaths, params.changedPaths))
+        continue;
+      waiters.push({
+        executionId: row.execution_id,
+        stepKey: row.step_key,
+        event: deserializeEvent(JSON.parse(row.event))
+      });
+    }
+    return waiters;
+  }
+  deleteWaiterRow(params) {
+    this.db.query(`DELETE FROM store_waiters
+         WHERE store_name = $storeName
+           AND store_id = $storeId
+           AND execution_id = $executionId
+           AND step_key = $stepKey
+           AND ($sinceVersion IS NULL OR since_version = $sinceVersion)`).run({
+      $storeName: params.storeName,
+      $storeId: params.storeId,
+      $executionId: params.executionId,
+      $stepKey: params.stepKey,
+      $sinceVersion: params.sinceVersion ?? null
+    });
+  }
+  insertWakeOutboxRow(params) {
+    this.db.query(`INSERT OR IGNORE INTO store_wake_outbox
+           (store_name, store_id, execution_id, step_key)
+         VALUES ($storeName, $storeId, $executionId, $stepKey)`).run({
+      $storeName: params.storeName,
+      $storeId: params.storeId,
+      $executionId: params.executionId,
+      $stepKey: params.stepKey
+    });
+  }
+  async drainWakeOutbox() {
+    const rows = this.db.query(`SELECT
+           o.store_name,
+           o.store_id,
+           o.execution_id,
+           o.step_key,
+           w.event,
+           w.since_version
+         FROM store_wake_outbox o
+         LEFT JOIN store_waiters w
+           ON w.store_name = o.store_name
+          AND w.store_id = o.store_id
+          AND w.execution_id = o.execution_id
+          AND w.step_key = o.step_key
+         ORDER BY o.store_name, o.store_id, o.execution_id, o.step_key`).all();
+    for (const row of rows) {
+      try {
+        if (row.event !== null) {
+          await this.schedulerClient.requestWakeUp(deserializeEvent(JSON.parse(row.event)));
+          this.deleteWaiterRow({
+            storeName: row.store_name,
+            storeId: row.store_id,
+            executionId: row.execution_id,
+            stepKey: row.step_key,
+            sinceVersion: row.since_version ?? undefined
+          });
+        }
+        this.db.query(`DELETE FROM store_wake_outbox
+             WHERE store_name = $storeName
+               AND store_id = $storeId
+               AND execution_id = $executionId
+               AND step_key = $stepKey`).run({
+          $storeName: row.store_name,
+          $storeId: row.store_id,
+          $executionId: row.execution_id,
+          $stepKey: row.step_key
+        });
+      } catch (error) {
+        console.error("Failed to deliver pending store wake", error);
+      }
+    }
+  }
+  async drainWakeOutboxBestEffort() {
+    try {
+      await this.drainWakeOutbox();
+    } catch (error) {
+      console.error("Failed to drain pending store wakes", error);
+    }
+  }
+  assertSnapshotHasInstanceId(snapshot) {
+    if (!snapshot.instanceId) {
+      throw new Error("Store snapshot is missing instanceId; read a fresh snapshot");
+    }
+  }
+}
+function serializeEvent(event) {
+  return {
+    workflowId: event.workflowId,
+    executionId: event.executionId,
+    params: event.params,
+    context: event.context instanceof Map ? [...event.context.entries()] : event.context ? Object.entries(event.context) : []
+  };
+}
+function deserializeEvent(event) {
+  return {
+    workflowId: event.workflowId,
+    executionId: event.executionId,
+    params: event.params,
+    context: new Map(event.context ?? [])
+  };
+}
+// src/sqlite-scheduler.ts
+class SqliteSchedulerClient {
+  taskQueue;
+  timersClient;
+  constructor(params) {
+    this.taskQueue = params.taskQueueClient;
+    this.timersClient = params.timersClient;
+  }
+  async requestWakeUp(event, resumeIn) {
+    if (resumeIn) {
+      this.timersClient.createTimer(event, resumeIn);
+    } else {
+      this.taskQueue.add(event);
+    }
+  }
+}
+// src/dao/task-queue-dao.ts
+class TaskQueueDao {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS task_queue (
+        task_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        workflow_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        params TEXT,
+        context TEXT,
+        visible_from INTEGER DEFAULT (strftime('%s', 'now'))
+      )
+    `);
+  }
+  insertTask(event) {
+    const query = this.db.query(`INSERT INTO task_queue (workflow_id, execution_id, params, context)
+      VALUES ($workflowId, $executionId, $params, $context)`);
+    query.run({
+      $workflowId: event.workflowId,
+      $executionId: event.executionId,
+      $params: event.params ? JSON.stringify(event.params) : null,
+      $context: event.context ? JSON.stringify(Array.from(event.context.entries())) : null
+    });
+  }
+  getNextTask() {
+    const query = this.db.query(`SELECT * FROM task_queue WHERE visible_from < strftime('%s', 'now') ORDER BY task_id LIMIT 1`);
+    return query.get();
+  }
+  updateTaskVisibility(taskId, visibleFrom) {
+    const query = this.db.query("UPDATE task_queue SET visible_from = $visibleFrom WHERE task_id = $taskId");
+    query.run({ $taskId: taskId, $visibleFrom: visibleFrom });
+  }
+  deleteTaskById(id) {
+    const query = this.db.query(`DELETE FROM task_queue WHERE task_id = $taskId`);
+    query.run({ $taskId: id });
+  }
+  getTaskCount() {
+    const query = this.db.query(`SELECT COUNT(*) as count FROM task_queue WHERE visible_from < strftime('%s', 'now')`);
+    return query.get().count;
+  }
+}
+
+// src/sqlite-task-queue.ts
+var VISIBILITY_WINDOW = 300000;
+
+class SqliteTaskQueue {
+  taskQueueDao;
+  constructor(db) {
+    this.taskQueueDao = new TaskQueueDao(db);
+    this.taskQueueDao.setupDb();
+  }
+  add(event) {
+    this.taskQueueDao.insertTask(event);
+  }
+  process() {
+    const row = this.taskQueueDao.getNextTask();
+    if (!row)
+      return;
+    const now = Date.now();
+    const visibilityTimeout = now + VISIBILITY_WINDOW;
+    this.taskQueueDao.updateTaskVisibility(row.task_id, visibilityTimeout);
+    return {
+      taskId: row.task_id,
+      visibilityTimeout,
+      event: {
+        workflowId: row.workflow_id,
+        executionId: row.execution_id,
+        params: row.params ? JSON.parse(row.params) : undefined,
+        context: row.context ? new Map(JSON.parse(row.context)) : new Map
+      }
+    };
+  }
+  remove(taskId) {
+    this.taskQueueDao.deleteTaskById(taskId);
+  }
+  makeVisible(taskId) {
+    this.taskQueueDao.updateTaskVisibility(taskId, 0);
+  }
+  get isEmpty() {
+    return this.taskQueueDao.getTaskCount() === 0;
+  }
+}
+
+class SqliteTaskQueueClient {
+  taskQueueDao;
+  constructor(db) {
+    this.taskQueueDao = new TaskQueueDao(db);
+  }
+  add(event) {
+    this.taskQueueDao.insertTask(event);
+  }
+}
+
+// src/dao/timers-dao.ts
+class TimersDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS scheduled_tasks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        delay INTEGER NOT NULL,
+        workflow_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        params TEXT,
+        context TEXT
+      );
+    `);
+  }
+  getExpiredTimers() {
+    const query = this.db.query(`SELECT id, delay, workflow_id, execution_id, created_at, params, context
+       FROM scheduled_tasks 
+       WHERE (created_at + delay) < $currentTime`);
+    return query.all({ $currentTime: Date.now() });
+  }
+  getTaskCount() {
+    const query = this.db.query(`SELECT COUNT(*) as count 
+       FROM scheduled_tasks 
+       WHERE (created_at + delay) < $currentTime`);
+    const count = query.get({ $currentTime: Date.now() });
+    return count.count;
+  }
+  insertTimer(event, delay) {
+    const query = this.db.query(`INSERT INTO scheduled_tasks (delay, workflow_id, execution_id, created_at, params, context) 
+      VALUES ($delay, $workflowId, $executionId, $createdAt, $params, $context)`);
+    query.run({
+      $delay: delay,
+      $workflowId: event.workflowId,
+      $executionId: event.executionId,
+      $createdAt: Date.now(),
+      $params: event.params ? JSON.stringify(event.params) : null,
+      $context: JSON.stringify(Array.from(event.context.entries()))
+    });
+  }
+  deleteTimerById(id) {
+    const query = this.db.query(`DELETE FROM scheduled_tasks WHERE id = $id`);
+    query.run({ $id: id });
+  }
+}
+
+// src/sqlite-timers.ts
+class SqliteTimers {
+  timersDao;
+  taskQueue;
+  constructor(params) {
+    this.timersDao = new TimersDao(params.db);
+    this.taskQueue = params.taskQueue;
+  }
+  processTimers() {
+    const timers = this.timersDao.getExpiredTimers();
+    for (const timer of timers) {
+      this.timersDao.deleteTimerById(timer.id);
+      this.taskQueue.add({
+        workflowId: timer.workflow_id,
+        executionId: timer.execution_id,
+        params: timer.params ? JSON.parse(timer.params) : undefined,
+        context: timer.context ? new Map(JSON.parse(timer.context)) : new Map
+      });
+    }
+  }
+}
+
+class SqliteTimersClient {
+  timersDao;
+  constructor(db) {
+    this.timersDao = new TimersDao(db);
+  }
+  createTimer(event, delay) {
+    this.timersDao.insertTimer(event, delay);
+  }
+}
+
+// src/sqlite-event-loop.ts
+class SqliteEventLoop {
+  taskQueue;
+  timers;
+  isRunning = false;
+  constructor(db) {
+    this.taskQueue = new SqliteTaskQueue(db);
+    this.timers = new SqliteTimers({ db, taskQueue: this.taskQueue });
+  }
+  start(params) {
+    this.isRunning = true;
+    this.loop(params.onNewEvent, params.logger);
+  }
+  stop() {
+    this.isRunning = false;
+  }
+  async loop(processEvent, logger) {
+    if (!this.isRunning)
+      return;
+    while (!this.taskQueue.isEmpty) {
+      const task = this.taskQueue.process();
+      if (task) {
+        await processEvent(task.event, logger);
+        this.taskQueue.remove(task.taskId);
+      }
+    }
+    this.timers.processTimers();
+    setTimeout(() => this.loop(processEvent, logger), 10);
+  }
+}
+export { SqliteHeapClient, SqliteStoreClient, SqliteSchedulerClient, SqliteTaskQueueClient, SqliteTimersClient, SqliteEventLoop };