@tenetkit/pg 0.28.0

package/dist/postgres/store-ops.js

@@ -0,0 +1,328 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { OperationResolutionConflict, RunNotFound, RunTerminal, RuntimeUnavailable, } from "tenetkit/runtime/driver/errors";
+import { OperationResolution, digest as resolutionDigest } from "tenetkit/runtime/driver/operation-resolution";
+import { isTerminal } from "tenetkit/runtime/driver/run";
+import { ExecutionCheckpoint } from "tenetkit/runtime/driver/execution-state";
+import { decodeJson, encodeExecutableRef, encodeJson, encodeJsonValue } from "tenetkit/runtime/driver/sql/codecs";
+import { canBlindRetry } from "tenetkit/runtime/driver/sql/operations";
+import { appendEvent, toOperationRecord } from "./pg-helpers.js";
+import { encodeContinuation } from "tenetkit/runtime/driver/steering";
+import { checkpointRef } from "tenetkit/runtime/driver/executable-manifest";
+import { getProgramOperation, resolveProgramOperation } from "tenetkit/runtime/driver/sql/store-program";
+import { settleAdmittedCancellation } from "tenetkit/runtime/driver/sql/store-control";
+import { postgresModelResponseOperations } from "./store-model-response.js";
+import { appendHandoffSessionEntry, verifyHandoffSessionEntry } from "./session-store.js";
+import { handoffSessionEntry, isHandoffCommit, sameHandoffCheckpoint, sameHandoffCommit, } from "tenetkit/runtime/driver/handoff-session";
+import { lockRunHierarchy } from "./locks.js";
+export const postgresOperations = (input) => {
+    const { sql, hub, run, runNoTxn, requireRun, requireClaim, nextId } = input;
+    const fenced = (claim, effect) => run(sql `SELECT run_id FROM baton_runs WHERE run_id = ${claim.runId} FOR UPDATE`.pipe(Effect.andThen(requireClaim(claim)), Effect.andThen(effect)));
+    return {
+        recordOperation: (op) => fenced(op, Effect.gen(function* () {
+            const loaded = yield* requireRun(op.runId);
+            if (isTerminal(loaded.status)) {
+                return yield* RunTerminal.make({ runId: loaded.runId, status: loaded.status });
+            }
+            const existing = yield* sql `
+            SELECT * FROM baton_run_operations
+            WHERE run_id = ${op.runId} AND operation_key = ${op.operationKey}
+          `;
+            const prior = existing[0];
+            if (prior !== undefined) {
+                const consumed = yield* sql `
+              SELECT entry_id FROM baton_run_steering
+              WHERE run_id = ${op.runId} AND consumed_operation_id = ${prior.operation_id}
+              ORDER BY sequence
+            `;
+                const retried = op.steeringEntryIds ?? [];
+                if (consumed.length !== retried.length ||
+                    consumed.some((entry, index) => entry.entry_id !== retried[index])) {
+                    return yield* RuntimeUnavailable.make({ message: "steering consumption does not match operation" });
+                }
+                return toOperationRecord(prior);
+            }
+            const steeringEntryIds = op.steeringEntryIds ?? [];
+            const pending = yield* sql `
+            SELECT entry_id FROM baton_run_steering
+            WHERE run_id = ${op.runId} AND consumed_operation_id IS NULL AND discarded_reason IS NULL
+            ORDER BY sequence
+          `;
+            const selected = pending.slice(0, steeringEntryIds.length);
+            if (selected.length !== steeringEntryIds.length ||
+                selected.some((entry, index) => entry.entry_id !== steeringEntryIds[index])) {
+                return yield* RuntimeUnavailable.make({ message: "steering entries are not the pending prefix" });
+            }
+            const operationId = yield* nextId("op");
+            const executableRef = yield* Effect.try({
+                try: () => checkpointRef(loaded.executableRef, loaded.executableManifest, op.checkpoint),
+                catch: (error) => RuntimeUnavailable.make({ message: String(error) }),
+            });
+            yield* sql `
+            INSERT INTO baton_run_operations (
+              run_id, operation_id, operation_key, kind, status, input_digest, input_json,
+              result_json, error_json, replay_policy, attempt, owner_worker_id, lease_expires_at, started_at, finished_at
+            ) VALUES (
+              ${op.runId}, ${operationId}, ${op.operationKey}, ${op.kind}, 'requested',
+              ${op.inputDigest}, ${encodeJsonValue(op.input)}, NULL, NULL, ${op.replayPolicy},
+              ${op.attempt}, NULL, NULL, NULL, NULL
+            )
+          `;
+            if (op.checkpoint !== undefined || op.continuation !== undefined) {
+                yield* sql `
+              UPDATE baton_runs SET
+                driver_checkpoint_json = COALESCE(${op.checkpoint === undefined ? null : encodeJson(ExecutionCheckpoint, op.checkpoint)}, driver_checkpoint_json),
+                executable_ref_json = ${encodeExecutableRef(executableRef)},
+                continuation_json = CASE WHEN ${op.continuation === undefined ? 0 : 1} = 1
+                  THEN ${op.continuation === null || op.continuation === undefined ? null : encodeContinuation(op.continuation)}
+                  ELSE continuation_json END
+              WHERE run_id = ${op.runId}
+            `;
+            }
+            for (const entryId of steeringEntryIds) {
+                yield* sql `
+              UPDATE baton_run_steering SET consumed_operation_id = ${operationId}
+              WHERE run_id = ${op.runId} AND entry_id = ${entryId}
+                AND consumed_operation_id IS NULL AND discarded_reason IS NULL
+            `;
+            }
+            if (steeringEntryIds.length > 0) {
+                yield* appendEvent(hub, yield* requireRun(op.runId), {
+                    _tag: "SteeringConsumed",
+                    entryIds: steeringEntryIds,
+                    operationId,
+                });
+            }
+            for (const event of op.steeringEvents ?? []) {
+                yield* appendEvent(hub, yield* requireRun(op.runId), event);
+            }
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${operationId}
+          `;
+            return toOperationRecord(rows[0]);
+        })),
+        startOperation: (op) => fenced(op, Effect.gen(function* () {
+            yield* requireRun(op.runId);
+            yield* sql `
+            UPDATE baton_run_operations
+            SET status = 'running', started_at = NOW()
+            WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status = 'requested'
+          `;
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+          `;
+            const row = rows[0];
+            if (row === undefined)
+                return yield* RuntimeUnavailable.make({ message: "operation missing" });
+            return toOperationRecord(row);
+        })),
+        completeOperation: (op) => fenced(op, Effect.gen(function* () {
+            const loaded = yield* requireRun(op.runId);
+            const existing = yield* sql `
+            SELECT * FROM baton_run_operations
+            WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+            FOR UPDATE
+          `;
+            const row = existing[0];
+            if (row === undefined)
+                return yield* RuntimeUnavailable.make({ message: "operation missing" });
+            const current = toOperationRecord(row);
+            if (row.status === "succeeded" || row.status === "failed" || row.status === "unknown") {
+                if (current.kind === "handoff" && current.status === "succeeded" && isHandoffCommit(current.result)) {
+                    if (op.outcome._tag !== "Succeeded" ||
+                        !sameHandoffCommit(current.result, op.outcome.value) ||
+                        !sameHandoffCheckpoint(loaded.driverCheckpoint, op.checkpoint)) {
+                        return yield* RuntimeUnavailable.make({ message: "handoff operation has a divergent completion retry" });
+                    }
+                    const entry = handoffSessionEntry({
+                        sessionId: loaded.message.sessionId,
+                        operationKey: current.operationKey,
+                        value: op.outcome.value,
+                    });
+                    if (Schema.is(RuntimeUnavailable)(entry))
+                        return yield* entry;
+                    yield* verifyHandoffSessionEntry(entry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
+                }
+                return current;
+            }
+            for (const entryId of new Set(op.steeringEntryIds ?? [])) {
+                const rows = yield* sql `
+              SELECT consumed_operation_id FROM baton_run_steering
+              WHERE run_id = ${op.runId} AND entry_id = ${entryId}
+            `;
+                if (rows[0]?.consumed_operation_id !== op.operationId) {
+                    return yield* RuntimeUnavailable.make({
+                        message: `steering entry ${entryId} does not belong to operation`,
+                    });
+                }
+            }
+            const executableRef = yield* Effect.try({
+                try: () => checkpointRef(loaded.executableRef, loaded.executableManifest, op.checkpoint),
+                catch: (error) => RuntimeUnavailable.make({ message: String(error) }),
+            });
+            if (row.kind === "handoff" && op.outcome._tag === "Succeeded" && isHandoffCommit(op.outcome.value)) {
+                const entry = handoffSessionEntry({
+                    sessionId: loaded.message.sessionId,
+                    operationKey: row.operation_key,
+                    value: op.outcome.value,
+                });
+                if (Schema.is(RuntimeUnavailable)(entry))
+                    return yield* entry;
+                yield* appendHandoffSessionEntry(entry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
+            }
+            if (op.outcome._tag === "Succeeded") {
+                yield* sql `
+              UPDATE baton_run_operations
+              SET status = 'succeeded', result_json = ${encodeJsonValue(op.outcome.value)}, finished_at = NOW()
+              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+                AND status IN ('requested', 'running')
+            `;
+            }
+            else if (op.outcome._tag === "Failed") {
+                yield* sql `
+              UPDATE baton_run_operations
+              SET status = 'failed', error_json = ${encodeJsonValue(op.outcome.error)}, finished_at = NOW()
+              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+                AND status IN ('requested', 'running')
+            `;
+            }
+            else {
+                yield* sql `
+              UPDATE baton_run_operations SET status = 'unknown', finished_at = NOW()
+              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+                AND status IN ('requested', 'running')
+            `;
+            }
+            yield* sql `
+            UPDATE baton_runs SET
+              driver_checkpoint_json = COALESCE(${op.checkpoint === undefined ? null : encodeJson(ExecutionCheckpoint, op.checkpoint)}, driver_checkpoint_json),
+              executable_ref_json = ${encodeExecutableRef(executableRef)},
+              continuation_json = CASE WHEN ${op.continuation === undefined ? 0 : 1} = 1
+                THEN ${op.continuation === null || op.continuation === undefined ? null : encodeContinuation(op.continuation)}
+                ELSE continuation_json END,
+              updated_at = NOW()
+            WHERE run_id = ${op.runId}
+          `;
+            if (op.outcome._tag === "Unknown") {
+                yield* appendEvent(hub, yield* requireRun(op.runId), { _tag: "OperationUnknown", operationId: op.operationId }, loaded.cancellationRequested ? "cancelling" : "needs-resolution");
+            }
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+          `;
+            return toOperationRecord(rows[0]);
+        })),
+        ...postgresModelResponseOperations(input),
+        expireRunningOperation: (op) => fenced(op, Effect.gen(function* () {
+            const loaded = yield* requireRun(op.runId);
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+          `;
+            const row = rows[0];
+            if (row === undefined)
+                return yield* RuntimeUnavailable.make({ message: "operation missing" });
+            if (row.status !== "running") {
+                return { record: toOperationRecord(row), outcome: row.status };
+            }
+            if (canBlindRetry(row.replay_policy)) {
+                yield* sql `
+              UPDATE baton_run_operations
+              SET status = 'requested', started_at = NULL, finished_at = NULL, owner_worker_id = NULL, lease_expires_at = NULL
+              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status = 'running'
+            `;
+                const next = yield* sql `
+              SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+            `;
+                return { record: toOperationRecord(next[0]), outcome: "retried" };
+            }
+            yield* sql `
+            UPDATE baton_run_operations SET status = 'unknown', finished_at = NOW()
+            WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status = 'running'
+          `;
+            yield* appendEvent(hub, loaded, { _tag: "OperationUnknown", operationId: op.operationId }, loaded.cancellationRequested ? "cancelling" : "needs-resolution");
+            const next = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+          `;
+            return { record: toOperationRecord(next[0]), outcome: "unknown" };
+        })),
+        getOperation: (op) => runNoTxn(Effect.gen(function* () {
+            yield* requireRun(op.runId);
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+          `;
+            const row = rows[0];
+            if (row === undefined)
+                return yield* RuntimeUnavailable.make({ message: "operation missing" });
+            return toOperationRecord(row);
+        })),
+        getOperationByKey: (op) => runNoTxn(Effect.gen(function* () {
+            yield* requireRun(op.runId);
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_key = ${op.operationKey}
+          `;
+            return rows[0] === undefined ? undefined : toOperationRecord(rows[0]);
+        })),
+        resolveOperation: (op) => run(Effect.gen(function* () {
+            yield* lockRunHierarchy(op.runId);
+            const loaded = yield* requireRun(op.runId);
+            const program = yield* getProgramOperation({ runId: op.runId, operation: op.operationId });
+            if (program !== undefined) {
+                yield* resolveProgramOperation(op, "queued", true);
+                yield* settleAdmittedCancellation(hub, op.runId);
+                return;
+            }
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations
+            WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+            FOR UPDATE
+          `;
+            const row = rows[0];
+            const resolutionJson = encodeJsonValue(op.resolution);
+            const conflict = () => OperationResolutionConflict.make({
+                runId: op.runId,
+                operationId: op.operationId,
+                idempotencyKey: op.idempotencyKey,
+            });
+            if (row === undefined)
+                return yield* conflict();
+            if (row.resolution_idempotency_key !== null) {
+                const priorResolution = row.resolution_json === null ? undefined : decodeJson(OperationResolution, row.resolution_json);
+                if (row.resolution_idempotency_key === op.idempotencyKey &&
+                    priorResolution !== undefined &&
+                    resolutionDigest(priorResolution) === resolutionDigest(op.resolution))
+                    return;
+                return yield* conflict();
+            }
+            if (loaded.status !== "needs-resolution" || row.status !== "unknown")
+                return yield* conflict();
+            if (op.resolution._tag === "Succeeded") {
+                yield* sql `
+              UPDATE baton_run_operations SET status = 'succeeded', result_json = ${encodeJsonValue(op.resolution.value)},
+                resolution_idempotency_key = ${op.idempotencyKey}, resolution_json = ${resolutionJson},
+                owner_worker_id = NULL, lease_expires_at = NULL, finished_at = NOW()
+              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status = 'unknown'
+            `;
+            }
+            else if (op.resolution._tag === "Failed") {
+                yield* sql `
+              UPDATE baton_run_operations SET status = 'failed', error_json = ${encodeJsonValue(op.resolution.error)},
+                resolution_idempotency_key = ${op.idempotencyKey}, resolution_json = ${resolutionJson},
+                owner_worker_id = NULL, lease_expires_at = NULL, finished_at = NOW()
+              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status = 'unknown'
+            `;
+            }
+            else {
+                yield* sql `
+              UPDATE baton_run_operations SET status = 'requested', result_json = NULL, error_json = NULL,
+                resolution_idempotency_key = ${op.idempotencyKey}, resolution_json = ${resolutionJson},
+                owner_worker_id = NULL, lease_expires_at = NULL, started_at = NULL, finished_at = NULL
+              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status = 'unknown'
+            `;
+            }
+            yield* sql `
+            UPDATE baton_runs SET status = CASE WHEN cancellation_requested THEN 'cancelling' ELSE 'queued' END, owner_worker_id = NULL, lease_expires_at = NULL, updated_at = NOW()
+            WHERE run_id = ${op.runId} AND status = 'needs-resolution'
+          `;
+            yield* settleAdmittedCancellation(hub, op.runId);
+        })),
+    };
+};

package/dist/postgres/store-program.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import type { PgClient } from "@effect/sql-pg";
+import { SqlClient } from "effect/unstable/sql";
+import { RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import type { Interface as RunStore } from "tenetkit/runtime/driver/run-store";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+type SqlR = SqlClient.SqlClient | PgClient.PgClient;
+export type Run = <A, E>(effect: Effect.Effect<A, E | SqlError, SqlR>) => Effect.Effect<A, WithoutSqlError<E | SqlError> | RuntimeUnavailable>;
+export declare const programStoreMethods: (input: {
+    readonly sql: SqlClient.SqlClient;
+    readonly hub: EventHub;
+    readonly run: Run;
+    readonly runNoTxn: Run;
+    readonly lockRunHierarchy: (runId: string) => Effect.Effect<void, SqlError, SqlClient.SqlClient>;
+}) => Pick<RunStore, "reserveProgramOperation" | "admitProgramChild" | "admitProgramChildAndSuspend" | "admitProgramAgents" | "settleProgramOperation" | "suspendProgramOperation" | "startProgramOperation" | "loadProgramState" | "completeProgram" | "getProgramOperation" | "commitProgramLog">;
+export {};

package/dist/postgres/store-program.js

@@ -0,0 +1,36 @@
+import { Effect } from "effect";
+import { ProgramCapabilities } from "tenetkit";
+import { SqlClient } from "effect/unstable/sql";
+import { RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import { requireExecutionClaim } from "tenetkit/runtime/driver/sql/store-execution";
+import { loadProgramState, getProgramOperation, reserveProgramOperation, admitProgramAgents, commitProgramLog, settleProgramOperation, suspendProgramOperation, startProgramOperation, } from "tenetkit/runtime/driver/sql/store-program";
+import { completeRun, requireRun } from "./pg-helpers.js";
+import { suspend } from "./store-suspend.js";
+import { admitProgramChild } from "tenetkit/runtime/driver/sql/store-admit";
+export const programStoreMethods = (input) => {
+    const fenced = (claim, effect) => input.run(input.sql `SELECT run_id FROM baton_runs WHERE run_id = ${claim.runId} FOR UPDATE`.pipe(Effect.andThen(requireExecutionClaim(claim)), Effect.andThen(effect)));
+    return {
+        admitProgramChild: (operation) => fenced(operation, admitProgramChild(input.hub, operation)),
+        admitProgramChildAndSuspend: (operation) => fenced(operation, admitProgramChild(input.hub, operation).pipe(Effect.tap(() => suspend(input.hub, operation)))),
+        reserveProgramOperation: (operation) => fenced(operation, reserveProgramOperation(operation)),
+        admitProgramAgents: (operation) => fenced(operation, admitProgramAgents(input.hub, operation, suspend)),
+        suspendProgramOperation: (operation) => fenced(operation, suspendProgramOperation(input.hub, operation, suspend)),
+        settleProgramOperation: (operation) => fenced(operation, settleProgramOperation(input.hub, operation)),
+        startProgramOperation: (operation) => fenced(operation, startProgramOperation(operation)),
+        loadProgramState: (runId) => input.runNoTxn(requireRun(runId).pipe(Effect.andThen(loadProgramState(runId)))),
+        getProgramOperation: (operation) => input.runNoTxn(requireRun(operation.runId).pipe(Effect.andThen(getProgramOperation(operation)))),
+        commitProgramLog: (operation) => fenced(operation, commitProgramLog(input.hub, operation)),
+        completeProgram: (operation) => input.run(Effect.gen(function* () {
+            yield* input.lockRunHierarchy(operation.runId);
+            yield* requireExecutionClaim(operation);
+            if (operation.outputBytes > operation.outputLimit)
+                return yield* ProgramCapabilities.ProgramBudgetExhausted.make({
+                    dimension: "outputBytes",
+                    limit: operation.outputLimit,
+                });
+            const loaded = yield* requireRun(operation.runId);
+            yield* completeRun(input.hub, loaded, { _tag: "Program", value: operation.output });
+            return { _tag: "Completed" };
+        })),
+    };
+};

package/dist/postgres/store-suspend.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+type SuspendEffect = Effect.Effect<undefined, RunNotFound | RunTerminal | RuntimeUnavailable | SqlError | StaleClaim, SqlClient.SqlClient>;
+export declare const suspend: {
+    (input: Parameters<RunStoreInterface["suspend"]>[0]): (hub: EventHub) => SuspendEffect;
+    (hub: EventHub, input: Parameters<RunStoreInterface["suspend"]>[0]): SuspendEffect;
+};
+export {};

package/dist/postgres/store-suspend.js

@@ -0,0 +1,87 @@
+import { Effect, Function, Option } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
+import { checkpointRef } from "tenetkit/runtime/driver/executable-manifest";
+import { isTerminal } from "tenetkit/runtime/driver/run";
+import { encodeContinuation } from "tenetkit/runtime/driver/steering";
+import { encodeExecutableRef, encodeJson } from "tenetkit/runtime/driver/sql/codecs";
+import { encodeReason, WaitResolution } from "tenetkit/runtime/driver/run-wait";
+import { lockRun } from "./locks.js";
+import { appendEvent, requireRun } from "./pg-helpers.js";
+import { requireExecutionClaim } from "tenetkit/runtime/driver/sql/store-execution";
+import { groupIdFromSuspension, resultFromInspection } from "tenetkit/runtime/driver/child-group";
+import { inspectFanOut } from "tenetkit/runtime/driver/sql/store-fan-out";
+import { ExecutionCheckpoint, ExecutionSuspension } from "tenetkit/runtime/driver/execution-state";
+import { loadTerminalEvent, reconcileChildWaitWith } from "tenetkit/runtime/driver/sql/store-child-settlement";
+export const suspend = Function.dual(2, (hub, input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* lockRun(input.runId);
+    yield* requireExecutionClaim(input);
+    const loaded = yield* requireRun(input.runId);
+    if (isTerminal(loaded.status)) {
+        return yield* RunTerminal.make({ runId: loaded.runId, status: loaded.status });
+    }
+    if (loaded.cancellationRequested)
+        return;
+    const executableRef = yield* Effect.try({
+        try: () => checkpointRef(loaded.executableRef, loaded.executableManifest, input.checkpoint),
+        catch: (error) => RuntimeUnavailable.make({ message: String(error) }),
+    });
+    yield* sql `
+      UPDATE baton_runs SET
+        driver_checkpoint_json = COALESCE(${input.checkpoint === undefined ? null : encodeJson(ExecutionCheckpoint, input.checkpoint)}, driver_checkpoint_json),
+        executable_ref_json = ${encodeExecutableRef(executableRef)},
+        suspension_json = ${encodeJson(ExecutionSuspension, input.suspension)},
+        continuation_json = CASE WHEN ${input.continuation === undefined ? 0 : 1} = 1
+          THEN ${input.continuation === null || input.continuation === undefined ? null : encodeContinuation(input.continuation)}
+          ELSE continuation_json END,
+        updated_at = NOW()
+      WHERE run_id = ${input.runId}
+    `;
+    yield* sql `
+      INSERT INTO baton_run_waits (
+        run_id, wait_id, reason, status, response_json, due_at, owner_worker_id, lease_expires_at, opened_at, closed_at
+      ) VALUES (
+        ${loaded.runId}, ${input.wait.waitId}, ${encodeReason(input.wait.reason)}, 'open', NULL, NULL, NULL, NULL, NOW(), NULL
+      )
+      ON CONFLICT (run_id, wait_id) DO UPDATE SET
+        status = 'open', reason = EXCLUDED.reason, response_json = NULL, opened_at = EXCLUDED.opened_at, closed_at = NULL
+    `;
+    yield* appendEvent(hub, loaded, { _tag: "RunWaiting", wait: input.wait }, "waiting");
+    const child = typeof input.suspension.token === "string"
+        ? yield* requireRun(input.suspension.token).pipe(Effect.option)
+        : Option.none();
+    if (child._tag === "Some" && child.value.terminalEventId !== undefined) {
+        const terminalEvent = yield* loadTerminalEvent(child.value.terminalEventId);
+        if (terminalEvent !== undefined) {
+            yield* reconcileChildWaitWith({
+                hub,
+                parent: yield* requireRun(loaded.runId),
+                child: child.value,
+                event: terminalEvent,
+                append: appendEvent,
+            });
+        }
+    }
+    const groupId = groupIdFromSuspension(input.suspension);
+    if (groupId !== undefined) {
+        const rows = yield* sql `
+        SELECT parent_run_id, status FROM baton_fan_outs WHERE fan_out_id = ${groupId}
+      `;
+        const group = rows[0];
+        if (group?.parent_run_id === loaded.runId && group.status !== "running") {
+            const resolution = {
+                _tag: "Signal",
+                name: input.wait.waitId,
+                payload: resultFromInspection(yield* inspectFanOut(groupId).pipe(Effect.mapError(() => RuntimeUnavailable.make({ message: `child group ${groupId} disappeared` })))),
+            };
+            yield* sql `
+          UPDATE baton_run_waits SET status = 'signaled', response_json = ${encodeJson(WaitResolution, resolution)}, closed_at = NOW()
+          WHERE run_id = ${loaded.runId} AND wait_id = ${input.wait.waitId} AND status = 'open'
+        `;
+            yield* appendEvent(hub, yield* requireRun(loaded.runId), { _tag: "RunResumed", waitId: input.wait.waitId, resolution }, "running");
+        }
+    }
+    yield* sql `UPDATE baton_runs SET owner_worker_id = NULL, lease_expires_at = NULL WHERE run_id = ${loaded.runId}`;
+}));

package/dist/postgres/store.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import type { PostgresStoreOptions } from "./runtime-layer.js";
+export declare const makePostgresServices: (options: PostgresStoreOptions) => Effect.Effect<{
+    store: import("tenetkit/runtime/driver/run-store").Interface;
+    claims: import("tenetkit/runtime/driver/sql/run-claims").Interface;
+}, import("tenetkit/runtime/driver/sql/errors").SchemaChecksumMismatch | import("tenetkit/runtime/driver/sql/errors").SchemaDirty | import("tenetkit/runtime/driver/sql/errors").SchemaMigrationFailed | import("tenetkit/runtime/driver/sql/errors").SchemaUpgradeRequired | import("tenetkit/runtime/driver/sql/errors").SchemaVersionUnsupported | import("effect/unstable/sql/SqlError").SqlError, import("effect/Scope").Scope | SqlClient.SqlClient>;