@effect-app/infra 4.0.0-beta.257 → 4.0.0-beta.259

package/dist/WorkflowEngineSqlite.js

@@ -0,0 +1,550 @@
+/**
+ * SQLite backed {@link WorkflowEngine} implementation.
+ *
+ * Persists workflow state across four tables:
+ *   - `workflow_exec`     — one row per execution; tracks status, lease, etag
+ *   - `workflow_activity` — recorded activity results keyed by (exec, name, attempt)
+ *   - `workflow_deferred` — durable deferred completions keyed by (exec, name)
+ *   - `workflow_clock`    — scheduled clocks with `fire_at`
+ *
+ * Atomicity: multi-statement operations are wrapped in `sql.withTransaction`
+ * (BEGIN/COMMIT) so concurrent writers do not observe partial state.
+ *
+ * Optimistic concurrency:
+ *   - exec state transitions use `UPDATE ... WHERE etag = ? RETURNING etag`;
+ *     a zero-row result is an `OptimisticConcurrencyException`.
+ *   - activity / deferred / clock inserts use `INSERT ... ON CONFLICT DO
+ *     NOTHING RETURNING ...` for first-writer-wins semantics across drivers.
+ *
+ * Durability — everything that crosses the storage boundary is round-tripped
+ * through schema codecs (`S.fromJsonString(S.toCodecJson(...))`), exactly like
+ * the cluster engine:
+ *
+ * - The workflow payload and the top-level `Workflow.Result` are encoded with
+ *   the workflow's own `payloadSchema` / `successSchema` / `errorSchema`, so
+ *   typed values (dates, branded ids, schema classes) survive a restart.
+ * - Activity results flow through the engine already encoded, so they are
+ *   persisted with an opaque `Workflow.Result({ success: AnyOrVoid, error:
+ *   AnyOrVoid })` codec — same trick the cluster `ActivityRpc` uses.
+ * - Durable-deferred exits use an opaque `Exit` codec.
+ *
+ * Crash recovery: each driver holds a time-bound lease on the exec row,
+ * renewed by a heartbeat fiber. A scope-bound recovery poller re-drives any
+ * exec whose lease has lapsed. A clock poller fires due clocks even when
+ * the in-process timer is missing (e.g. after a restart).
+ */
+import * as Effect from "effect-app/Effect";
+import * as Layer from "effect-app/Layer";
+import * as Option from "effect-app/Option";
+import * as S from "effect-app/Schema";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as FiberMap from "effect/FiberMap";
+import * as Schedule from "effect/Schedule";
+import { SqlClient } from "effect/unstable/sql";
+import * as Workflow from "effect/unstable/workflow/Workflow";
+import { makeUnsafe, WorkflowEngine, WorkflowInstance } from "effect/unstable/workflow/WorkflowEngine";
+import { randomUUID } from "node:crypto";
+import { OptimisticConcurrencyException } from "./errors.js";
+import { annotateDb } from "./otel.js";
+const parseExec = (row) => ({
+    executionId: row.execution_id,
+    workflowName: row.workflow_name,
+    payload: row.payload,
+    parent: row.parent ?? undefined,
+    status: row.status,
+    suspended: row.suspended !== 0,
+    interrupted: row.interrupted !== 0,
+    completedResult: row.completed_result ?? undefined,
+    worker: row.worker ?? undefined,
+    leaseExpiresAt: row.lease_expires_at ?? undefined,
+    etag: row.etag
+});
+// --- Storage codecs ---------------------------------------------------------
+// Values flowing through the engine's activity / deferred boundary are already
+// schema-encoded, so the structure is round-tripped while the payload stays
+// opaque (mirrors the cluster engine's `AnyOrVoid` usage).
+const AnyOrVoid = S.Union([S.Any, S.Void]);
+const ActivityResultCodec = S.fromJsonString(S.toCodecJson(Workflow.Result({ success: AnyOrVoid, error: AnyOrVoid })));
+const DeferredExitCodec = S.fromJsonString(S.toCodecJson(S.Exit(AnyOrVoid, AnyOrVoid, S.Defect)));
+const encodeActivityResult = (r) => Effect.orDie(S.encodeEffect(ActivityResultCodec)(r));
+const decodeActivityResult = (s) => Effect.orDie(S.decodeEffect(ActivityResultCodec)(s));
+const encodeDeferredExit = (e) => Effect.orDie(S.encodeEffect(DeferredExitCodec)(e));
+const decodeDeferredExit = (s) => Effect.orDie(S.decodeEffect(DeferredExitCodec)(s));
+const makeSqliteWorkflowEngine = Effect.fnUntraced(function* (cfg) {
+    const sql = yield* SqlClient.SqlClient;
+    const scope = yield* Effect.scope;
+    const prefix = cfg.prefix ?? "";
+    const execTable = `${prefix}workflow_exec`;
+    const activityTable = `${prefix}workflow_activity`;
+    const deferredTable = `${prefix}workflow_deferred`;
+    const clockTable = `${prefix}workflow_clock`;
+    const workerId = cfg.workerId ?? randomUUID();
+    const leaseTtl = cfg.leaseTtl ?? Duration.seconds(30);
+    const heartbeatInterval = cfg.heartbeatInterval ?? Duration.seconds(10);
+    const recoveryInterval = cfg.recoveryInterval ?? Duration.seconds(15);
+    const clockPollInterval = cfg.clockPollInterval ?? Duration.seconds(5);
+    const annotate = (operation, executionId) => annotateDb({
+        operation,
+        system: "sqlite",
+        collection: execTable,
+        entity: "workflow",
+        extra: executionId !== undefined ? { "app.entity.id": executionId } : undefined
+    });
+    const exec = (query, params = []) => sql.unsafe(query, params).pipe(Effect.orDie);
+    // --- Schema -----------------------------------------------------------
+    yield* exec(`CREATE TABLE IF NOT EXISTS "${execTable}" (
+       execution_id TEXT PRIMARY KEY,
+       workflow_name TEXT NOT NULL,
+       payload TEXT NOT NULL,
+       parent TEXT,
+       status TEXT NOT NULL,
+       suspended INTEGER NOT NULL DEFAULT 0,
+       interrupted INTEGER NOT NULL DEFAULT 0,
+       completed_result TEXT,
+       worker TEXT,
+       lease_expires_at INTEGER,
+       etag TEXT NOT NULL
+     )`);
+    yield* exec(`CREATE INDEX IF NOT EXISTS "${execTable}_recovery" ON "${execTable}" (status, lease_expires_at)`);
+    yield* exec(`CREATE TABLE IF NOT EXISTS "${activityTable}" (
+       execution_id TEXT NOT NULL,
+       name TEXT NOT NULL,
+       attempt INTEGER NOT NULL,
+       result TEXT NOT NULL,
+       PRIMARY KEY (execution_id, name, attempt)
+     )`);
+    yield* exec(`CREATE TABLE IF NOT EXISTS "${deferredTable}" (
+       execution_id TEXT NOT NULL,
+       name TEXT NOT NULL,
+       exit TEXT NOT NULL,
+       PRIMARY KEY (execution_id, name)
+     )`);
+    yield* exec(`CREATE TABLE IF NOT EXISTS "${clockTable}" (
+       execution_id TEXT NOT NULL,
+       name TEXT NOT NULL,
+       workflow_name TEXT NOT NULL,
+       deferred_name TEXT NOT NULL,
+       fire_at INTEGER NOT NULL,
+       PRIMARY KEY (execution_id, name)
+     )`);
+    yield* exec(`CREATE INDEX IF NOT EXISTS "${clockTable}_due" ON "${clockTable}" (fire_at)`);
+    const workflows = new Map();
+    const locals = new Map();
+    const clocks = yield* FiberMap.make();
+    // Per-workflow codecs for the typed payload + top-level result. Cached by
+    // workflow name; derived from the workflow's own schemas so typed values
+    // (dates, branded ids, schema classes) survive the storage round-trip.
+    const makePayloadCodec = (workflow) => S.fromJsonString(S.toCodecJson(workflow.payloadSchema));
+    const payloadCodecCache = new Map();
+    const payloadCodecFor = (workflow) => {
+        let c = payloadCodecCache.get(workflow.name);
+        if (!c) {
+            c = makePayloadCodec(workflow);
+            payloadCodecCache.set(workflow.name, c);
+        }
+        return c;
+    };
+    const makeResultCodec = (workflow) => S.fromJsonString(S.toCodecJson(Workflow.Result({ success: workflow.successSchema, error: workflow.errorSchema })));
+    const resultCodecCache = new Map();
+    const resultCodecFor = (workflow) => {
+        let c = resultCodecCache.get(workflow.name);
+        if (!c) {
+            c = makeResultCodec(workflow);
+            resultCodecCache.set(workflow.name, c);
+        }
+        return c;
+    };
+    const encodePayload = (workflow, payload) => Effect.orDie(S.encodeEffect(payloadCodecFor(workflow))(payload));
+    const decodePayload = (workflow, s) => Effect.orDie(S.decodeEffect(payloadCodecFor(workflow))(s));
+    const encodeResult = (workflow, r) => Effect.orDie(S.encodeEffect(resultCodecFor(workflow))(r));
+    const decodeResult = (workflow, s) => Effect.orDie(S.decodeEffect(resultCodecFor(workflow))(s));
+    // --- Core SQL operations ----------------------------------------------
+    const readExec = (executionId) => exec(`SELECT * FROM "${execTable}" WHERE execution_id = ?`, [executionId])
+        .pipe(Effect.map((rows) => {
+        const r = rows[0];
+        return r ? Option.some(parseExec(r)) : Option.none();
+    }), annotate("readExec", executionId));
+    /**
+     * OCC-guarded write. Generates a fresh etag on success; returns
+     * `OptimisticConcurrencyException` when no row matches the prior etag.
+     */
+    const replaceExec = (state, next) => Effect
+        .gen(function* () {
+        const newEtag = randomUUID();
+        const merged = { ...state, ...next, etag: newEtag };
+        const rows = yield* exec(`UPDATE "${execTable}"
+           SET status = ?,
+               suspended = ?,
+               interrupted = ?,
+               completed_result = ?,
+               worker = ?,
+               lease_expires_at = ?,
+               etag = ?
+         WHERE execution_id = ? AND etag = ?
+         RETURNING etag`, [
+            merged.status,
+            merged.suspended ? 1 : 0,
+            merged.interrupted ? 1 : 0,
+            merged.completedResult ?? null,
+            merged.worker ?? null,
+            merged.leaseExpiresAt ?? null,
+            newEtag,
+            state.executionId,
+            state.etag
+        ]);
+        if (rows.length === 0) {
+            return yield* new OptimisticConcurrencyException({
+                type: "workflow.exec",
+                id: state.executionId,
+                code: 412
+            });
+        }
+        return merged;
+    })
+        .pipe(annotate("replaceExec", state.executionId));
+    const createExec = (initial) => exec(`INSERT INTO "${execTable}"
+         (execution_id, workflow_name, payload, parent, status, suspended, interrupted, etag)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT DO NOTHING
+       RETURNING execution_id`, [
+        initial.executionId,
+        initial.workflowName,
+        initial.payload,
+        initial.parent ?? null,
+        initial.status,
+        initial.suspended ? 1 : 0,
+        initial.interrupted ? 1 : 0,
+        initial.etag
+    ])
+        .pipe(Effect.map((rows) => rows.length > 0), annotate("createExec", initial.executionId));
+    // First-writer-wins persistence of an activity result; returns true if this
+    // call won, false if another writer beat us to the (exec, name, attempt) row.
+    const createActivity = (executionId, name, attempt, encoded) => exec(`INSERT INTO "${activityTable}" (execution_id, name, attempt, result)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT DO NOTHING
+       RETURNING execution_id`, [executionId, name, attempt, encoded])
+        .pipe(Effect.map((rows) => rows.length > 0));
+    // Overwrites a previously persisted *suspended* activity result so the next
+    // attempt can record its real outcome.
+    const upsertActivity = (executionId, name, attempt, encoded) => exec(`INSERT INTO "${activityTable}" (execution_id, name, attempt, result)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(execution_id, name, attempt) DO UPDATE SET result = excluded.result`, [executionId, name, attempt, encoded])
+        .pipe(Effect.asVoid);
+    const readActivity = (executionId, name, attempt) => exec(`SELECT result FROM "${activityTable}" WHERE execution_id = ? AND name = ? AND attempt = ?`, [executionId, name, attempt])
+        .pipe(Effect.map((rows) => {
+        const r = rows[0];
+        return r ? Option.some(r.result) : Option.none();
+    }));
+    const createDeferred = (executionId, name, encoded) => exec(`INSERT INTO "${deferredTable}" (execution_id, name, exit)
+       VALUES (?, ?, ?)
+       ON CONFLICT DO NOTHING
+       RETURNING execution_id`, [executionId, name, encoded])
+        .pipe(Effect.map((rows) => rows.length > 0));
+    const readDeferred = (executionId, name) => exec(`SELECT exit FROM "${deferredTable}" WHERE execution_id = ? AND name = ?`, [executionId, name])
+        .pipe(Effect.map((rows) => {
+        const r = rows[0];
+        return r ? Option.some(r.exit) : Option.none();
+    }));
+    const insertClock = (executionId, name, workflowName, deferredName, fireAt) => exec(`INSERT INTO "${clockTable}" (execution_id, name, workflow_name, deferred_name, fire_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT DO NOTHING
+       RETURNING execution_id`, [executionId, name, workflowName, deferredName, fireAt])
+        .pipe(Effect.map((rows) => rows.length > 0));
+    const deleteClock = (executionId, name) => exec(`DELETE FROM "${clockTable}" WHERE execution_id = ? AND name = ?`, [executionId, name]);
+    // --- Workflow result helpers ------------------------------------------
+    const completeResult = (workflow, state) => state.status === "complete" && state.completedResult
+        ? Effect.map(decodeResult(workflow, state.completedResult), Option.some)
+        : Effect.succeedNone;
+    // --- Lease / claim ----------------------------------------------------
+    const leaseActive = (state, now) => state.worker !== undefined
+        && state.worker !== workerId
+        && state.leaseExpiresAt !== undefined
+        && state.leaseExpiresAt > now;
+    const tryClaim = (state) => Effect.gen(function* () {
+        const now = Date.now();
+        if (leaseActive(state, now))
+            return Option.none();
+        return yield* replaceExec(state, {
+            worker: workerId,
+            leaseExpiresAt: now + Duration.toMillis(leaseTtl)
+        })
+            .pipe(Effect.map(Option.some), Effect.catchTag("OptimisticConcurrencyException", () => Effect.succeed(Option.none())));
+    });
+    const heartbeat = (executionId) => Effect.gen(function* () {
+        while (true) {
+            yield* Effect.sleep(heartbeatInterval);
+            const local = locals.get(executionId);
+            const polled = local?.fiber?.pollUnsafe();
+            if (!local?.fiber || polled)
+                return;
+            const cur = yield* readExec(executionId).pipe(Effect.catchCause(() => Effect.succeed(Option.none())));
+            if (Option.isNone(cur))
+                continue;
+            const state = cur.value;
+            if (state.status === "complete" || state.worker !== workerId)
+                return;
+            yield* replaceExec(state, {
+                leaseExpiresAt: Date.now() + Duration.toMillis(leaseTtl)
+            })
+                .pipe(Effect.catchTag("OptimisticConcurrencyException", () => Effect.void), Effect.catchCause(() => Effect.void));
+        }
+    });
+    // --- Drive logic ------------------------------------------------------
+    const drive = (executionId, payload, parent, entry) => Effect.gen(function* () {
+        let local = locals.get(executionId);
+        if (local?.fiber) {
+            const polled = local.fiber.pollUnsafe();
+            const stillRunning = !polled;
+            const completedNotResume = polled && polled._tag === "Success" && polled.value._tag === "Complete";
+            if (stillRunning || completedNotResume)
+                return;
+        }
+        const stateOpt = yield* readExec(executionId);
+        if (Option.isNone(stateOpt) || stateOpt.value.status === "complete")
+            return;
+        const claimed = yield* tryClaim(stateOpt.value);
+        const state = Option.isSome(claimed) ? claimed.value : stateOpt.value;
+        const instance = WorkflowInstance.initial(entry.workflow, executionId);
+        instance.interrupted = state.interrupted;
+        if (!local) {
+            local = { instance, fiber: undefined, parent };
+            locals.set(executionId, local);
+        }
+        else {
+            local.instance = instance;
+        }
+        const onComplete = Effect.fnUntraced(function* (result) {
+            const current = yield* readExec(executionId);
+            if (Option.isNone(current) || current.value.status === "complete")
+                return;
+            const isComplete = result._tag === "Complete";
+            const completedResult = isComplete ? yield* encodeResult(entry.workflow, result) : undefined;
+            yield* replaceExec(current.value, {
+                status: isComplete ? "complete" : current.value.status,
+                suspended: result._tag === "Suspended",
+                interrupted: instance.interrupted,
+                completedResult,
+                worker: isComplete ? undefined : current.value.worker,
+                leaseExpiresAt: isComplete ? undefined : current.value.leaseExpiresAt
+            })
+                .pipe(Effect.catchTag("OptimisticConcurrencyException", () => Effect.void));
+            if (parent && isComplete) {
+                yield* Effect.forkIn(driveById(parent), scope);
+            }
+        });
+        local.fiber = yield* entry.execute(payload, executionId).pipe(Effect.onExit(() => {
+            if (!instance.interrupted)
+                return Effect.void;
+            instance.suspended = false;
+            return Effect.withFiber((fiber) => Effect.interruptible(Fiber.interrupt(fiber)));
+        }), Workflow.intoResult, Effect.provideService(WorkflowInstance, instance), Effect.provideService(WorkflowEngine, engine), Effect.tap(onComplete), Effect.forkIn(entry.scope));
+        if (Option.isSome(claimed)) {
+            yield* Effect.forkIn(heartbeat(executionId), scope);
+        }
+    });
+    const driveById = (executionId) => Effect.gen(function* () {
+        const stateOpt = yield* readExec(executionId);
+        if (Option.isNone(stateOpt))
+            return;
+        const state = stateOpt.value;
+        const entry = workflows.get(state.workflowName);
+        if (!entry)
+            return;
+        const payload = yield* decodePayload(entry.workflow, state.payload);
+        yield* drive(executionId, payload, state.parent, entry);
+    });
+    // --- Clock firing -----------------------------------------------------
+    const fireClock = (executionId, name, deferredName) => Effect
+        .gen(function* () {
+        const encoded = yield* encodeDeferredExit(Exit.void);
+        const inserted = yield* sql
+            .withTransaction(Effect.gen(function* () {
+            const got = yield* createDeferred(executionId, deferredName, encoded);
+            yield* deleteClock(executionId, name);
+            return got;
+        }))
+            .pipe(Effect.orDie);
+        if (inserted)
+            yield* driveById(executionId);
+    })
+        .pipe(annotate("clockFire", executionId));
+    // --- Encoded engine ---------------------------------------------------
+    const encoded = {
+        register: Effect.fnUntraced(function* (workflow, execute) {
+            workflows.set(workflow.name, {
+                workflow,
+                execute,
+                scope: yield* Effect.scope
+            });
+        }),
+        execute: Effect.fnUntraced(function* (workflow, options) {
+            const entry = workflows.get(workflow.name);
+            if (!entry) {
+                return yield* Effect.orDie(Effect.fail(`Workflow ${workflow.name} is not registered`));
+            }
+            const initial = {
+                executionId: options.executionId,
+                workflowName: workflow.name,
+                payload: yield* encodePayload(workflow, options.payload),
+                parent: options.parent?.executionId,
+                status: "running",
+                suspended: false,
+                interrupted: false,
+                completedResult: undefined,
+                worker: undefined,
+                leaseExpiresAt: undefined,
+                etag: randomUUID()
+            };
+            yield* createExec(initial);
+            yield* drive(options.executionId, options.payload, options.parent?.executionId, entry);
+            if (options.discard)
+                return undefined;
+            const local = locals.get(options.executionId);
+            if (local?.fiber) {
+                return (yield* Fiber.join(local.fiber));
+            }
+            // Foreign-driver fallback: poll the persisted result until completion.
+            while (true) {
+                const cur = yield* readExec(options.executionId);
+                if (Option.isSome(cur)) {
+                    const r = yield* completeResult(workflow, cur.value);
+                    if (Option.isSome(r))
+                        return r.value;
+                }
+                yield* Effect.sleep(Duration.millis(500));
+            }
+        }),
+        poll: (workflow, executionId) => Effect.gen(function* () {
+            const local = locals.get(executionId);
+            if (local?.fiber) {
+                const exitVal = local.fiber.pollUnsafe();
+                if (!exitVal)
+                    return Option.none();
+                if (exitVal._tag !== "Success")
+                    return yield* Effect.die(exitVal.cause);
+                return Option.some(exitVal.value);
+            }
+            const state = yield* readExec(executionId);
+            if (Option.isNone(state))
+                return Option.none();
+            return yield* completeResult(workflow, state.value);
+        }),
+        interrupt: Effect.fnUntraced(function* (_workflow, executionId) {
+            const local = locals.get(executionId);
+            if (local)
+                local.instance.interrupted = true;
+            const current = yield* readExec(executionId);
+            if (Option.isNone(current) || current.value.status === "complete")
+                return;
+            yield* replaceExec(current.value, { interrupted: true }).pipe(Effect.catchTag("OptimisticConcurrencyException", () => Effect.void));
+            yield* driveById(executionId);
+        }),
+        interruptUnsafe: Effect.fnUntraced(function* (_workflow, executionId) {
+            const local = locals.get(executionId);
+            if (local)
+                local.instance.interrupted = true;
+            const current = yield* readExec(executionId);
+            if (Option.isSome(current) && current.value.status !== "complete") {
+                yield* replaceExec(current.value, { interrupted: true }).pipe(Effect.catchTag("OptimisticConcurrencyException", () => Effect.void));
+            }
+            if (local?.fiber)
+                yield* Fiber.interrupt(local.fiber);
+        }),
+        resume: (_workflow, executionId) => driveById(executionId),
+        activityExecute: Effect.fnUntraced(function* (activity, attempt) {
+            const instance = yield* WorkflowInstance;
+            const existing = yield* readActivity(instance.executionId, activity.name, attempt);
+            if (Option.isSome(existing)) {
+                const prev = yield* decodeActivityResult(existing.value);
+                // A completed activity is replayed from its persisted result; a
+                // suspended one must re-run (it parked on a clock/deferred).
+                if (prev._tag === "Complete")
+                    return prev;
+            }
+            const activityInstance = WorkflowInstance.initial(instance.workflow, instance.executionId);
+            activityInstance.interrupted = instance.interrupted;
+            const result = yield* activity.executeEncoded.pipe(Workflow.intoResult, Effect.provideService(WorkflowInstance, activityInstance));
+            const encodedResult = yield* encodeActivityResult(result);
+            if (Option.isSome(existing)) {
+                // Overwrite the previously persisted *suspended* result.
+                yield* upsertActivity(instance.executionId, activity.name, attempt, encodedResult);
+                return result;
+            }
+            // First-writer-wins: if persistence loses the race, use the persisted result.
+            const persisted = yield* createActivity(instance.executionId, activity.name, attempt, encodedResult);
+            if (persisted)
+                return result;
+            const winner = yield* readActivity(instance.executionId, activity.name, attempt);
+            if (Option.isSome(winner)) {
+                const w = yield* decodeActivityResult(winner.value);
+                if (w._tag === "Complete")
+                    return w;
+            }
+            return result;
+        }),
+        deferredResult: Effect.fnUntraced(function* (deferred) {
+            const instance = yield* WorkflowInstance;
+            const got = yield* readDeferred(instance.executionId, deferred.name);
+            if (Option.isNone(got))
+                return Option.none();
+            return Option.some(yield* decodeDeferredExit(got.value));
+        }),
+        deferredDone: Effect.fnUntraced(function* (options) {
+            const encoded = yield* encodeDeferredExit(options.exit);
+            const inserted = yield* createDeferred(options.executionId, options.deferredName, encoded);
+            if (!inserted)
+                return;
+            yield* driveById(options.executionId);
+        }),
+        scheduleClock: (workflow, options) => {
+            const fireAt = Date.now() + Duration.toMillis(options.clock.duration);
+            return Effect.gen(function* () {
+                yield* insertClock(options.executionId, options.clock.name, workflow.name, options.clock.deferred.name, fireAt);
+                yield* fireClock(options.executionId, options.clock.name, options.clock.deferred.name).pipe(Effect.delay(options.clock.duration), FiberMap.run(clocks, `${options.executionId}/${options.clock.name}`, { onlyIfMissing: true }), Effect.asVoid);
+            });
+        }
+    };
+    const engine = makeUnsafe(encoded);
+    // --- Recovery poller --------------------------------------------------
+    if (Duration.toMillis(recoveryInterval) > 0) {
+        const recoverStep = Effect
+            .gen(function* () {
+            const rows = yield* exec(`SELECT execution_id, workflow_name FROM "${execTable}"
+         WHERE status = 'running' AND (lease_expires_at IS NULL OR lease_expires_at <= ?)
+         LIMIT 100`, [Date.now()]);
+            for (const row of rows) {
+                if (!workflows.has(row.workflow_name))
+                    continue;
+                const local = locals.get(row.execution_id);
+                if (local?.fiber && !local.fiber.pollUnsafe())
+                    continue;
+                yield* Effect.forkIn(driveById(row.execution_id), scope);
+            }
+        })
+            .pipe(annotate("recoveryScan"), Effect.catchCause(() => Effect.void));
+        yield* recoverStep.pipe(Effect.repeat(Schedule.spaced(recoveryInterval)), Effect.forkIn(scope));
+    }
+    // --- Clock poller -----------------------------------------------------
+    if (Duration.toMillis(clockPollInterval) > 0) {
+        const clockStep = Effect
+            .gen(function* () {
+            const rows = yield* exec(`SELECT execution_id, name, deferred_name FROM "${clockTable}"
+         WHERE fire_at <= ?
+         LIMIT 100`, [Date.now()]);
+            for (const row of rows) {
+                yield* Effect.forkIn(fireClock(row.execution_id, row.name, row.deferred_name), scope);
+            }
+        })
+            .pipe(annotate("clockScan"), Effect.catchCause(() => Effect.void));
+        yield* clockStep.pipe(Effect.repeat(Schedule.spaced(clockPollInterval)), Effect.forkIn(scope));
+    }
+    return engine;
+});
+/**
+ * SQLite backed `WorkflowEngine` layer. Requires an ambient `SqlClient`
+ * (`@effect/sql-sqlite-node` or a compatible client).
+ */
+export const layerSqlite = (cfg = {}) => Layer.effect(WorkflowEngine)(makeSqliteWorkflowEngine(cfg));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WorkflowEngineSqlite.js","sourceRoot":"","sources":["../src/WorkflowEngineSqlite.ts"],"names":[],"mappings":"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"}

package/docs/cluster-storage.md

@@ -0,0 +1,26 @@
+# Cluster storage backends (Cosmos vs SQL)
+
+`@effect-app/infra` now ships Cosmos-backed cluster storage:
+
+- [`ClusterCosmos.layerMessageStorage`](../src/ClusterCosmos.ts)
+- [`ClusterCosmos.layerRunnerStorage`](../src/ClusterCosmos.ts)
+- [`ClusterCosmos.layer`](../src/ClusterCosmos.ts)
+- [`ClusterCosmos.layerCosmos`](../src/ClusterCosmos.ts)
+
+The closest baseline in Effect is `SqlMessageStorage` + `SqlRunnerStorage`.
+
+## Comparison
+
+| Aspect              | `ClusterCosmos`                                                           | `SqlMessageStorage` + `SqlRunnerStorage`                                                    |
+| ------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Backend dependency  | Azure Cosmos DB                                                           | SQL database via `SqlClient`                                                                |
+| Schema management   | Container-only document model (no SQL migrations)                         | Creates / migrates SQL tables (`messages`, `replies`, `runners`, `locks`, migrations table) |
+| Message/reply model | JSON docs split by partition key (`message::shardId`, `reply::requestId`) | Relational rows with SQL indexes and joins                                                  |
+| Locking strategy    | Optimistic concurrency (`_etag`) on lock docs                             | Dialect-aware SQL locking (including advisory locks on pg/mysql when enabled)               |
+| Horizontal behavior | Throughput/cost depends on partitioning and cross-partition queries       | Throughput/cost depends on SQL indexing, query plans, and connection limits                 |
+| Operational fit     | Best when Cosmos is already your system DB                                | Best when the cluster already runs on SQL infrastructure                                    |
+
+## Practical guidance
+
+- Pick **`ClusterCosmos`** when your platform standard is Cosmos and you want to avoid introducing SQL just for cluster storage.
+- Pick **SQL storage** when you already have strong SQL ops tooling and prefer table/migration based durability.