@yieldstar/sqlite-runtime 0.5.0 → 0.6.1

package/dist/index-gjfs8rn6.js

@@ -0,0 +1,997 @@
+// src/sqlite-runtime.ts
+import { Runtime } from "@yieldstar/core";
+
+// src/sqlite-effect.ts
+import {
+  createEffectState,
+  effectNotFound,
+  matchEffectBegin,
+  prepareEffectBegin,
+  prepareEffectSettle,
+  prepareEffectWatch,
+  settleEffect,
+  toEffectRecord
+} from "@yieldstar/core";
+
+// src/dao/effect-waiters-dao.ts
+class EffectWaitersDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS effect_waiters (
+        effect_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        PRIMARY KEY (effect_id, execution_id, step_key)
+      );
+      CREATE INDEX IF NOT EXISTS idx_effect_waiters_step
+      ON effect_waiters(execution_id, step_key);
+    `);
+  }
+  upsertWaiter(waiter) {
+    this.db.query(`INSERT INTO effect_waiters (effect_id, execution_id, step_key)
+         VALUES ($effectId, $executionId, $stepKey)
+         ON CONFLICT(effect_id, execution_id, step_key) DO NOTHING`).run({
+      $effectId: waiter.effectId,
+      $executionId: waiter.executionId,
+      $stepKey: waiter.stepKey
+    });
+  }
+  getWaitingExecutionIds(effectId) {
+    return this.db.query(`SELECT DISTINCT execution_id FROM effect_waiters WHERE effect_id = $effectId`).all({ $effectId: effectId }).map((row) => row.execution_id);
+  }
+  deleteStepWaiters(executionId, stepKey) {
+    this.db.query(`DELETE FROM effect_waiters WHERE execution_id = $executionId AND step_key = $stepKey`).run({ $executionId: executionId, $stepKey: stepKey });
+  }
+}
+
+// src/dao/effects-dao.ts
+class EffectsDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS effects (
+        effect_id TEXT PRIMARY KEY,
+        operation TEXT NOT NULL,
+        input TEXT NOT NULL,
+        status TEXT NOT NULL,
+        result TEXT
+      );
+      CREATE TABLE IF NOT EXISTS effect_conflicts (
+        effect_id TEXT NOT NULL,
+        result TEXT NOT NULL,
+        conflicting_result TEXT NOT NULL,
+        reported_at INTEGER NOT NULL,
+        PRIMARY KEY (effect_id, conflicting_result)
+      );
+    `);
+  }
+  getState(effectId) {
+    const row = this.db.query(`SELECT * FROM effects WHERE effect_id = $effectId`).get({ $effectId: effectId });
+    if (!row)
+      return;
+    const conflicts = this.db.query(`SELECT result, conflicting_result, reported_at FROM effect_conflicts
+         WHERE effect_id = $effectId
+         ORDER BY reported_at, rowid`).all({ $effectId: effectId });
+    const state = {
+      effectId: row.effect_id,
+      operation: row.operation,
+      input: row.input,
+      status: row.status,
+      conflicts: conflicts.map((conflict) => ({
+        result: conflict.result,
+        conflictingResult: conflict.conflicting_result,
+        reportedAt: conflict.reported_at
+      }))
+    };
+    if (row.result !== null)
+      state.result = row.result;
+    return state;
+  }
+  insertState(state) {
+    this.db.query(`INSERT INTO effects (effect_id, operation, input, status, result)
+         VALUES ($effectId, $operation, $input, $status, $result)`).run({
+      $effectId: state.effectId,
+      $operation: state.operation,
+      $input: state.input,
+      $status: state.status,
+      $result: state.result ?? null
+    });
+  }
+  updateState(before, after) {
+    if (before.status !== after.status || before.result !== after.result) {
+      this.db.query(`UPDATE effects SET status = $status, result = $result
+           WHERE effect_id = $effectId`).run({
+        $effectId: after.effectId,
+        $status: after.status,
+        $result: after.result ?? null
+      });
+    }
+    for (const conflict of after.conflicts.slice(before.conflicts.length)) {
+      this.insertConflict(after.effectId, conflict);
+    }
+  }
+  insertConflict(effectId, conflict) {
+    this.db.query(`INSERT INTO effect_conflicts (effect_id, result, conflicting_result, reported_at)
+         VALUES ($effectId, $result, $conflictingResult, $reportedAt)`).run({
+      $effectId: effectId,
+      $result: conflict.result,
+      $conflictingResult: conflict.conflictingResult,
+      $reportedAt: conflict.reportedAt
+    });
+  }
+}
+
+// src/sqlite-execution.ts
+import {
+  acknowledgeExecution,
+  claimExecution,
+  createExecutionState,
+  createStartedExecution,
+  executionIdConflict,
+  executionNotFound,
+  isExecutionClaimable,
+  matchStartRequest,
+  prepareExecutionAdmission,
+  prepareExecutionStart,
+  releaseExecutionLease,
+  renewExecutionLease,
+  requestExecutionWake,
+  toExecutionRecord
+} from "@yieldstar/core";
+
+// src/dao/executions-dao.ts
+import { nextClaimAt } from "@yieldstar/core";
+class ExecutionsDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS executions (
+        execution_id TEXT PRIMARY KEY,
+        workflow_id TEXT NOT NULL,
+        params TEXT NOT NULL,
+        context TEXT NOT NULL,
+        status TEXT NOT NULL,
+        outcome TEXT,
+        admitted_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        due_at INTEGER,
+        claimed_due_at INTEGER,
+        lease_token INTEGER NOT NULL DEFAULT 0,
+        lease_expires_at INTEGER,
+        unacknowledged_delivery_count INTEGER NOT NULL DEFAULT 0,
+        redeliver_at INTEGER,
+        next_claim_at INTEGER,
+        parent_execution_id TEXT,
+        parent_step_key TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_executions_next_claim_at
+      ON executions(next_claim_at) WHERE next_claim_at IS NOT NULL;
+    `);
+  }
+  getState(executionId) {
+    const row = this.db.query(`SELECT * FROM executions WHERE execution_id = $executionId`).get({ $executionId: executionId });
+    return row ? toState(row) : undefined;
+  }
+  getClaimableIds(now, limit) {
+    return this.db.query(`SELECT execution_id FROM executions
+         WHERE next_claim_at IS NOT NULL AND next_claim_at <= $now
+         ORDER BY next_claim_at, execution_id
+         LIMIT $limit`).all({ $now: now, $limit: limit }).map((row) => row.execution_id);
+  }
+  insertState(state) {
+    const result = this.db.query(`INSERT INTO executions (
+           execution_id, workflow_id, params, context, status, outcome,
+           admitted_at, updated_at, due_at, claimed_due_at, lease_token,
+           lease_expires_at, unacknowledged_delivery_count, redeliver_at,
+           next_claim_at, parent_execution_id, parent_step_key
+         ) VALUES (
+           $executionId, $workflowId, $params, $context, $status, $outcome,
+           $admittedAt, $updatedAt, $dueAt, $claimedDueAt, $leaseToken,
+           $leaseExpiresAt, $unacknowledgedDeliveryCount, $redeliverAt,
+           $nextClaimAt, $parentExecutionId, $parentStepKey
+         )
+         ON CONFLICT(execution_id) DO NOTHING`).run({
+      ...toBindings(state),
+      $parentExecutionId: state.parent?.executionId ?? null,
+      $parentStepKey: state.parent?.stepKey ?? null
+    });
+    return Number(result.changes) === 1;
+  }
+  updateState(state) {
+    this.db.query(`UPDATE executions SET
+           workflow_id = $workflowId,
+           params = $params,
+           context = $context,
+           status = $status,
+           outcome = $outcome,
+           admitted_at = $admittedAt,
+           updated_at = $updatedAt,
+           due_at = $dueAt,
+           claimed_due_at = $claimedDueAt,
+           lease_token = $leaseToken,
+           lease_expires_at = $leaseExpiresAt,
+           unacknowledged_delivery_count = $unacknowledgedDeliveryCount,
+           redeliver_at = $redeliverAt,
+           next_claim_at = $nextClaimAt
+         WHERE execution_id = $executionId`).run(toBindings(state));
+  }
+}
+function toState(row) {
+  return {
+    executionId: row.execution_id,
+    workflowId: row.workflow_id,
+    params: row.params,
+    context: row.context,
+    status: row.status,
+    outcome: row.outcome,
+    admittedAt: Number(row.admitted_at),
+    updatedAt: Number(row.updated_at),
+    dueAt: toNumberOrNull(row.due_at),
+    claimedDueAt: toNumberOrNull(row.claimed_due_at),
+    leaseToken: Number(row.lease_token),
+    leaseExpiresAt: toNumberOrNull(row.lease_expires_at),
+    unacknowledgedDeliveryCount: Number(row.unacknowledged_delivery_count),
+    redeliverAt: toNumberOrNull(row.redeliver_at),
+    parent: row.parent_execution_id !== null && row.parent_step_key !== null ? { executionId: row.parent_execution_id, stepKey: row.parent_step_key } : null
+  };
+}
+function toBindings(state) {
+  return {
+    $executionId: state.executionId,
+    $workflowId: state.workflowId,
+    $params: state.params,
+    $context: state.context,
+    $status: state.status,
+    $outcome: state.outcome,
+    $admittedAt: state.admittedAt,
+    $updatedAt: state.updatedAt,
+    $dueAt: state.dueAt,
+    $claimedDueAt: state.claimedDueAt,
+    $leaseToken: state.leaseToken,
+    $leaseExpiresAt: state.leaseExpiresAt,
+    $unacknowledgedDeliveryCount: state.unacknowledgedDeliveryCount,
+    $redeliverAt: state.redeliverAt,
+    $nextClaimAt: nextClaimAt(state)
+  };
+}
+function toNumberOrNull(value) {
+  return value === null ? null : Number(value);
+}
+
+// src/dao/start-requests-dao.ts
+class StartRequestsDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS start_requests (
+        caller_execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        workflow_id TEXT NOT NULL,
+        params TEXT,
+        execution_id TEXT NOT NULL,
+        PRIMARY KEY (caller_execution_id, step_key)
+      );
+    `);
+  }
+  get(callerExecutionId, stepKey) {
+    const row = this.db.query(`SELECT * FROM start_requests
+         WHERE caller_execution_id = $callerExecutionId AND step_key = $stepKey`).get({ $callerExecutionId: callerExecutionId, $stepKey: stepKey });
+    return row ? {
+      callerExecutionId: row.caller_execution_id,
+      stepKey: row.step_key,
+      workflowId: row.workflow_id,
+      params: row.params,
+      executionId: row.execution_id
+    } : undefined;
+  }
+  insert(request) {
+    this.db.query(`INSERT INTO start_requests
+           (caller_execution_id, step_key, workflow_id, params, execution_id)
+         VALUES
+           ($callerExecutionId, $stepKey, $workflowId, $params, $executionId)`).run({
+      $callerExecutionId: request.callerExecutionId,
+      $stepKey: request.stepKey,
+      $workflowId: request.workflowId,
+      $params: request.params,
+      $executionId: request.executionId
+    });
+  }
+}
+
+// src/sqlite-transaction.ts
+function runTransaction(db, fn) {
+  db.run("BEGIN IMMEDIATE");
+  try {
+    const result = fn();
+    db.run("COMMIT");
+    return result;
+  } catch (err) {
+    db.run("ROLLBACK");
+    throw err;
+  }
+}
+
+// src/sqlite-execution.ts
+class SqliteExecutionClient2 {
+  db;
+  executionsDao;
+  startRequestsDao;
+  clock;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.executionsDao = new ExecutionsDao(db);
+    this.startRequestsDao = new StartRequestsDao(db);
+    this.clock = options.clock ?? (() => Date.now());
+  }
+  async admit(request) {
+    const prepared = prepareExecutionAdmission(request);
+    if (!prepared.ok) {
+      return {
+        status: "rejected",
+        code: prepared.code,
+        message: prepared.message
+      };
+    }
+    return runTransaction(this.db, () => {
+      const state = createExecutionState({
+        executionId: prepared.executionId,
+        workflowId: request.workflowId,
+        encoded: prepared.encoded,
+        now: this.clock()
+      });
+      if (!this.executionsDao.insertState(state)) {
+        return executionIdConflict(prepared.executionId);
+      }
+      return { status: "accepted", executionId: prepared.executionId };
+    });
+  }
+  async start(request) {
+    const prepared = prepareExecutionStart(request);
+    if (!prepared.ok)
+      return prepared.result;
+    const { start } = prepared;
+    return runTransaction(this.db, () => {
+      const recorded = this.startRequestsDao.get(start.callerExecutionId, start.stepKey);
+      if (recorded)
+        return matchStartRequest(recorded, start);
+      const caller = this.executionsDao.getState(start.callerExecutionId);
+      if (!caller) {
+        throw new Error(`Cannot start a workflow from execution "${start.callerExecutionId}": it does not exist`);
+      }
+      let created = createStartedExecution({ start, caller, now: this.clock() });
+      while (!this.executionsDao.insertState(created.target)) {
+        created = createStartedExecution({ start, caller, now: this.clock() });
+      }
+      this.startRequestsDao.insert(created.startRequest);
+      return {
+        status: "accepted",
+        executionId: created.target.executionId
+      };
+    });
+  }
+  async get(executionId) {
+    const state = this.executionsDao.getState(executionId);
+    return state ? toExecutionRecord(state, this.clock()) : undefined;
+  }
+  async requestWake(request) {
+    return runTransaction(this.db, () => {
+      const state = this.executionsDao.getState(request.executionId);
+      if (!state)
+        return executionNotFound(request.executionId);
+      const next = requestExecutionWake(state, request.wakeAt, this.clock());
+      if (!next)
+        return { status: "ignored" };
+      this.executionsDao.updateState(next);
+      return { status: "requested" };
+    });
+  }
+  async claimDue(request) {
+    if (request.limit <= 0)
+      return [];
+    return runTransaction(this.db, () => {
+      const now = this.clock();
+      const leases = [];
+      for (const executionId of this.executionsDao.getClaimableIds(now, request.limit)) {
+        const state = this.executionsDao.getState(executionId);
+        if (!state || !isExecutionClaimable(state, now))
+          continue;
+        const claimed = claimExecution(state, {
+          now,
+          duration: request.duration
+        });
+        this.executionsDao.updateState(claimed.state);
+        leases.push(claimed.lease);
+      }
+      return leases;
+    });
+  }
+  async renew(request) {
+    return this.transition(request.lease, (state) => renewExecutionLease(state, {
+      lease: request.lease,
+      duration: request.duration,
+      now: this.clock()
+    }));
+  }
+  async release(request) {
+    return this.transition(request.lease, (state) => releaseExecutionLease(state, { lease: request.lease, now: this.clock() }));
+  }
+  async acknowledge(request) {
+    return this.transition(request.lease, (state) => acknowledgeExecution(state, {
+      lease: request.lease,
+      outcome: request.outcome,
+      now: this.clock()
+    }));
+  }
+  transition(lease, fn) {
+    return Promise.resolve(runTransaction(this.db, () => {
+      const state = this.executionsDao.getState(lease.executionId);
+      if (!state)
+        return { status: "lost" };
+      const next = fn(state);
+      if (next.state !== state)
+        this.executionsDao.updateState(next.state);
+      return next.result;
+    }));
+  }
+  wakeInTransaction(executionId, wakeAt = this.clock()) {
+    const state = this.executionsDao.getState(executionId);
+    if (!state)
+      return;
+    const next = requestExecutionWake(state, wakeAt, this.clock());
+    if (next)
+      this.executionsDao.updateState(next);
+  }
+}
+
+// src/sqlite-effect.ts
+class SqliteEffectClient2 {
+  db;
+  executions;
+  effectsDao;
+  effectWaitersDao;
+  clock;
+  constructor(params) {
+    this.db = params.db;
+    this.clock = params.clock ?? (() => Date.now());
+    this.executions = params.executions ?? new SqliteExecutionClient2(params.db, { clock: this.clock });
+    this.effectsDao = new EffectsDao(params.db);
+    this.effectWaitersDao = new EffectWaitersDao(params.db);
+  }
+  async begin(request) {
+    const begin = prepareEffectBegin(request);
+    return runTransaction(this.db, () => {
+      const state = this.effectsDao.getState(begin.effectId);
+      if (state)
+        return matchEffectBegin(state, begin);
+      this.effectsDao.insertState(createEffectState(begin));
+      return { status: "new" };
+    });
+  }
+  async settle(request) {
+    const settle = prepareEffectSettle(request);
+    return runTransaction(this.db, () => {
+      const state = this.effectsDao.getState(settle.effectId);
+      if (!state)
+        throw effectNotFound(settle.effectId);
+      const settled = settleEffect(state, settle, this.clock());
+      if (settled.state !== state)
+        this.effectsDao.updateState(state, settled.state);
+      if (settled.wake) {
+        for (const executionId of this.effectWaitersDao.getWaitingExecutionIds(settle.effectId)) {
+          this.executions.wakeInTransaction(executionId);
+        }
+      }
+      return settled.result;
+    });
+  }
+  async watch(request) {
+    const watch = prepareEffectWatch(request);
+    runTransaction(this.db, () => {
+      const state = this.effectsDao.getState(watch.effectId);
+      if (!state)
+        throw effectNotFound(watch.effectId);
+      this.effectWaitersDao.upsertWaiter(watch);
+      if (state.status === "settled") {
+        this.executions.wakeInTransaction(watch.executionId);
+      }
+    });
+  }
+  async getEffect(effectId) {
+    const state = this.effectsDao.getState(effectId);
+    return state ? toEffectRecord(state) : undefined;
+  }
+}
+
+// src/sqlite-heap.ts
+import {
+  isLeaseCurrent
+} from "@yieldstar/core";
+
+// 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 TEXT NOT NULL,
+        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;
+  }
+  getStepResponse(executionId, stepKey, stepAttempt) {
+    return this.db.query(`SELECT * FROM step_responses
+         WHERE execution_id = $executionId
+         AND step_key = $stepKey
+         AND step_attempt = $stepAttempt`).get({
+      $executionId: executionId,
+      $stepKey: stepKey,
+      $stepAttempt: stepAttempt
+    });
+  }
+  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/dao/store-waiters-dao.ts
+class StoreWaitersDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    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,
+        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 INDEX IF NOT EXISTS idx_store_waiters_step
+      ON store_waiters(execution_id, step_key);
+    `);
+  }
+  upsertWaiter(waiter) {
+    this.db.query(`INSERT INTO store_waiters
+           (workflow_id, execution_id, step_key, store_name, store_id, since_version, read_paths)
+         VALUES
+           ($workflowId, $executionId, $stepKey, $storeName, $storeId, $sinceVersion, $readPaths)
+         ON CONFLICT(store_name, store_id, execution_id, step_key)
+         DO UPDATE SET
+           workflow_id = excluded.workflow_id,
+           since_version = excluded.since_version,
+           read_paths = excluded.read_paths`).run({
+      $workflowId: waiter.workflowId,
+      $executionId: waiter.executionId,
+      $stepKey: waiter.stepKey,
+      $storeName: waiter.storeName,
+      $storeId: waiter.storeId,
+      $sinceVersion: waiter.sinceVersion,
+      $readPaths: JSON.stringify(waiter.readPaths)
+    });
+  }
+  getStoreWaiters(storeName, storeId) {
+    return this.db.query(`SELECT * FROM store_waiters
+         WHERE store_name = $storeName AND store_id = $storeId`).all({ $storeName: storeName, $storeId: storeId });
+  }
+  deleteStoreWaiters(storeName, storeId) {
+    this.db.query(`DELETE FROM store_waiters WHERE store_name = $storeName AND store_id = $storeId`).run({ $storeName: storeName, $storeId: storeId });
+  }
+  deleteStepWaiters(executionId, stepKey) {
+    this.db.query(`DELETE FROM store_waiters WHERE execution_id = $executionId AND step_key = $stepKey`).run({ $executionId: executionId, $stepKey: stepKey });
+  }
+}
+
+// src/sqlite-heap.ts
+class SqliteHeapClient2 {
+  db;
+  executionsDao;
+  stepResponsesDao;
+  storeWaitersDao;
+  effectWaitersDao;
+  constructor(db) {
+    this.db = db;
+    this.executionsDao = new ExecutionsDao(db);
+    this.stepResponsesDao = new StepResponsesDao(db);
+    this.storeWaitersDao = new StoreWaitersDao(db);
+    this.effectWaitersDao = new EffectWaitersDao(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) {
+      return null;
+    }
+    return {
+      stepResponseJson: result.step_response,
+      meta: {
+        attempt: result.step_attempt,
+        done: Boolean(result.step_done)
+      }
+    };
+  }
+  async writeStep(params) {
+    const { lease, stepKey, stepAttempt, done, stepResponseJson } = params;
+    const { executionId } = lease;
+    return runTransaction(this.db, () => {
+      const state = this.executionsDao.getState(executionId);
+      if (!state || !isLeaseCurrent(state, lease)) {
+        return { status: "lost" };
+      }
+      const existing = this.stepResponsesDao.getStepResponse(executionId, stepKey, stepAttempt);
+      if (existing) {
+        return {
+          stepResponseJson: existing.step_response,
+          meta: { attempt: existing.step_attempt, done: Boolean(existing.step_done) }
+        };
+      }
+      this.stepResponsesDao.insertStepResponse(executionId, stepKey, stepAttempt, done, stepResponseJson);
+      if (done) {
+        this.storeWaitersDao.deleteStepWaiters(executionId, stepKey);
+        this.effectWaitersDao.deleteStepWaiters(executionId, stepKey);
+      }
+      return { stepResponseJson, meta: { attempt: stepAttempt, done } };
+    });
+  }
+}
+
+// src/sqlite-store.ts
+import { v7 as uuidv7 } from "uuid";
+import {
+  cloneStoreState,
+  CasStoreClient,
+  decodeStoreValue,
+  encodeStoreValue,
+  StoreNotFoundError,
+  storePathsIntersect,
+  validateStoreState
+} from "@yieldstar/core";
+class SqliteStoreClient2 extends CasStoreClient {
+  db;
+  executions;
+  storeWaitersDao;
+  constructor(params) {
+    super();
+    this.db = params.db;
+    this.executions = params.executions ?? new SqliteExecutionClient2(params.db);
+    this.setupDb();
+    this.storeWaitersDao = new StoreWaitersDao(params.db);
+  }
+  async getOrCreateStore(params) {
+    const existing = this.getStoreRow(params.definition.name, params.id);
+    if (existing) {
+      return toSnapshot(existing);
+    }
+    if (!params.initial) {
+      throw new StoreNotFoundError(params.definition.name, params.id);
+    }
+    const initialValue = params.initial;
+    const initial = typeof initialValue === "function" ? await initialValue() : initialValue;
+    const state = await validateStoreState(params.definition, initial);
+    return runTransaction(this.db, () => {
+      const existingTx = this.getStoreRow(params.definition.name, params.id);
+      if (existingTx) {
+        return toSnapshot(existingTx);
+      }
+      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: encodeStoreValue(state)
+      });
+      return {
+        state: cloneStoreState(state),
+        instanceId,
+        version: 0
+      };
+    });
+  }
+  async getStore(params) {
+    const row = this.getStoreRow(params.definition.name, params.id);
+    if (!row) {
+      throw new StoreNotFoundError(params.definition.name, params.id);
+    }
+    return toSnapshot(row);
+  }
+  async getAppliedStoreStep(params) {
+    const row = this.getAppliedStepRow({
+      storeName: params.definition.name,
+      storeId: params.id,
+      stepId: params.stepId
+    });
+    return row ? { result: decodeStoreValue(row.result) } : undefined;
+  }
+  async commitStoreMutation(mutation) {
+    return runTransaction(this.db, () => {
+      if (mutation.stepId) {
+        const applied = this.getAppliedStepRow({
+          storeName: mutation.definition.name,
+          storeId: mutation.id,
+          stepId: mutation.stepId
+        });
+        if (applied) {
+          return {
+            status: "already-applied",
+            result: decodeStoreValue(applied.result)
+          };
+        }
+      }
+      const row = this.getStoreRow(mutation.definition.name, mutation.id);
+      if (!row) {
+        throw new StoreNotFoundError(mutation.definition.name, mutation.id);
+      }
+      if (row.instance_id !== mutation.expected.instanceId || row.version !== mutation.expected.version) {
+        return { status: "conflict", snapshot: toSnapshot(row) };
+      }
+      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: encodeStoreValue(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: encodeStoreValue(mutation.result)
+        });
+      }
+      const executionIds = this.selectMatchingExecutionIds({
+        storeName: mutation.definition.name,
+        storeId: mutation.id,
+        version,
+        changedPaths: mutation.changedPaths
+      });
+      for (const executionId of executionIds) {
+        this.executions.wakeInTransaction(executionId);
+      }
+      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) {
+    runTransaction(this.db, () => {
+      this.db.query(`DELETE FROM stores WHERE store_name = $storeName AND store_id = $storeId`).run({
+        $storeName: params.definition.name,
+        $storeId: params.id
+      });
+      this.storeWaitersDao.deleteStoreWaiters(params.definition.name, params.id);
+    });
+  }
+  async deleteStoreFrom(params) {
+    return runTransaction(this.db, () => {
+      if (params.stepId) {
+        const applied = this.getAppliedStepRow({
+          storeName: params.definition.name,
+          storeId: params.id,
+          stepId: params.stepId
+        });
+        if (applied) {
+          return decodeStoreValue(applied.result);
+        }
+      }
+      this.assertSnapshotHasInstanceId(params.snapshot);
+      const row = this.getStoreRow(params.definition.name, params.id);
+      if (!row) {
+        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) {
+        return {
+          deleted: false,
+          reason: "conflict",
+          expectedInstanceId: params.snapshot.instanceId,
+          actualInstanceId: row.instance_id,
+          expectedVersion: params.snapshot.version,
+          actualVersion: row.version
+        };
+      }
+      this.storeWaitersDao.deleteStoreWaiters(params.definition.name, params.id);
+      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: encodeStoreValue(result)
+        });
+      }
+      return result;
+    });
+  }
+  async registerWaiter(waiter) {
+    runTransaction(this.db, () => {
+      this.storeWaitersDao.upsertWaiter(waiter);
+      const row = this.getStoreRow(waiter.storeName, waiter.storeId);
+      if (!row || row.instance_id !== waiter.instanceId || row.version > waiter.sinceVersion) {
+        this.executions.wakeInTransaction(waiter.executionId);
+      }
+    });
+  }
+  setupDb() {
+    this.createStoresTable();
+    this.db.run(`
+      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)
+      );
+    `);
+  }
+  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
+    });
+  }
+  selectMatchingExecutionIds(params) {
+    const executionIds = new Set;
+    const rows = this.storeWaitersDao.getStoreWaiters(params.storeName, 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;
+      executionIds.add(row.execution_id);
+    }
+    return executionIds;
+  }
+  assertSnapshotHasInstanceId(snapshot) {
+    if (!snapshot.instanceId) {
+      throw new Error("Store snapshot is missing instanceId; read a fresh snapshot");
+    }
+  }
+}
+function toSnapshot(row) {
+  return {
+    state: decodeStoreValue(row.state),
+    instanceId: row.instance_id,
+    version: row.version
+  };
+}
+
+// src/sqlite-runtime.ts
+class SqliteRuntime2 extends Runtime {
+  clock;
+  executions;
+  effects;
+  heap;
+  stores;
+  constructor(db, options = {}) {
+    super();
+    this.clock = options.clock ?? (() => Date.now());
+    this.executions = new SqliteExecutionClient2(db, { clock: this.clock });
+    this.heap = new SqliteHeapClient2(db);
+    this.stores = new SqliteStoreClient2({ db, executions: this.executions });
+    this.effects = new SqliteEffectClient2({
+      db,
+      executions: this.executions,
+      clock: this.clock
+    });
+  }
+}
+export { SqliteExecutionClient2, SqliteEffectClient2, SqliteHeapClient2, SqliteStoreClient2, SqliteRuntime2 };