@tenetkit/pg 0.28.0

package/dist/postgres/pg-helpers.js

@@ -0,0 +1,359 @@
+import { Effect, Function } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { PgClient } from "@effect/sql-pg";
+import { eventIdFor } from "tenetkit/runtime/driver/run-event";
+import { isTerminal } from "tenetkit/runtime/driver/run";
+import { StringArray, decodeMessage, decodeQueue, encodeExecutableManifest, encodeExecutableRef, encodeEvent, encodeJson, encodeMessage, encodeQueue, } from "tenetkit/runtime/driver/sql/codecs";
+import { reconcileFanOutWith } from "tenetkit/runtime/driver/sql/store-fan-out";
+import { decodePersistedEvents, decodeRunEffect, nowIso } from "tenetkit/runtime/driver/sql/store-helpers";
+import { NOTIFY_CHANNEL } from "./schema.js";
+import { PendingRunOutcome } from "tenetkit/runtime/driver/run-store";
+import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
+import { admitChildSettlementFromEventId } from "tenetkit/runtime/driver/sql/settlement-notifications";
+import { discardPendingSteering } from "tenetkit/runtime/driver/sql/store-steering-disposition";
+import { hasUnsettledChild, loadTerminalEvent, reconcileChildWaitWith, } from "tenetkit/runtime/driver/sql/store-child-settlement";
+import { appendTerminalToolResultsForEvent } from "tenetkit/runtime/driver/sql/session-terminalization";
+export const loadRun = (runId) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const rows = yield* sql `SELECT * FROM baton_runs WHERE run_id = ${runId}`;
+    const row = rows[0];
+    return row === undefined ? undefined : yield* decodeRunEffect(row);
+});
+export const requireRun = (runId) => loadRun(runId).pipe(Effect.flatMap((loaded) => loaded === undefined ? Effect.fail(RunNotFound.make({ runId })) : Effect.succeed(loaded)));
+export const emitAgentEvent = Function.dual(2, (hub, input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `SELECT run_id FROM baton_runs WHERE run_id = ${input.runId} FOR UPDATE`;
+    const loaded = yield* loadRun(input.runId);
+    if (loaded === undefined)
+        return yield* RunNotFound.make({ runId: input.runId });
+    if (loaded.ownerWorkerId !== input.ownerId || loaded.attemptFence !== input.attemptFence) {
+        return yield* StaleClaim.make({
+            runId: input.runId,
+            workerId: input.ownerId,
+            attemptFence: input.attemptFence,
+        });
+    }
+    if (isTerminal(loaded.status))
+        return yield* RunTerminal.make({ runId: loaded.runId, status: loaded.status });
+    yield* appendEvent(hub, loaded, input.event);
+    if (input.event._tag === "TurnCompleted") {
+        yield* sql `UPDATE baton_runs SET continuation_json = NULL WHERE run_id = ${loaded.runId}`;
+    }
+}));
+export const loadEventsAfter = Function.dual(2, (runId, cursor) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const run = yield* loadRun(runId);
+    if (run === undefined)
+        return [];
+    const rows = yield* sql `
+      SELECT * FROM baton_run_events
+      WHERE run_id = ${runId} AND sequence > ${cursor}
+      ORDER BY sequence ASC
+    `;
+    return yield* decodePersistedEvents(rows, run.executableManifest);
+}));
+export const allocateSequence = (runId) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const rows = yield* sql `
+      UPDATE baton_runs
+      SET last_sequence = last_sequence + 1, updated_at = NOW()
+      WHERE run_id = ${runId}
+      RETURNING last_sequence
+    `;
+    return Number(rows[0].last_sequence);
+});
+export const appendEvent = Function.dual((args) => args.length >= 4 || (args.length === 3 && !("runId" in args[0])), (_hub, run, partial, nextStatus) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const pg = yield* PgClient.PgClient;
+    const discarded = yield* discardPendingSteering({ runId: run.runId, terminalTag: partial._tag });
+    if (discarded !== undefined) {
+        yield* appendEvent(_hub, run, discarded);
+        return yield* appendEvent(_hub, (yield* loadRun(run.runId)), partial, nextStatus);
+    }
+    yield* appendTerminalToolResultsForEvent({ run, event: partial });
+    const sequence = yield* allocateSequence(run.runId);
+    const occurredAt = yield* nowIso;
+    const event = {
+        specVersion: "1",
+        eventId: eventIdFor(run.runId, sequence),
+        runId: run.runId,
+        sequence,
+        executableRef: run.executableRef,
+        rootRunId: run.rootRunId,
+        depth: run.depth,
+        occurredAt,
+        ...(run.parentRunId === undefined ? {} : { parentRunId: run.parentRunId }),
+        ...(run.message.causationId === undefined ? {} : { causationId: run.message.causationId }),
+        ...(run.message.correlationId === undefined ? {} : { correlationId: run.message.correlationId }),
+        ...(run.attempt > 0 ? { attemptId: `${run.runId}:attempt:${run.attempt}` } : {}),
+        ...partial,
+    };
+    yield* sql `
+      INSERT INTO baton_run_events (run_id, sequence, event_id, event_json)
+      VALUES (${run.runId}, ${sequence}, ${event.eventId}, ${encodeEvent(event)})
+    `;
+    const treeRoot = (yield* sql `
+      UPDATE baton_tree_roots SET last_position = last_position + 1
+      WHERE root_run_id = ${run.rootRunId} RETURNING last_position
+    `)[0];
+    yield* sql `
+      INSERT INTO baton_tree_event_index (root_run_id, position, run_id, run_sequence, event_id)
+      VALUES (${run.rootRunId}, ${Number(treeRoot.last_position)}, ${run.runId}, ${sequence}, ${event.eventId})
+    `;
+    const status = nextStatus ?? run.status;
+    const activeWaitId = event._tag === "RunWaiting"
+        ? event.wait.waitId
+        : event._tag === "RunResumed"
+            ? null
+            : (run.activeWaitId ?? null);
+    const terminalEventId = event._tag === "RunCompleted" || event._tag === "RunFailed" || event._tag === "RunCancelled"
+        ? event.eventId
+        : (run.terminalEventId ?? null);
+    const cancellationRequested = event._tag === "RunCancellationRequested" || run.cancellationRequested;
+    const cancelReason = event._tag === "RunCancellationRequested" && "reason" in event && typeof event.reason === "string"
+        ? event.reason
+        : (run.cancelReason ?? null);
+    const attempt = event._tag === "RunAttemptStarted" ? event.attempt : run.attempt;
+    const terminalPartial = event._tag === "RunCompleted" || event._tag === "RunFailed" || event._tag === "RunCancelled";
+    if (terminalPartial) {
+        yield* sql `
+        UPDATE baton_runs SET
+          status = ${status},
+          active_wait_id = ${activeWaitId},
+          terminal_event_id = ${terminalEventId},
+          cancellation_requested = ${cancellationRequested},
+          cancel_reason = ${cancelReason},
+          attempt = ${attempt},
+           owner_worker_id = NULL,
+           lease_expires_at = NULL,
+           continuation_json = NULL,
+           pending_outcome_json = NULL,
+           suspension_json = NULL,
+          updated_at = NOW()
+        WHERE run_id = ${run.runId}
+          AND status NOT IN ('succeeded', 'failed', 'cancelled')
+      `;
+    }
+    else {
+        yield* sql `
+        UPDATE baton_runs SET
+          status = ${status},
+          active_wait_id = ${activeWaitId},
+          terminal_event_id = ${terminalEventId},
+          cancellation_requested = ${cancellationRequested},
+          cancel_reason = ${cancelReason},
+          attempt = ${attempt},
+          updated_at = NOW()
+        WHERE run_id = ${run.runId}
+      `;
+    }
+    yield* pg.notify(NOTIFY_CHANNEL, run.runId);
+    return event;
+}));
+export const promoteHead = Function.dual(3, (hub, address, sessionId) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const lanes = yield* sql `
+      SELECT head_run_id, queue_json FROM baton_lanes
+      WHERE address = ${address} AND session_id = ${sessionId}
+      FOR UPDATE
+    `;
+    const lane = lanes[0];
+    if (lane === undefined)
+        return;
+    const queue = decodeQueue(lane.queue_json);
+    const headId = lane.head_run_id ?? queue[0];
+    if (headId === undefined)
+        return;
+    if (lane.head_run_id !== headId) {
+        yield* sql `
+        UPDATE baton_lanes SET head_run_id = ${headId}
+        WHERE address = ${address} AND session_id = ${sessionId}
+      `;
+    }
+    const head = yield* loadRun(headId);
+    if (head === undefined || head.status !== "queued" || head.cancellationRequested)
+        return;
+}));
+export const removeFromLane = Function.dual(3, (address, sessionId, runId) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const lanes = yield* sql `
+      SELECT queue_json FROM baton_lanes
+      WHERE address = ${address} AND session_id = ${sessionId}
+      FOR UPDATE
+    `;
+    const lane = lanes[0];
+    if (lane === undefined)
+        return;
+    const queue = decodeQueue(lane.queue_json).filter((id) => id !== runId);
+    if (queue.length === 0) {
+        yield* sql `DELETE FROM baton_lanes WHERE address = ${address} AND session_id = ${sessionId}`;
+    }
+    else {
+        yield* sql `
+        UPDATE baton_lanes
+        SET queue_json = ${encodeQueue(queue)}, head_run_id = ${queue[0]}
+        WHERE address = ${address} AND session_id = ${sessionId}
+      `;
+    }
+}));
+export const afterTerminal = Function.dual(2, (hub, run) => Effect.gen(function* () {
+    yield* removeFromLane(run.address, run.sessionId, run.runId);
+    yield* promoteHead(hub, run.address, run.sessionId);
+}));
+export const completeRun = Function.dual(3, (hub, run, result) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    if (isTerminal(run.status))
+        return yield* RunTerminal.make({ runId: run.runId, status: run.status });
+    if (run.cancellationRequested) {
+        const runningFanOut = yield* sql `
+        SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${run.runId} AND status = 'running' LIMIT 1
+      `;
+        if (runningFanOut.length > 0 || (yield* hasUnsettledChild(run.runId))) {
+            yield* sql `
+          UPDATE baton_runs SET owner_worker_id = NULL, lease_expires_at = NULL WHERE run_id = ${run.runId}
+        `;
+            return;
+        }
+        const event = yield* appendEvent(hub, run, { _tag: "RunCancelled", ...(run.cancelReason === undefined ? {} : { reason: run.cancelReason }) }, "cancelled");
+        const settled = (yield* loadRun(run.runId));
+        yield* settleParent(hub, settled, event.eventId);
+        yield* afterTerminal(hub, settled);
+        return;
+    }
+    const runningFanOut = yield* sql `
+      SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${run.runId} AND status = 'running' LIMIT 1
+    `;
+    if (runningFanOut.length > 0) {
+        yield* sql `
+        UPDATE baton_runs SET status = 'waiting', owner_worker_id = NULL, lease_expires_at = NULL,
+          suspension_json = NULL,
+          pending_outcome_json = ${encodeJson(PendingRunOutcome, { _tag: "Completed", result })}
+        WHERE run_id = ${run.runId}
+      `;
+        return;
+    }
+    const event = yield* appendEvent(hub, run, { _tag: "RunCompleted", result }, "succeeded");
+    const settled = (yield* loadRun(run.runId));
+    yield* settleParent(hub, settled, event.eventId);
+    yield* afterTerminal(hub, settled);
+}));
+export const settleParent = Function.dual(3, (hub, child, terminalEventId) => Effect.gen(function* () {
+    if (child.parentRunId === undefined)
+        return;
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `SELECT run_id FROM baton_runs WHERE run_id = ${child.parentRunId} FOR UPDATE`;
+    const parent = yield* loadRun(child.parentRunId);
+    if (parent === undefined)
+        return;
+    const existing = yield* sql `
+      SELECT child_run_id FROM baton_run_links
+      WHERE parent_run_id = ${parent.runId} AND child_run_id = ${child.runId} AND terminal_event_id IS NOT NULL
+    `;
+    if (existing.length > 0)
+        return;
+    yield* sql `
+      UPDATE baton_run_links
+      SET readiness = 'settled', terminal_event_id = ${terminalEventId}, settled_at = NOW()
+      WHERE parent_run_id = ${parent.runId} AND child_run_id = ${child.runId}
+    `;
+    yield* admitChildSettlementFromEventId({ parent, child, terminalEventId });
+    if (!isTerminal(parent.status)) {
+        yield* appendEvent(hub, parent, {
+            _tag: "ChildReadinessChanged",
+            childRunId: child.runId,
+            readiness: "settled",
+        });
+        yield* appendEvent(hub, (yield* loadRun(parent.runId)), {
+            _tag: "ChildSettled",
+            childRunId: child.runId,
+            terminalEventId,
+        });
+    }
+    yield* reconcileFanOutWith(hub, child.runId, terminalEventId, appendEvent, settleParent, afterTerminal);
+    let currentParent = yield* loadRun(parent.runId);
+    const terminalEvent = yield* loadTerminalEvent(terminalEventId);
+    if (currentParent !== undefined && terminalEvent !== undefined) {
+        yield* reconcileChildWaitWith({ hub, parent: currentParent, child, event: terminalEvent, append: appendEvent });
+        currentParent = yield* loadRun(parent.runId);
+    }
+    if (currentParent?.status === "queued") {
+        const unsettled = yield* sql `
+        SELECT l.child_run_id FROM baton_run_links l
+        JOIN baton_runs r ON r.run_id = l.child_run_id
+        WHERE l.parent_run_id = ${parent.runId}
+          AND r.status NOT IN ('succeeded', 'failed', 'cancelled')
+        LIMIT 1
+      `;
+        if (unsettled.length === 0) {
+            const attempt = currentParent.attempt + 1;
+            yield* sql `UPDATE baton_runs SET attempt_fence = ${attempt} WHERE run_id = ${parent.runId}`;
+            yield* appendEvent(hub, { ...currentParent, attempt }, { _tag: "RunAttemptStarted", attempt }, "running");
+        }
+        return;
+    }
+    if (currentParent?.status !== "cancelling" || currentParent.ownerWorkerId !== undefined)
+        return;
+    const running = yield* sql `
+      SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${parent.runId} AND status = 'running' LIMIT 1
+    `;
+    if (running.length > 0)
+        return;
+    if (yield* hasUnsettledChild(parent.runId))
+        return;
+    const cancelled = yield* appendEvent(hub, currentParent, {
+        _tag: "RunCancelled",
+        ...(currentParent.cancelReason === undefined ? {} : { reason: currentParent.cancelReason }),
+    }, "cancelled");
+    const settledParent = (yield* loadRun(parent.runId));
+    yield* settleParent(hub, settledParent, cancelled.eventId);
+    yield* afterTerminal(hub, settledParent);
+}));
+export const insertRun = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `
+      INSERT INTO baton_runs (
+        run_id, status, address, session_id, message_id, message_json, message_digest, idempotency_key,
+        executable_ref_json, executable_manifest_json, root_run_id, depth, max_depth, max_subagents, parent_run_id, invocation_id, active_wait_id, attempt, attempt_fence,
+        last_sequence, cancellation_requested, cancel_reason, terminal_event_id, accepted_sequence,
+        responded_wait_ids_json, owner_worker_id, lease_expires_at, created_at, updated_at
+      ) VALUES (
+        ${input.runId}, ${input.status}, ${input.message.to}, ${input.message.sessionId}, ${input.message.id},
+        ${encodeMessage(input.message)}, ${input.digest}, ${input.message.idempotencyKey},
+        ${encodeExecutableRef(input.executableRef)}, ${encodeExecutableManifest(input.executableManifest)},
+        ${input.rootRunId}, ${input.depth}, ${input.treePolicy.maxDepth}, ${input.treePolicy.maxSubagents}, ${input.parentRunId ?? null}, ${input.invocationId ?? null},
+        NULL, ${input.attempt ?? 0}, ${input.attempt ?? 0}, -1, FALSE, NULL, NULL, ${input.acceptedSequence},
+        ${encodeJson(StringArray, [])}, NULL, NULL, NOW(), NOW()
+      )
+    `;
+    if (input.runId === input.rootRunId) {
+        yield* sql `INSERT INTO baton_tree_roots (root_run_id) VALUES (${input.runId})`;
+    }
+});
+export const enqueueLane = Function.dual(3, (address, sessionId, runId) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const lanes = yield* sql `
+      SELECT accepted_sequence, queue_json, head_run_id FROM baton_lanes
+      WHERE address = ${address} AND session_id = ${sessionId}
+      FOR UPDATE
+    `;
+    const lane = lanes[0];
+    if (lane === undefined) {
+        yield* sql `
+        INSERT INTO baton_lanes (address, session_id, accepted_sequence, queue_json, head_run_id)
+        VALUES (${address}, ${sessionId}, 0, ${encodeQueue([runId])}, ${runId})
+      `;
+        return { acceptedSequence: 0, isHead: true };
+    }
+    const acceptedSequence = Number(lane.accepted_sequence) + 1;
+    const queue = [...decodeQueue(lane.queue_json), runId];
+    const head = lane.head_run_id ?? queue[0];
+    yield* sql `
+      UPDATE baton_lanes
+      SET accepted_sequence = ${acceptedSequence}, queue_json = ${encodeQueue(queue)}, head_run_id = ${head}
+      WHERE address = ${address} AND session_id = ${sessionId}
+    `;
+    return { acceptedSequence, isHead: head === runId };
+}));
+export { toOperationRecord } from "tenetkit/runtime/driver/sql/operations";
+export { decodeMessage, encodeQueue, decodeQueue };

package/dist/postgres/run-schema.d.ts

@@ -0,0 +1,23 @@
+import { Effect, Layer } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import { PgClient } from "@effect/sql-pg";
+import { SchemaChecksumMismatch, SchemaDirty, SchemaMigrationFailed, SchemaUpgradeRequired, SchemaVersionUnsupported } from "tenetkit/runtime/driver/sql/errors";
+export interface SchemaPlan {
+    readonly current: number;
+    readonly required: number;
+    readonly checksum: string;
+    readonly statements: ReadonlyArray<string>;
+    readonly upgradeRequired: boolean;
+}
+export declare const plan: (source: string) => Effect.Effect<SchemaPlan, SchemaMigrationFailed, SqlClient.SqlClient>;
+export declare const check: (source: string) => Effect.Effect<undefined, SchemaChecksumMismatch | SchemaDirty | SchemaMigrationFailed | SchemaUpgradeRequired | SchemaVersionUnsupported, SqlClient.SqlClient>;
+export declare const apply: (source: string) => Effect.Effect<undefined, SchemaChecksumMismatch | SchemaDirty | SchemaMigrationFailed | SchemaUpgradeRequired | SchemaVersionUnsupported | SqlError, SqlClient.SqlClient>;
+export declare const markDirty: (source: string) => Effect.Effect<void, SchemaMigrationFailed, SqlClient.SqlClient>;
+export declare const RunSchema: {
+    readonly plan: typeof plan;
+    readonly check: typeof check;
+    readonly apply: typeof apply;
+    readonly markDirty: typeof markDirty;
+};
+export declare const layerClient: (url: string) => Layer.Layer<SqlClient.SqlClient | PgClient.PgClient, SqlError>;

package/dist/postgres/run-schema.js

@@ -0,0 +1,92 @@
+import { DateTime, Effect, Layer, Redacted } from "effect";
+import { Migrator, SqlClient } from "effect/unstable/sql";
+import { PgClient } from "@effect/sql-pg";
+import { SchemaChecksumMismatch, SchemaDirty, SchemaMigrationFailed, SchemaUpgradeRequired, SchemaVersionUnsupported, } from "tenetkit/runtime/driver/sql/errors";
+import { mapSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
+import { MIGRATIONS_TABLE, SCHEMA_META_TABLE, SCHEMA_STATEMENTS, SCHEMA_VERSION, schemaChecksum } from "./schema.js";
+const readMeta = (source) => mapSqlError(Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const exists = yield* sql `
+        SELECT EXISTS (
+          SELECT 1 FROM information_schema.tables
+          WHERE table_schema = current_schema() AND table_name = ${SCHEMA_META_TABLE}
+        ) AS exists
+      `;
+    if (exists[0]?.exists !== true)
+        return { version: 0, checksum: "", dirty: false, present: false };
+    const rows = yield* sql `
+        SELECT version, checksum, dirty FROM ${sql(SCHEMA_META_TABLE)} WHERE id = 1
+      `;
+    const row = rows[0];
+    if (row === undefined)
+        return { version: 0, checksum: "", dirty: false, present: false };
+    return { version: Number(row.version), checksum: row.checksum, dirty: row.dirty, present: true };
+})).pipe(Effect.mapError((error) => SchemaMigrationFailed.make({
+    source,
+    message: "message" in error ? String(error.message) : "schema meta read failed",
+})));
+const migrationEffect = Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    for (const statement of SCHEMA_STATEMENTS)
+        yield* sql.unsafe(statement);
+    const now = yield* DateTime.nowAsDate;
+    yield* sql `
+    INSERT INTO ${sql(SCHEMA_META_TABLE)} (id, version, checksum, dirty, applied_at)
+    VALUES (1, ${SCHEMA_VERSION}, ${schemaChecksum()}, FALSE, ${now})
+  `;
+});
+export const plan = (source) => Effect.map(readMeta(source), (meta) => ({
+    current: meta.version,
+    required: SCHEMA_VERSION,
+    checksum: schemaChecksum(),
+    statements: meta.present ? [] : SCHEMA_STATEMENTS,
+    upgradeRequired: !meta.present,
+}));
+export const check = (source) => Effect.gen(function* () {
+    const meta = yield* readMeta(source);
+    if (!meta.present)
+        return yield* SchemaUpgradeRequired.make({ source, current: 0, required: SCHEMA_VERSION });
+    if (meta.dirty)
+        return yield* SchemaDirty.make({ source, version: meta.version });
+    if (meta.version > SCHEMA_VERSION) {
+        return yield* SchemaVersionUnsupported.make({ source, version: meta.version, supported: SCHEMA_VERSION });
+    }
+    const expected = schemaChecksum();
+    if (meta.version !== SCHEMA_VERSION || meta.checksum !== expected) {
+        return yield* SchemaChecksumMismatch.make({ source, expected, actual: meta.checksum });
+    }
+});
+export const apply = (source) => Effect.gen(function* () {
+    const meta = yield* readMeta(source);
+    if (meta.present)
+        return yield* check(source);
+    const sql = yield* SqlClient.SqlClient;
+    const existing = yield* sql `
+      SELECT COUNT(*) AS present FROM information_schema.tables
+      WHERE table_schema = current_schema() AND table_name LIKE 'baton\_%' ESCAPE '\'
+    `;
+    if (Number(existing[0]?.present ?? 0) > 0) {
+        return yield* SchemaMigrationFailed.make({
+            source,
+            message: "cannot create the baseline over an existing TenetKit schema",
+        });
+    }
+    const runMigrations = Migrator.make({});
+    yield* runMigrations({
+        loader: Migrator.fromRecord({ "0001_baton_runtime": migrationEffect }),
+        table: MIGRATIONS_TABLE,
+    }).pipe(Effect.mapError((error) => SchemaMigrationFailed.make({
+        source,
+        message: "message" in error ? String(error.message) : "migration failed",
+    })));
+    yield* check(source).pipe(Effect.catchTag("tenetkit/runtime/SchemaUpgradeRequired", (error) => SchemaMigrationFailed.make({ source, message: `schema absent after apply: ${error.current}` })));
+});
+export const markDirty = (source) => mapSqlError(Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `UPDATE ${sql(SCHEMA_META_TABLE)} SET dirty = TRUE WHERE id = 1`;
+})).pipe(Effect.mapError((error) => SchemaMigrationFailed.make({
+    source,
+    message: "message" in error ? String(error.message) : "failed to mark schema dirty",
+})));
+export const RunSchema = { plan, check, apply, markDirty };
+export const layerClient = (url) => PgClient.layer({ url: Redacted.make(url) });

package/dist/postgres/runtime-layer.d.ts

@@ -0,0 +1,15 @@
+import { Layer } from "effect";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import { Runtime } from "tenetkit/runtime/driver/runtime";
+import { RunStore } from "tenetkit/runtime/driver/run-store";
+import { RunClaims } from "tenetkit/runtime/driver/sql/run-claims";
+import { ExecutionHost } from "tenetkit/runtime/driver/execution-host";
+import type { LayerOptions } from "tenetkit/runtime/driver/runtime";
+import { SchemaMigrationFailed, type SchemaChecksumMismatch, type SchemaDirty, type SchemaUpgradeRequired, type SchemaVersionUnsupported } from "tenetkit/runtime/driver/sql/errors";
+export interface PostgresStoreOptions extends LayerOptions {
+    readonly url: string;
+    readonly source?: string;
+    readonly maxConnections?: number;
+}
+export type PostgresStoreError = SchemaDirty | SchemaChecksumMismatch | SchemaVersionUnsupported | SchemaUpgradeRequired | SchemaMigrationFailed;
+export declare const layerPostgres: (options: PostgresStoreOptions) => Layer.Layer<Runtime | RunStore | RunClaims | ExecutionHost, PostgresStoreError | SqlError>;

package/dist/postgres/runtime-layer.js

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer, Redacted } from "effect";
+import { PgClient } from "@effect/sql-pg";
+import { makeRuntime } from "tenetkit/runtime/driver/memory/runtime-layer";
+import { Runtime } from "tenetkit/runtime/driver/runtime";
+import { RunStore } from "tenetkit/runtime/driver/run-store";
+import { RunClaims } from "tenetkit/runtime/driver/sql/run-claims";
+import { makePostgresServices } from "./store.js";
+import { ExecutionHost, make as makeExecutionHost } from "tenetkit/runtime/driver/execution-host";
+import { layer as activeExecutionsLayer } from "tenetkit/runtime/driver/active-executions";
+import { layer as modelPreviewLayer } from "tenetkit/runtime/driver/model-preview";
+import { SchemaMigrationFailed, } from "tenetkit/runtime/driver/sql/errors";
+export const layerPostgres = (options) => {
+    const maxConnections = options.maxConnections ?? 10;
+    const client = Layer.unwrap(Effect.gen(function* () {
+        if (!Number.isSafeInteger(maxConnections) || maxConnections < 1) {
+            return yield* SchemaMigrationFailed.make({
+                source: options.source ?? "postgres",
+                message: "PostgreSQL maxConnections must be a positive integer",
+            });
+        }
+        return PgClient.layer({ url: Redacted.make(options.url), maxConnections });
+    }));
+    const services = Layer.effectContext(makePostgresServices(options).pipe(Effect.map(({ store, claims }) => Context.make(RunStore, store).pipe(Context.add(RunClaims, claims))))).pipe(Layer.provide(client));
+    const dependencies = Layer.mergeAll(services, activeExecutionsLayer, modelPreviewLayer);
+    const runtime = Layer.effect(Runtime, makeRuntime(options)).pipe(Layer.provide(dependencies));
+    const host = Layer.effect(ExecutionHost, makeExecutionHost({ workerId: "postgres", resolver: options.resolver })).pipe(Layer.provide(dependencies));
+    return Layer.mergeAll(runtime, host, services);
+};

package/dist/postgres/schema.d.ts

@@ -0,0 +1,6 @@
+export declare const SCHEMA_VERSION = 7;
+export declare const SCHEMA_META_TABLE = "baton_schema_meta";
+export declare const MIGRATIONS_TABLE = "baton_sql_migrations";
+export declare const NOTIFY_CHANNEL = "baton_run_events";
+export declare const SCHEMA_STATEMENTS: ReadonlyArray<string>;
+export declare const schemaChecksum: () => string;