@effect-app/infra 4.0.0-beta.26 → 4.0.0-beta.260

package/dist/WorkflowEngineCosmos.js

@@ -0,0 +1,521 @@
+/**
+ * Cosmos DB backed {@link WorkflowEngine} implementation.
+ *
+ * Persists workflow state in a single container partitioned by `executionId`
+ * so per-execution writes share a partition key (eligible for Cosmos
+ * TransactionalBatch). Optimistic concurrency is enforced with `_etag` +
+ * `IfMatch` on Replace, and create-only batch ops give first-writer-wins
+ * semantics for activity results and durable-deferred completions.
+ *
+ * Durability — everything that crosses the storage boundary is round-tripped
+ * through schema codecs (`S.fromJsonString(S.toCodecJson(...))`), exactly like
+ * the cluster engine, instead of dumping live runtime objects as JSON:
+ *
+ * - 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 and clock completions use an opaque `Exit` codec.
+ *
+ * Crash recovery: each driver holds a time-bound lease (`worker` +
+ * `leaseExpiresAt`) on the exec doc and renews it via a heartbeat fiber. A
+ * scope-bound recovery poller queries for exec docs whose lease has lapsed and
+ * re-drives them in the local process, decoding the persisted payload and
+ * picking up persisted activity results from where the crashed driver left off.
+ *
+ * Durable clocks: `scheduleClock` writes a clock doc (`fireAt`, `deferredName`)
+ * and arms an in-process timer. A cross-partition clock poller fires any clock
+ * whose `fireAt` is due, completing the deferred idempotently (create-only) and
+ * deleting the doc. Survives restarts.
+ */
+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 Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
+import * as Workflow from "effect/unstable/workflow/Workflow";
+import { makeUnsafe, WorkflowEngine, WorkflowInstance } from "effect/unstable/workflow/WorkflowEngine";
+import { randomUUID } from "node:crypto";
+import { CosmosClient, CosmosClientLayer } from "./cosmos-client.js";
+import { OptimisticConcurrencyException } from "./errors.js";
+import { annotateCosmosResponse, annotateDb } from "./otel.js";
+const execId = "exec";
+const activityKey = (name, attempt) => `activity::${name}::${attempt}`;
+const deferredKey = (name) => `deferred::${name}`;
+const clockKey = (name) => `clock::${name}`;
+const isOptimisticStatus = (code) => code === 409 || code === 412 || code === 404;
+// --- 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 makeCosmosWorkflowEngine = Effect.fnUntraced(function* (cfg) {
+    const { db } = yield* CosmosClient;
+    const containerId = `${cfg.prefix ?? ""}workflow-engine`;
+    yield* Effect.promise(() => db.containers.createIfNotExists({
+        id: containerId,
+        partitionKey: { paths: ["/_partitionKey"], version: 2 }
+    }));
+    const container = db.container(containerId);
+    const scope = yield* Effect.scope;
+    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: "cosmosdb",
+        collection: containerId,
+        entity: "workflow",
+        extra: executionId !== undefined
+            ? { "azure.cosmosdb.operation.partition_key": executionId, "app.entity.id": executionId }
+            : undefined
+    });
+    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));
+    // --- Cosmos primitives -------------------------------------------------
+    const readExec = (executionId) => Effect
+        .gen(function* () {
+        const resp = yield* Effect.promise(() => container.item(execId, executionId).read());
+        yield* annotateCosmosResponse({ requestCharge: resp.requestCharge, statusCode: resp.statusCode });
+        return Option.fromNullishOr(resp.resource).pipe(Option.map((r) => ({ ...r, _etag: resp.etag })));
+    })
+        .pipe(annotate("readExec", executionId));
+    const replaceExec = (doc) => Effect
+        .gen(function* () {
+        const resp = yield* Effect.promise(() => container.item(execId, doc._partitionKey).replace(doc, {
+            accessCondition: { type: "IfMatch", condition: doc._etag ?? "" }
+        }));
+        yield* annotateCosmosResponse({ requestCharge: resp.requestCharge, statusCode: resp.statusCode });
+        if (isOptimisticStatus(resp.statusCode)) {
+            return yield* new OptimisticConcurrencyException({
+                type: "workflow.exec",
+                id: doc._partitionKey,
+                code: resp.statusCode
+            });
+        }
+        return { ...doc, _etag: resp.etag };
+    })
+        .pipe(annotate("replaceExec", doc._partitionKey));
+    // Atomic create-or-noop using a single-op batch — returns true if created.
+    const createIfMissing = (body) => Effect.gen(function* () {
+        const resp = yield* Effect.promise(() => container.items.batch([{ operationType: "Create", resourceBody: body }], body._partitionKey));
+        const r = resp.result?.[0];
+        const code = r?.statusCode ?? 0;
+        if (code === 201)
+            return true;
+        if (code === 409)
+            return false;
+        return yield* Effect.die(new Error(`workflow-engine cosmos createIfMissing for ${body.id} failed: ${code}`));
+    });
+    // Last-writer-wins upsert — used to overwrite a persisted *suspended* activity
+    // result once it finally completes (create-only ops can't transition it).
+    const upsert = (body) => Effect.gen(function* () {
+        const resp = yield* Effect.promise(() => container.items.upsert(body));
+        yield* annotateCosmosResponse({ requestCharge: resp.requestCharge, statusCode: resp.statusCode });
+    });
+    const readPoint = (id, executionId) => Effect.promise(() => container.item(id, executionId).read()).pipe(Effect.map((r) => Option.fromNullishOr(r.resource)));
+    // --- 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
+        && Date.parse(state.leaseExpiresAt) > now;
+    /**
+     * Try to claim a lease on `state`. Returns the updated doc on success, `None`
+     * if another worker holds an active lease, or on OCC conflict (caller may
+     * retry by re-reading).
+     */
+    const tryClaim = (state) => Effect.gen(function* () {
+        const now = Date.now();
+        if (leaseActive(state, now))
+            return Option.none();
+        const updated = {
+            ...state,
+            worker: workerId,
+            leaseExpiresAt: new Date(now + Duration.toMillis(leaseTtl)).toISOString()
+        };
+        return yield* replaceExec(updated).pipe(Effect.map(Option.some), Effect.catchTag("OptimisticConcurrencyException", () => Effect.succeed(Option.none())));
+    });
+    /**
+     * Renew lease until the local fiber stops or another worker takes the claim.
+     * Best-effort: failures are swallowed; loop simply retries on next tick.
+     */
+    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: new Date(Date.now() + Duration.toMillis(leaseTtl)).toISOString()
+            })
+                .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;
+        // Best-effort claim: takes lease so recovery poller leaves us alone.
+        // Failure is tolerated — local fiber still drives; OCC guards persisted
+        // state so split-brain stays correct.
+        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,
+                // Release lease on completion so the doc isn't seen as orphaned.
+                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 -----------------------------------------------------
+    // Persist deferred completion (first-writer-wins via createIfMissing),
+    // resume the workflow, then clean up the clock doc.
+    const fireClock = (doc) => Effect.gen(function* () {
+        const created = yield* createIfMissing({
+            id: deferredKey(doc.deferredName),
+            _partitionKey: doc._partitionKey,
+            type: "deferred",
+            exit: yield* encodeDeferredExit(Exit.void)
+        })
+            .pipe(annotate("clockFire", doc._partitionKey));
+        if (created)
+            yield* driveById(doc._partitionKey);
+        yield* Effect.promise(() => container.item(doc.id, doc._partitionKey).delete()).pipe(Effect.catchCause(() => Effect.void));
+    });
+    // --- 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 = {
+                id: execId,
+                _partitionKey: options.executionId,
+                type: "exec",
+                workflowName: workflow.name,
+                payload: yield* encodePayload(workflow, options.payload),
+                parent: options.parent?.executionId,
+                status: "running",
+                suspended: false,
+                interrupted: false
+            };
+            const created = yield* createIfMissing(initial).pipe(annotate("execute.claim", options.executionId));
+            if (created || !locals.has(options.executionId)) {
+                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-owned execution: poll until exec doc reports complete.
+            while (true) {
+                const cur = yield* readExec(options.executionId);
+                if (Option.isSome(cur)) {
+                    const c = yield* completeResult(workflow, cur.value);
+                    if (Option.isSome(c))
+                        return c.value;
+                }
+                yield* Effect.sleep(Duration.millis(500));
+            }
+        }),
+        poll: (workflow, executionId) => Effect.gen(function* () {
+            const local = locals.get(executionId);
+            if (local?.fiber) {
+                const exit = local.fiber.pollUnsafe();
+                if (!exit)
+                    return Option.none();
+                if (exit._tag !== "Success")
+                    return yield* Effect.die(exit.cause);
+                return Option.some(exit.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 id = activityKey(activity.name, attempt);
+            const existing = yield* readPoint(id, instance.executionId).pipe(annotate("activityRead", instance.executionId));
+            if (Option.isSome(existing)) {
+                const prev = yield* decodeActivityResult(existing.value.result);
+                // 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 doc = {
+                id,
+                _partitionKey: instance.executionId,
+                type: "activity",
+                result: yield* encodeActivityResult(result)
+            };
+            if (Option.isSome(existing)) {
+                // Overwrite the previously persisted *suspended* doc with the new result.
+                yield* upsert(doc).pipe(annotate("activityPersist", instance.executionId));
+                return result;
+            }
+            // First-writer-wins: if persistence loses the race, use the persisted result.
+            const persisted = yield* createIfMissing(doc).pipe(annotate("activityPersist", instance.executionId));
+            if (persisted)
+                return result;
+            const winner = yield* readPoint(id, instance.executionId);
+            if (Option.isSome(winner)) {
+                const w = yield* decodeActivityResult(winner.value.result);
+                if (w._tag === "Complete")
+                    return w;
+            }
+            return result;
+        }),
+        deferredResult: Effect.fnUntraced(function* (deferred) {
+            const instance = yield* WorkflowInstance;
+            const got = yield* readPoint(deferredKey(deferred.name), instance.executionId).pipe(annotate("deferredRead", instance.executionId));
+            if (Option.isNone(got))
+                return Option.none();
+            return Option.some(yield* decodeDeferredExit(got.value.exit));
+        }),
+        deferredDone: Effect.fnUntraced(function* (options) {
+            const created = yield* createIfMissing({
+                id: deferredKey(options.deferredName),
+                _partitionKey: options.executionId,
+                type: "deferred",
+                exit: yield* encodeDeferredExit(options.exit)
+            })
+                .pipe(annotate("deferredPersist", options.executionId));
+            if (!created)
+                return;
+            yield* driveById(options.executionId);
+        }),
+        scheduleClock: (workflow, options) => {
+            const fireAt = new Date(Date.now() + Duration.toMillis(options.clock.duration)).toISOString();
+            const clockDoc = {
+                id: clockKey(options.clock.name),
+                _partitionKey: options.executionId,
+                type: "clock",
+                workflowName: workflow.name,
+                deferredName: options.clock.deferred.name,
+                fireAt
+            };
+            return Effect.gen(function* () {
+                yield* createIfMissing(clockDoc).pipe(annotate("clockPersist", options.executionId));
+                // Fast-path in-process timer. If this process dies, the clock poller
+                // picks up the persisted doc and fires the deferred.
+                yield* fireClock(clockDoc).pipe(Effect.delay(options.clock.duration), FiberMap.run(clocks, `${options.executionId}/${options.clock.name}`, { onlyIfMissing: true }), Effect.asVoid);
+            });
+        }
+    };
+    const engine = makeUnsafe(encoded);
+    // --- Recovery poller --------------------------------------------------
+    // Scan for executions whose lease has lapsed (or was never set) and
+    // re-drive them locally. driveById will go through claim → fork fiber,
+    // resuming activities from persisted results.
+    if (Duration.toMillis(recoveryInterval) > 0) {
+        const recoverStep = Effect
+            .gen(function* () {
+            const nowIso = new Date().toISOString();
+            const stale = yield* Effect.promise(() => container
+                .items
+                .query({
+                query: "SELECT c._partitionKey, c.workflowName FROM c WHERE c.type = 'exec' AND c.status = 'running' AND (NOT IS_DEFINED(c.leaseExpiresAt) OR c.leaseExpiresAt <= @now)",
+                parameters: [{ name: "@now", value: nowIso }]
+            })
+                .fetchAll());
+            for (const row of stale.resources) {
+                if (!workflows.has(row.workflowName))
+                    continue;
+                const local = locals.get(row._partitionKey);
+                if (local?.fiber && !local.fiber.pollUnsafe())
+                    continue;
+                yield* Effect.forkIn(driveById(row._partitionKey), scope);
+            }
+        })
+            .pipe(annotate("recoveryScan"), Effect.catchCause(() => Effect.void));
+        yield* recoverStep.pipe(Effect.repeat(Schedule.spaced(recoveryInterval)), Effect.forkIn(scope));
+    }
+    // --- Clock poller -----------------------------------------------------
+    // Cross-partition scan for clocks whose fireAt is due. Fires the deferred
+    // via createIfMissing (idempotent) so multiple pollers across processes
+    // converge. Also acts as the restart recovery path for clocks scheduled
+    // before a crash.
+    if (Duration.toMillis(clockPollInterval) > 0) {
+        const clockStep = Effect
+            .gen(function* () {
+            const nowIso = new Date().toISOString();
+            const due = yield* Effect.promise(() => container
+                .items
+                .query({
+                query: "SELECT c.id, c._partitionKey, c.workflowName, c.deferredName FROM c WHERE c.type = 'clock' AND c.fireAt <= @now",
+                parameters: [{ name: "@now", value: nowIso }]
+            })
+                .fetchAll());
+            for (const row of due.resources) {
+                yield* Effect.forkIn(fireClock({
+                    id: row.id,
+                    _partitionKey: row._partitionKey,
+                    type: "clock",
+                    workflowName: row.workflowName,
+                    deferredName: row.deferredName,
+                    fireAt: nowIso
+                }), scope);
+            }
+        })
+            .pipe(annotate("clockScan"), Effect.catchCause(() => Effect.void));
+        yield* clockStep.pipe(Effect.repeat(Schedule.spaced(clockPollInterval)), Effect.forkIn(scope));
+    }
+    return engine;
+});
+/**
+ * Cosmos DB backed `WorkflowEngine` layer.
+ *
+ * Per-execution writes share a partition key (TransactionalBatch-eligible) and
+ * use OCC via `_etag`/IfMatch, giving first-writer-wins semantics for activity
+ * results, durable-deferred completions, and exec-state transitions. All
+ * persisted payloads/results/exits are round-tripped through schema codecs.
+ */
+export const layerCosmos = (cfg) => Layer
+    .effect(WorkflowEngine)(makeCosmosWorkflowEngine(cfg))
+    .pipe(Layer.provide(CosmosClientLayer(Redacted.value(cfg.url), cfg.dbName)));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WorkflowEngineCosmos.js","sourceRoot":"","sources":["../src/WorkflowEngineCosmos.ts"],"names":[],"mappings":"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"}

package/dist/WorkflowEngineSqlite.d.ts

@@ -0,0 +1,24 @@
+import * as Layer from "effect-app/Layer";
+import * as Duration from "effect/Duration";
+import { SqlClient } from "effect/unstable/sql";
+import { WorkflowEngine } from "effect/unstable/workflow/WorkflowEngine";
+export interface WorkflowEngineSqliteConfig {
+    /** Optional prefix for table names (e.g. `tenant_`). */
+    readonly prefix?: string;
+    /** Lease duration before a claim is considered stale. Default 30s. */
+    readonly leaseTtl?: Duration.Duration;
+    /** Renewal cadence — should be < leaseTtl. Default 10s. */
+    readonly heartbeatInterval?: Duration.Duration;
+    /** Cadence for scanning stale leases. Default 15s. Set to `Duration.zero` to disable. */
+    readonly recoveryInterval?: Duration.Duration;
+    /** Cadence for scanning due clocks. Default 5s. Set to `Duration.zero` to disable. */
+    readonly clockPollInterval?: Duration.Duration;
+    /** Stable worker identity; defaults to a random UUID per process. */
+    readonly workerId?: string;
+}
+/**
+ * SQLite backed `WorkflowEngine` layer. Requires an ambient `SqlClient`
+ * (`@effect/sql-sqlite-node` or a compatible client).
+ */
+export declare const layerSqlite: (cfg?: WorkflowEngineSqliteConfig) => Layer.Layer<WorkflowEngine, never, SqlClient.SqlClient>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV29ya2Zsb3dFbmdpbmVTcWxpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9Xb3JrZmxvd0VuZ2luZVNxbGl0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFvQ0EsT0FBTyxLQUFLLEtBQUssTUFBTSxrQkFBa0IsQ0FBQTtBQUd6QyxPQUFPLEtBQUssUUFBUSxNQUFNLGlCQUFpQixDQUFBO0FBTTNDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQTtBQUUvQyxPQUFPLEVBQTRCLGNBQWMsRUFBb0IsTUFBTSx5Q0FBeUMsQ0FBQTtBQUtwSCxNQUFNLFdBQVcsMEJBQTBCO0lBQ3pDLHdEQUF3RDtJQUN4RCxRQUFRLENBQUMsTUFBTSxDQUFDLEVBQUUsTUFBTSxDQUFBO0lBQ3hCLHNFQUFzRTtJQUN0RSxRQUFRLENBQUMsUUFBUSxDQUFDLEVBQUUsUUFBUSxDQUFDLFFBQVEsQ0FBQTtJQUNyQywyREFBMkQ7SUFDM0QsUUFBUSxDQUFDLGlCQUFpQixDQUFDLEVBQUUsUUFBUSxDQUFDLFFBQVEsQ0FBQTtJQUM5Qyx5RkFBeUY7SUFDekYsUUFBUSxDQUFDLGdCQUFnQixDQUFDLEVBQUUsUUFBUSxDQUFDLFFBQVEsQ0FBQTtJQUM3QyxzRkFBc0Y7SUFDdEYsUUFBUSxDQUFDLGlCQUFpQixDQUFDLEVBQUUsUUFBUSxDQUFDLFFBQVEsQ0FBQTtJQUM5QyxxRUFBcUU7SUFDckUsUUFBUSxDQUFDLFFBQVEsQ0FBQyxFQUFFLE1BQU0sQ0FBQTtDQUMzQjtBQW91QkQ7OztHQUdHO0FBQ0gsZUFBTyxNQUFNLFdBQVcsU0FDakIsMEJBQTBCLEtBQzlCLEtBQUssQ0FBQyxLQUFLLENBQUMsY0FBYyxFQUFFLEtBQUssRUFBRSxTQUFTLENBQUMsU0FBUyxDQUNJLENBQUEifQ==

package/dist/WorkflowEngineSqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkflowEngineSqlite.d.ts","sourceRoot":"","sources":["../src/WorkflowEngineSqlite.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAA;AAGzC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAM3C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAE/C,OAAO,EAA4B,cAAc,EAAoB,MAAM,yCAAyC,CAAA;AAKpH,MAAM,WAAW,0BAA0B;IACzC,wDAAwD;IACxD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAA;IACrC,2DAA2D;IAC3D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAA;IAC9C,yFAAyF;IACzF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAA;IAC7C,sFAAsF;IACtF,QAAQ,CAAC,iBAAiB,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAA;IAC9C,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAouBD;;;GAGG;AACH,eAAO,MAAM,WAAW,SACjB,0BAA0B,KAC9B,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,CACI,CAAA"}