@yieldstar/sqlite-runtime 0.5.0 → 0.6.0

package/dist/index-4vq70w0r.js

@@ -1,796 +0,0 @@
-// 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 };