@yieldstar/sqlite-runtime 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,16 +1,14 @@
 import {
-  SqliteEventLoop,
-  SqliteHeapClient,
-  SqliteSchedulerClient,
-  SqliteStoreClient,
-  SqliteTaskQueueClient,
-  SqliteTimersClient
-} from "./index-4vq70w0r.js";
+  SqliteExecutionClient2,
+  SqliteEffectClient2,
+  SqliteHeapClient2,
+  SqliteStoreClient2,
+  SqliteRuntime2
+} from "./index-h3h7r4b6.js";
 export {
-  SqliteTimersClient,
-  SqliteTaskQueueClient,
-  SqliteStoreClient,
-  SqliteSchedulerClient,
-  SqliteHeapClient,
-  SqliteEventLoop
+  SqliteEffectClient2 as SqliteEffectClient,
+  SqliteExecutionClient2 as SqliteExecutionClient,
+  SqliteHeapClient2 as SqliteHeapClient,
+  SqliteRuntime2 as SqliteRuntime,
+  SqliteStoreClient2 as SqliteStoreClient
 };

package/dist/node.js

@@ -1,15 +1,14 @@
+import {
+  SqliteExecutionClient2,
+  SqliteEffectClient2,
+  SqliteHeapClient2,
+  SqliteStoreClient2,
+  SqliteRuntime2
+} from "./index-h3h7r4b6.js";
 import {
   createSqliteDriver,
   wrapSqliteStatement
-} from "./index-h7bm9xg4.js";
-import {
-  SqliteEventLoop,
-  SqliteHeapClient,
-  SqliteSchedulerClient,
-  SqliteStoreClient,
-  SqliteTaskQueueClient,
-  SqliteTimersClient
-} from "./index-4vq70w0r.js";
+} from "./index-dapqh99v.js";
 
 // src/node.ts
 import { DatabaseSync } from "node:sqlite";
@@ -38,12 +37,11 @@ function createSqliteDb(opts) {
   return createSqliteDriver((path) => new NodeSqliteDriver(new DatabaseSync(path)), opts);
 }
 export {
-  createSqliteDb,
-  SqliteTimersClient,
-  SqliteTaskQueueClient,
-  SqliteStoreClient,
-  SqliteSchedulerClient,
-  SqliteHeapClient,
-  SqliteEventLoop,
-  NodeSqliteDriver
+  NodeSqliteDriver,
+  SqliteEffectClient2 as SqliteEffectClient,
+  SqliteExecutionClient2 as SqliteExecutionClient,
+  SqliteHeapClient2 as SqliteHeapClient,
+  SqliteRuntime2 as SqliteRuntime,
+  SqliteStoreClient2 as SqliteStoreClient,
+  createSqliteDb
 };

package/dist/sqlite-effect.d.ts

@@ -0,0 +1,30 @@
+import { type EffectBeginRequest, type EffectBeginResult, type EffectClient, type EffectRecord, type EffectSettleRequest, type EffectSettleResult, type EffectWatchRequest } from "@yieldstar/core";
+import type { SqliteDriver } from "./sqlite-driver";
+import { SqliteExecutionClient } from "./sqlite-execution";
+/**
+ * Effect records and waiters in the same database as the execution records,
+ * so a settlement and the wakes of its waiters commit in one IMMEDIATE
+ * transaction.
+ */
+export declare class SqliteEffectClient implements EffectClient {
+    private db;
+    private executions;
+    private effectsDao;
+    private effectWaitersDao;
+    private clock;
+    /**
+     * @param params.executions The execution client whose records waiters wake.
+     * Defaults to one over `db` with the default clock; SqliteRuntime passes
+     * its own so both share the runtime clock.
+     */
+    constructor(params: {
+        db: SqliteDriver;
+        executions?: SqliteExecutionClient;
+        clock?: () => number;
+    });
+    begin(request: EffectBeginRequest): Promise<EffectBeginResult>;
+    settle(request: EffectSettleRequest): Promise<EffectSettleResult>;
+    watch(request: EffectWatchRequest): Promise<void>;
+    getEffect(effectId: string): Promise<EffectRecord | undefined>;
+}
+//# sourceMappingURL=sqlite-effect.d.ts.map

package/dist/sqlite-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-effect.d.ts","sourceRoot":"","sources":["../src/sqlite-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACxB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAG3D;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD,OAAO,CAAC,EAAE,CAAe;IACzB,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,KAAK,CAAe;IAE5B;;;;OAIG;gBACS,MAAM,EAAE;QAClB,EAAE,EAAE,YAAY,CAAC;QACjB,UAAU,CAAC,EAAE,qBAAqB,CAAC;QACnC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;KACtB;IAUK,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAU9D,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAkBjE,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjD,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;CAIrE"}

package/dist/sqlite-execution.d.ts

@@ -0,0 +1,54 @@
+import { type ExecutionAcknowledgeResult, type ExecutionAdmissionRequest, type ExecutionAdmissionResult, type ExecutionClient, type ExecutionLease, type ExecutionRecord, type ExecutionStartRequest, type ExecutionStartResult, type ExecutionReleaseResult, type ExecutionRenewResult, type ExecutionWakeResult, type WorkflowRunOutcome } from "@yieldstar/core";
+import type { SqliteDriver } from "./sqlite-driver";
+export type SqliteExecutionClientOptions = {
+    /** Reads the current time. Defaults to `Date.now`. */
+    clock?: () => number;
+};
+/**
+ * Execution records in the `executions` table. Every operation loads a row,
+ * applies a pure transition from @yieldstar/core and writes it back inside one
+ * IMMEDIATE transaction, so processes sharing the database file see the same
+ * semantics as the memory runtime.
+ */
+export declare class SqliteExecutionClient implements ExecutionClient {
+    private db;
+    private executionsDao;
+    private startRequestsDao;
+    private clock;
+    constructor(db: SqliteDriver, options?: SqliteExecutionClientOptions);
+    admit(request: ExecutionAdmissionRequest): Promise<ExecutionAdmissionResult>;
+    start(request: ExecutionStartRequest): Promise<ExecutionStartResult>;
+    get(executionId: string): Promise<ExecutionRecord | undefined>;
+    requestWake(request: {
+        executionId: string;
+        wakeAt: number;
+    }): Promise<ExecutionWakeResult>;
+    claimDue(request: {
+        limit: number;
+        duration: number;
+    }): Promise<ExecutionLease[]>;
+    renew(request: {
+        lease: ExecutionLease;
+        duration: number;
+    }): Promise<ExecutionRenewResult>;
+    release(request: {
+        lease: ExecutionLease;
+    }): Promise<ExecutionReleaseResult>;
+    acknowledge(request: {
+        lease: ExecutionLease;
+        outcome: WorkflowRunOutcome;
+    }): Promise<ExecutionAcknowledgeResult>;
+    /**
+     * Applies a fenced transition in one transaction. The transition checks the
+     * lease against the stored token, so the check and the write are atomic.
+     */
+    private transition;
+    /**
+     * @internal Requests a wake from inside a transaction the caller already
+     * holds on the same database, so the wake commits with the caller's write
+     * (e.g. a store commit). `wakeAt` defaults to the runtime clock's now.
+     * Unknown and terminal executions are ignored.
+     */
+    wakeInTransaction(executionId: string, wakeAt?: number): void;
+}
+//# sourceMappingURL=sqlite-execution.d.ts.map

package/dist/sqlite-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-execution.d.ts","sourceRoot":"","sources":["../src/sqlite-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAeL,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAEzB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACxB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,MAAM,MAAM,4BAA4B,GAAG;IACzC,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CACtB,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,EAAE,CAAe;IACzB,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,KAAK,CAAe;gBAEhB,EAAE,EAAE,YAAY,EAAE,OAAO,GAAE,4BAAiC;IAQlE,KAAK,CACT,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC;IA0B9B,KAAK,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiCpE,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAK9D,WAAW,CAAC,OAAO,EAAE;QACzB,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAa1B,QAAQ,CAAC,OAAO,EAAE;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IA2BvB,KAAK,CAAC,OAAO,EAAE;QACnB,KAAK,EAAE,cAAc,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAU3B,OAAO,CAAC,OAAO,EAAE;QACrB,KAAK,EAAE,cAAc,CAAC;KACvB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAM7B,WAAW,CAAC,OAAO,EAAE;QACzB,KAAK,EAAE,cAAc,CAAC;QACtB,OAAO,EAAE,kBAAkB,CAAC;KAC7B,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAUvC;;;OAGG;IACH,OAAO,CAAC,UAAU;IAelB;;;;;OAKG;IACH,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,GAAE,MAAqB;CAOrE"}

package/dist/sqlite-heap.d.ts

@@ -1,7 +1,11 @@
-import type { HeapClient } from "@yieldstar/core";
+import { type ExecutionLease, type HeapClient, type HeapRecord, type LeaseLost } from "@yieldstar/core";
 import type { SqliteDriver } from "./sqlite-driver";
 export declare class SqliteHeapClient implements HeapClient {
+    private db;
+    private executionsDao;
     private stepResponsesDao;
+    private storeWaitersDao;
+    private effectWaitersDao;
     constructor(db: SqliteDriver);
     getAllSteps(): Promise<unknown[]>;
     deleteAll(): Promise<void>;
@@ -15,12 +19,16 @@ export declare class SqliteHeapClient implements HeapClient {
             done: boolean;
         };
     } | null>;
+    /**
+     * Checks the lease against the `executions` row and writes the step record
+     * in one IMMEDIATE transaction, so no claim can interleave between them.
+     */
     writeStep(params: {
-        executionId: string;
+        lease: ExecutionLease;
         stepKey: string;
         stepAttempt: number;
-        stepDone: boolean;
+        done: boolean;
         stepResponseJson: string;
-    }): Promise<void>;
+    }): Promise<HeapRecord | LeaseLost>;
 }
 //# sourceMappingURL=sqlite-heap.d.ts.map

package/dist/sqlite-heap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-heap.d.ts","sourceRoot":"","sources":["../src/sqlite-heap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,EAAE,EAAE,YAAY;IAItB,WAAW;IAIX,SAAS;IAIT,QAAQ,CAAC,MAAM,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;;;;;;;IAmBzD,SAAS,CAAC,MAAM,EAAE;QACtB,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,OAAO,CAAC;QAClB,gBAAgB,EAAE,MAAM,CAAC;KAC1B;CASF"}
+{"version":3,"file":"sqlite-heap.d.ts","sourceRoot":"","sources":["../src/sqlite-heap.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACf,MAAM,iBAAiB,CAAC;AAKzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,EAAE,CAAe;IACzB,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,EAAE,EAAE,YAAY;IAQtB,WAAW;IAIX,SAAS;IAIT,QAAQ,CAAC,MAAM,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;;;;;;;IAmB/D;;;OAGG;IACG,SAAS,CAAC,MAAM,EAAE;QACtB,KAAK,EAAE,cAAc,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,OAAO,CAAC;QACd,gBAAgB,EAAE,MAAM,CAAC;KAC1B,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;CAuCpC"}

package/dist/sqlite-runtime.d.ts

@@ -0,0 +1,22 @@
+import { Runtime, type RuntimeOptions } from "@yieldstar/core";
+import { SqliteEffectClient } from "./sqlite-effect";
+import { SqliteExecutionClient } from "./sqlite-execution";
+import { SqliteHeapClient } from "./sqlite-heap";
+import { SqliteStoreClient } from "./sqlite-store";
+import type { SqliteDriver } from "./sqlite-driver";
+export type SqliteRuntimeOptions = RuntimeOptions;
+/**
+ * Execution records, step records, stores, effects and waiters in one SQLite
+ * database, so every guarantee that spans them (wakes for a store commit or an
+ * effect settlement, deleting a waiter with its step's result) holds in a
+ * single transaction.
+ */
+export declare class SqliteRuntime extends Runtime {
+    readonly clock: () => number;
+    readonly executions: SqliteExecutionClient;
+    readonly effects: SqliteEffectClient;
+    readonly heap: SqliteHeapClient;
+    readonly stores: SqliteStoreClient;
+    constructor(db: SqliteDriver, options?: SqliteRuntimeOptions);
+}
+//# sourceMappingURL=sqlite-runtime.d.ts.map

package/dist/sqlite-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-runtime.d.ts","sourceRoot":"","sources":["../src/sqlite-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAElD;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,OAAO;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;gBAEvB,EAAE,EAAE,YAAY,EAAE,OAAO,GAAE,oBAAyB;CAajE"}

package/dist/sqlite-store.d.ts

@@ -1,24 +1,38 @@
-import type { SchedulerClient } from "@yieldstar/core";
 import type { SqliteDriver } from "./sqlite-driver";
-import { CasStoreClient, type StandardSchemaV1, type StoreDefinition, type StoreDeleteFromResult, type StoreSnapshot, type StoreState, type StoreStepId, type StoreWaiter, type StoreMutation, type StoreMutationCommitResult } from "@yieldstar/core";
+import { SqliteExecutionClient } from "./sqlite-execution";
+import { CasStoreClient, type StandardSchemaV1, type StoreDefinition, type StoreDeletion, type StoreSnapshot, type StoreStepId, type StoreWaiter, type StoreMutation, type StoreMutationCommitResult } from "@yieldstar/core";
+/**
+ * Stores, waiters and the applied-steps ledger, in the same database as the
+ * execution records. A commit that satisfies waiters requests their wakes in
+ * the same transaction, so a durable commit always has durable wakes.
+ *
+ * Every write is one synchronous IMMEDIATE transaction: nothing awaits
+ * between BEGIN and COMMIT, so operations on a shared connection cannot
+ * interleave, and processes sharing the file serialize on SQLite's lock.
+ */
 export declare class SqliteStoreClient extends CasStoreClient {
     private db;
-    private schedulerClient;
-    private writeLock;
+    private executions;
+    private storeWaitersDao;
+    /**
+     * @param params.executions The execution client whose records waiters wake.
+     * Defaults to one over `db` with the default clock; SqliteRuntime passes
+     * its own so both share the runtime clock.
+     */
     constructor(params: {
         db: SqliteDriver;
-        schedulerClient: SchedulerClient;
+        executions?: SqliteExecutionClient;
     });
-    private enqueueWrite;
-    getOrCreateStore<Schema extends StandardSchemaV1>(params: {
-        definition: StoreDefinition<Schema>;
+    protected createInstanceId(): string;
+    protected readStore(params: {
+        definition: StoreDefinition;
         id: string;
-        initial?: StoreState<Schema> | (() => StoreState<Schema> | Promise<StoreState<Schema>>);
-    }): Promise<StoreSnapshot<StoreState<Schema>>>;
-    getStore<Schema extends StandardSchemaV1>(params: {
-        definition: StoreDefinition<Schema>;
+    }): Promise<StoreSnapshot<unknown> | undefined>;
+    protected insertStore(params: {
+        definition: StoreDefinition;
         id: string;
-    }): Promise<StoreSnapshot<StoreState<Schema>>>;
+        snapshot: StoreSnapshot<unknown>;
+    }): Promise<StoreSnapshot<unknown>>;
     protected getAppliedStoreStep(params: {
         definition: StoreDefinition;
         id: string;
@@ -32,23 +46,15 @@ export declare class SqliteStoreClient extends CasStoreClient {
         definition: StoreDefinition<Schema>;
         id: string;
     }): Promise<void>;
-    deleteStoreFrom(params: {
-        definition: StoreDefinition;
-        id: string;
-        snapshot: StoreSnapshot<unknown>;
-        stepId?: StoreStepId;
-    }): Promise<StoreDeleteFromResult>;
+    protected commitStoreDeletion(deletion: StoreDeletion): Promise<StoreMutationCommitResult>;
     registerWaiter(waiter: StoreWaiter): Promise<void>;
     private setupDb;
     private createStoresTable;
     private getAppliedStepRow;
     private insertAppliedStepRow;
     private getStoreRow;
-    private selectMatchingWaiters;
-    private deleteWaiterRow;
-    private insertWakeOutboxRow;
-    private drainWakeOutbox;
-    private drainWakeOutboxBestEffort;
-    private assertSnapshotHasInstanceId;
+    /** Executions with a waiter that the commit at `version` satisfies. */
+    private selectMatchingExecutionIds;
+    private insertStoreRow;
 }
 //# sourceMappingURL=sqlite-store.d.ts.map

package/dist/sqlite-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-store.d.ts","sourceRoot":"","sources":["../src/sqlite-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,iBAAiB,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAEL,cAAc,EAGd,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAE1B,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,yBAAyB,EAC/B,MAAM,iBAAiB,CAAC;AAoCzB,qBAAa,iBAAkB,SAAQ,cAAc;IACnD,OAAO,CAAC,EAAE,CAAe;IACzB,OAAO,CAAC,eAAe,CAAkB;IAEzC,OAAO,CAAC,SAAS,CAAuC;gBAE5C,MAAM,EAAE;QAAE,EAAE,EAAE,YAAY,CAAC;QAAC,eAAe,EAAE,eAAe,CAAA;KAAE;IAW1E,OAAO,CAAC,YAAY;IAMd,gBAAgB,CAAC,MAAM,SAAS,gBAAgB,EAAE,MAAM,EAAE;QAC9D,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;QACpC,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,CAAC,EACJ,UAAU,CAAC,MAAM,CAAC,GAClB,CAAC,MAAM,UAAU,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;KAC9D,GAAG,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;IAoExC,QAAQ,CAAC,MAAM,SAAS,gBAAgB,EAAE,MAAM,EAAE;QACtD,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;QACpC,EAAE,EAAE,MAAM,CAAC;KACZ,GAAG,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;cAgB9B,mBAAmB,CAAC,MAAM,EAAE;QAC1C,UAAU,EAAE,eAAe,CAAC;QAC5B,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,WAAW,CAAC;KACrB,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;IAS5C,SAAS,CAAC,mBAAmB,CAC3B,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC,yBAAyB,CAAC;IA+F/B,UAAU,CAAC,MAAM,SAAS,gBAAgB,EAC9C,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,GAClC,OAAO,CAAC,MAAM,EAAE,CAAC;IAWd,WAAW,CAAC,MAAM,SAAS,gBAAgB,EAAE,MAAM,EAAE;QACzD,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;QACpC,EAAE,EAAE,MAAM,CAAC;KACZ,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BX,eAAe,CAAC,MAAM,EAAE;QAC5B,UAAU,EAAE,eAAe,CAAC;QAC5B,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;QACjC,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA8E5B,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA6DxD,OAAO,CAAC,OAAO;IAmCf,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IAqBzB,OAAO,CAAC,oBAAoB;IAsB5B,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,qBAAqB;IAiC7B,OAAO,CAAC,eAAe;IAyBvB,OAAO,CAAC,mBAAmB;YAoBb,eAAe;YAyDf,yBAAyB;IASvC,OAAO,CAAC,2BAA2B;CAOpC"}
+{"version":3,"file":"sqlite-store.d.ts","sourceRoot":"","sources":["../src/sqlite-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,EAEL,cAAc,EAId,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,aAAa,EAElB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,yBAAyB,EAC/B,MAAM,iBAAiB,CAAC;AAgBzB;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,cAAc;IACnD,OAAO,CAAC,EAAE,CAAe;IACzB,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,eAAe,CAAkB;IAEzC;;;;OAIG;gBACS,MAAM,EAAE;QAAE,EAAE,EAAE,YAAY,CAAC;QAAC,UAAU,CAAC,EAAE,qBAAqB,CAAA;KAAE;IAQ5E,SAAS,CAAC,gBAAgB,IAAI,MAAM;cAIpB,SAAS,CAAC,MAAM,EAAE;QAChC,UAAU,EAAE,eAAe,CAAC;QAC5B,EAAE,EAAE,MAAM,CAAC;KACZ,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;cAK/B,WAAW,CAAC,MAAM,EAAE;QAClC,UAAU,EAAE,eAAe,CAAC;QAC5B,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;KAClC,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;cAenB,mBAAmB,CAAC,MAAM,EAAE;QAC1C,UAAU,EAAE,eAAe,CAAC;QAC5B,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,WAAW,CAAC;KACrB,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;cAS5B,mBAAmB,CACjC,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC,yBAAyB,CAAC;IAgF/B,UAAU,CAAC,MAAM,SAAS,gBAAgB,EAC9C,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,GAClC,OAAO,CAAC,MAAM,EAAE,CAAC;IAWd,WAAW,CAAC,MAAM,SAAS,gBAAgB,EAAE,MAAM,EAAE;QACzD,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;QACpC,EAAE,EAAE,MAAM,CAAC;KACZ,GAAG,OAAO,CAAC,IAAI,CAAC;cAcD,mBAAmB,CACjC,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC,yBAAyB,CAAC;IAyC/B,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBxD,OAAO,CAAC,OAAO;IAef,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IAqBzB,OAAO,CAAC,oBAAoB;IAsB5B,OAAO,CAAC,WAAW;IAYnB,uEAAuE;IACvE,OAAO,CAAC,0BAA0B;IAwBlC,OAAO,CAAC,cAAc;CAoBvB"}

package/dist/sqlite-transaction.d.ts

@@ -0,0 +1,9 @@
+import type { SqliteDriver } from "./sqlite-driver";
+/**
+ * Runs `fn` in one `BEGIN IMMEDIATE … COMMIT` transaction, rolling back if it
+ * throws. `fn` is synchronous so no other operation on this connection can
+ * interleave, and IMMEDIATE takes the write lock up front so concurrent
+ * processes sharing the database file serialize on it.
+ */
+export declare function runTransaction<R>(db: SqliteDriver, fn: () => R): R;
+//# sourceMappingURL=sqlite-transaction.d.ts.map

package/dist/sqlite-transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-transaction.d.ts","sourceRoot":"","sources":["../src/sqlite-transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAUlE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yieldstar/sqlite-runtime",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "license": "MIT",
   "author": "Daniel Grant",
   "repository": {
@@ -31,7 +31,7 @@
   "dependencies": {
     "pino": "^9.9.0",
     "uuid": "^11.1.0",
-    "@yieldstar/core": "0.5.0"
+    "@yieldstar/core": "0.6.0"
   },
   "devDependencies": {
     "@types/bun": "^1.2.21",

package/src/dao/effect-waiters-dao.ts

@@ -0,0 +1,63 @@
+import type { SqliteDriver } from "../sqlite-driver";
+
+class EffectWaiterRow {
+  execution_id!: string;
+}
+
+/**
+ * Effect waiters live in the same database as step records, so the heap can
+ * delete a waiter in the same transaction that records its step's result.
+ * Callers own the surrounding transaction.
+ */
+export class EffectWaitersDao {
+  private db: SqliteDriver;
+
+  constructor(db: SqliteDriver) {
+    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: { effectId: string; executionId: string; stepKey: string }) {
+    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: string): string[] {
+    return this.db
+      .query<EffectWaiterRow>(
+        `SELECT DISTINCT execution_id FROM effect_waiters WHERE effect_id = $effectId`
+      )
+      .all({ $effectId: effectId })
+      .map((row) => row.execution_id);
+  }
+
+  deleteStepWaiters(executionId: string, stepKey: string) {
+    this.db
+      .query(
+        `DELETE FROM effect_waiters WHERE execution_id = $executionId AND step_key = $stepKey`
+      )
+      .run({ $executionId: executionId, $stepKey: stepKey });
+  }
+}

package/src/dao/effects-dao.ts

@@ -0,0 +1,123 @@
+import type { EffectConflictState, EffectState } from "@yieldstar/core";
+import type { SqliteDriver } from "../sqlite-driver";
+
+class EffectRow {
+  effect_id!: string;
+  operation!: string;
+  input!: string;
+  status!: EffectState["status"];
+  result!: string | null;
+}
+
+class EffectConflictRow {
+  result!: string;
+  conflicting_result!: string;
+  reported_at!: number;
+}
+
+/**
+ * Effect records and their conflict reports. Neither is deleted with an
+ * execution. Callers own the surrounding transaction.
+ */
+export class EffectsDao {
+  private db: SqliteDriver;
+
+  constructor(db: SqliteDriver) {
+    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: string): EffectState | undefined {
+    const row = this.db
+      .query<EffectRow>(`SELECT * FROM effects WHERE effect_id = $effectId`)
+      .get({ $effectId: effectId });
+    if (!row) return undefined;
+    const conflicts = this.db
+      .query<EffectConflictRow>(
+        `SELECT result, conflicting_result, reported_at FROM effect_conflicts
+         WHERE effect_id = $effectId
+         ORDER BY reported_at, rowid`
+      )
+      .all({ $effectId: effectId });
+    const state: EffectState = {
+      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: EffectState) {
+    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,
+      });
+  }
+
+  /** Writes a transition from `before` to `after`: the settlement and any new conflict reports. */
+  updateState(before: EffectState, after: EffectState) {
+    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);
+    }
+  }
+
+  private insertConflict(effectId: string, conflict: EffectConflictState) {
+    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,
+      });
+  }
+}