@tenetkit/pg 0.40.1 → 0.41.1

package/dist/postgres/{store-cancel.js → store/cancel.js}

@@ -1,11 +1,11 @@
 import { Effect, Function } from "effect";
 import { RunNotFound, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
 import { isTerminal } from "tenetkit/runtime/driver/run";
-import { hasPendingOperationCancellation, hasUnsettledChild } from "tenetkit/runtime/driver/sql/store-child-settlement";
-import { markOperationCancellations } from "tenetkit/runtime/driver/sql/store-operations";
-import { afterTerminal, appendEvent, loadRun, settleParent } from "./pg-helpers.js";
-import { cancelOwnedFanOuts } from "./store-fan-out.js";
-import { reconcileProgramCancellation } from "tenetkit/runtime/driver/sql/store-program";
+import { hasPendingOperationCancellation, hasUnsettledChild } from "tenetkit/runtime/driver/sql/store/child/settlement";
+import { markOperationCancellations } from "tenetkit/runtime/driver/sql/store/operation/operations";
+import { afterTerminal, appendEvent, loadRun, settleParent } from "./runtime.js";
+import { cancelOwnedFanOuts } from "./fan-out.js";
+import { reconcileProgramCancellation } from "tenetkit/runtime/driver/sql/store/program";
 export const deferCancelledFanOutParent = Function.dual(2, (sql, runId) => Effect.gen(function* () {
     const running = yield* sql `
       SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${runId} AND status = 'running' LIMIT 1
@@ -15,14 +15,46 @@ export const deferCancelledFanOutParent = Function.dual(2, (sql, runId) => Effec
     yield* sql `UPDATE tenetkit_runs SET owner_worker_id = NULL, lease_expires_at = NULL WHERE run_id = ${runId}`;
     return true;
 }));
-export const makeCancelRun = (input) => {
+const cancelChildren = (input, cancelRun, runId, reason) => Effect.gen(function* () {
+    const linked = yield* input.sql `
+      SELECT l.child_run_id FROM tenetkit_run_links l
+      LEFT JOIN tenetkit_fan_out_members m ON m.child_run_id = l.child_run_id
+      WHERE l.parent_run_id = ${runId} AND m.child_run_id IS NULL
+      ORDER BY l.child_run_id ASC
+    `;
+    const owned = yield* cancelOwnedFanOuts(input.sql, runId);
+    for (const childRunId of [...linked.map((link) => link.child_run_id), ...owned]) {
+        const child = yield* loadRun(childRunId);
+        if (child !== undefined && !isTerminal(child.status)) {
+            yield* cancelRun(child.runId, reason ?? "parent cancelled");
+        }
+    }
+    return linked.length + owned.length;
+});
+const settleCancellation = (input, current, reason) => Effect.gen(function* () {
+    const running = yield* input.sql `
+      SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${current.runId} AND status = 'running' LIMIT 1
+    `;
+    if (running.length > 0)
+        return;
+    if (yield* hasPendingOperationCancellation(current.runId))
+        return;
+    if (yield* hasUnsettledChild(current.runId))
+        return;
+    const event = yield* appendEvent(input.hub, current, { _tag: "RunCancelled", ...(reason === undefined ? undefined : { reason }) }, "cancelled");
+    const settled = (yield* loadRun(current.runId));
+    yield* settleParent(input.hub, settled, event.eventId);
+    yield* afterTerminal(input.hub, settled);
+});
+const shouldSettleCancellation = (terminal, executing, current) => !terminal && !executing && !isTerminal(current.status);
+export const cancelRunFor = (input) => {
     const cancelRun = (runId, reason) => Effect.gen(function* () {
         let current = yield* loadRun(runId).pipe(Effect.flatMap((run) => (run === undefined ? RunNotFound.make({ runId }) : Effect.succeed(run))));
         const terminal = isTerminal(current.status);
         const needsResolution = current.status === "needs-resolution";
         const executing = current.ownerWorkerId !== undefined && (current.status === "running" || current.status === "cancelling");
         if (!terminal && !current.cancellationRequested) {
-            yield* appendEvent(input.hub, current, { _tag: "RunCancellationRequested", ...(reason === undefined ? {} : { reason }) }, needsResolution ? "needs-resolution" : "cancelling");
+            yield* appendEvent(input.hub, current, { _tag: "RunCancellationRequested", ...(reason === undefined ? undefined : { reason }) }, needsResolution ? "needs-resolution" : "cancelling");
             current = (yield* loadRun(runId));
         }
         const marked = terminal ? 0 : yield* markOperationCancellations(runId);
@@ -36,46 +68,10 @@ export const makeCancelRun = (input) => {
         UPDATE tenetkit_run_waits SET status = 'cancelled', closed_at = NOW()
         WHERE run_id = ${runId} AND status = 'open'
       `;
-        const linked = yield* input.sql `
-        SELECT l.child_run_id FROM tenetkit_run_links l
-        LEFT JOIN tenetkit_fan_out_members m ON m.child_run_id = l.child_run_id
-        WHERE l.parent_run_id = ${runId} AND m.child_run_id IS NULL
-        ORDER BY l.child_run_id ASC
-      `;
-        for (const link of linked) {
-            const child = yield* loadRun(link.child_run_id);
-            if (child !== undefined && !isTerminal(child.status))
-                yield* cancelRun(child.runId, reason ?? "parent cancelled");
-        }
-        if (linked.length > 0)
-            current = (yield* loadRun(runId));
-        const owned = yield* cancelOwnedFanOuts(input.sql, runId);
-        for (const childRunId of owned) {
-            const child = yield* loadRun(childRunId);
-            if (child !== undefined && !isTerminal(child.status))
-                yield* cancelRun(child.runId, reason ?? "parent cancelled");
-        }
-        if (owned.length > 0)
+        if ((yield* cancelChildren(input, cancelRun, runId, reason)) > 0)
             current = (yield* loadRun(runId));
-        if (terminal)
-            return;
-        if (executing)
-            return;
-        if (isTerminal(current.status))
-            return;
-        const running = yield* input.sql `
-        SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${runId} AND status = 'running' LIMIT 1
-      `;
-        if (running.length > 0)
-            return;
-        if (yield* hasPendingOperationCancellation(runId))
-            return;
-        if (yield* hasUnsettledChild(runId))
-            return;
-        const event = yield* appendEvent(input.hub, current, { _tag: "RunCancelled", ...(reason === undefined ? {} : { reason }) }, "cancelled");
-        const settled = (yield* loadRun(runId));
-        yield* settleParent(input.hub, settled, event.eventId);
-        yield* afterTerminal(input.hub, settled);
+        if (shouldSettleCancellation(terminal, executing, current))
+            yield* settleCancellation(input, current, reason);
     });
     return cancelRun;
 };

package/dist/postgres/{store-claims.d.ts → store/claims.d.ts}

@@ -4,11 +4,11 @@ import { SqlClient } from "effect/unstable/sql";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
-import { type Interface as ClaimsInterface } from "tenetkit/runtime/driver/sql/run-claims";
-import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
+import { type Interface as ClaimsInterface } from "tenetkit/runtime/driver/sql/run/claims";
+import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/effect";
 type SqlR = SqlClient.SqlClient | PgClient.PgClient;
 export type RunFn = <A, E>(effect: Effect.Effect<A, E | SqlError, SqlR>) => Effect.Effect<A, WithoutSqlError<E | SqlError> | RuntimeUnavailable>;
-export declare const makePostgresClaims: (input: {
+export declare const postgresClaims: (input: {
     readonly sql: SqlClient.SqlClient;
     readonly hub: EventHub;
     readonly run: RunFn;

package/dist/postgres/{store-claims.js → store/claims.js}

@@ -1,13 +1,14 @@
-import { Effect } from "effect";
+import { Effect, Schema } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { AgentExecutionFailure, RunNotFound, RunTerminal, RuntimeUnavailable, failureMessage, } from "tenetkit/runtime/driver/errors";
 import { isTerminal } from "tenetkit/runtime/driver/run";
 import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
-import { claimReadyRuns, refreshLease, releaseClaim } from "./claims.js";
-import { RunClaims } from "tenetkit/runtime/driver/sql/run-claims";
-import { afterTerminal, appendEvent, completeRun, loadEventsAfter, loadRun, settleParent } from "./pg-helpers.js";
-import { lockRunHierarchy } from "./locks.js";
-export const makePostgresClaims = (input) => {
+import { claimReadyRuns, refreshLease, releaseClaim } from "../runs/claims.js";
+import { RunClaims } from "tenetkit/runtime/driver/sql/run/claims";
+import { afterTerminal, appendEvent, completeRun, loadEventsAfter, loadRun, settleParent } from "./runtime.js";
+import { lockRunHierarchy } from "../runs/locks.js";
+import { ExecutionResult } from "tenetkit/runtime/driver/execution/state";
+export const postgresClaims = (input) => {
     const { hub, run, cancelRun } = input;
     return RunClaims.of({
         claimReadyRuns: (claimInput) => run(Effect.gen(function* () {
@@ -58,7 +59,8 @@ export const makePostgresClaims = (input) => {
                 return yield* RunTerminal.make({ runId: loaded.runId, status: loaded.status });
             }
             if (commitInput.transition === "complete") {
-                yield* completeRun(hub, loaded, commitInput.result);
+                const result = yield* Schema.decodeUnknownEffect(ExecutionResult)(commitInput.result).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: String(error) })));
+                yield* completeRun(hub, loaded, result);
                 return;
             }
             const event = yield* appendEvent(hub, loaded, {

package/dist/postgres/{store-fan-out.d.ts → store/fan-out.d.ts}

@@ -1,9 +1,9 @@
 import { Effect } from "effect";
 import type { PgClient } from "@effect/sql-pg";
 import type { SqlClient } from "effect/unstable/sql";
-import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { Interface as RunStoreInterface } 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 { WithoutSqlError } from "tenetkit/runtime/driver/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> | import("tenetkit/runtime/driver/errors").RuntimeUnavailable>;

package/dist/postgres/{store-fan-out.js → store/fan-out.js}

@@ -1,6 +1,6 @@
 import { Effect, Function } from "effect";
-import { admitFanOut, inspectFanOut } from "tenetkit/runtime/driver/sql/store-fan-out";
-import { NOTIFY_CHANNEL } from "./schema.js";
+import { admitFanOut, inspectFanOut } from "tenetkit/runtime/driver/sql/store/fan-out/service";
+import { NOTIFY_CHANNEL } from "../schema.js";
 export const fanOutStoreMethods = (input) => ({
     admitFanOut: (fanOut) => input
         .run(input.sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${fanOut.parentRunId} FOR UPDATE`.pipe(Effect.andThen(input.sql `SELECT pg_advisory_xact_lock(hashtext(${`fanout:${fanOut.parentRunId}:${fanOut.idempotencyKey}`}))`), Effect.andThen(admitFanOut(input.hub, fanOut))))

package/dist/postgres/{store.d.ts → store/index.d.ts}

@@ -1,7 +1,10 @@
 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 "../schema.js";
+import "tenetkit/runtime/driver/sql/tree-history";
+import "tenetkit/runtime/driver/sql/inspection/service";
+import type { PostgresStoreOptions } from "../runtime-layer.js";
+export declare const postgresServices: (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>;

package/dist/postgres/{store.js → store/index.js}

@@ -1,52 +1,51 @@
 import { Effect, Equal, Option } from "effect";
-import { listRuns } from "tenetkit/runtime/driver/sql/store-list";
+import { listRuns } from "tenetkit/runtime/driver/sql/store/list";
 import { SqlClient } from "effect/unstable/sql";
-import { claimExecution, loadExecution, requireExecutionClaim, retryExecution, saveExecution, } from "tenetkit/runtime/driver/sql/store-execution";
+import { claimExecution, loadExecution, requireExecutionClaim, retryExecution, saveExecution, } from "tenetkit/runtime/driver/sql/store/execution";
 import { PgClient } from "@effect/sql-pg";
-import { ApprovalStale, IdempotencyConflict, ResponseConflict } from "tenetkit/runtime/driver/errors";
-import { ChildSelectionMissing, RunTerminal, RuntimeUnavailable, WaitNotOpen } from "tenetkit/runtime/driver/errors";
+import { ApprovalStale, ChildSelectionMissing, IdempotencyConflict, ResponseConflict, RunTerminal, RuntimeUnavailable, WaitNotOpen, } from "tenetkit/runtime/driver/errors";
 import { childDigest } from "tenetkit/runtime/driver/memory/digest";
-import { enforceChildAdmission } from "tenetkit/runtime/driver/sql/store-admit-send";
-import { equals, resolveChild } from "tenetkit/runtime/driver/executable-manifest";
+import { enforceChildAdmission } from "tenetkit/runtime/driver/sql/store/admit-send";
+import { equals, resolveChild } from "tenetkit/runtime/driver/executable/manifest";
 import { isTerminal } from "tenetkit/runtime/driver/run";
-import { PendingRunOutcome, RunStore } from "tenetkit/runtime/driver/run-store";
-import { admitSteering, readSteering, saveCompletionContinuation } from "tenetkit/runtime/driver/sql/store-steering";
-import { messagingStoreMethods } from "./store-messaging.js";
-import { withSql } from "tenetkit/runtime/driver/sql/sql-effect";
-import { makeEventHub } from "tenetkit/runtime/driver/sql/subscribers";
-import { check as checkSchema } from "./run-schema.js";
-import {} from "./schema.js";
-import { makeTransactionRunner, nextId } from "./transaction-events.js";
-import { makeEventStream } from "./event-stream.js";
-import { makePostgresClaims } from "./store-claims.js";
-import { postgresOperations } from "./store-ops.js";
-import { releaseLeasedExecution as releaseExecution } from "tenetkit/runtime/driver/sql/store-release-leased";
-import { hasAdmission, loadRunWait } from "tenetkit/runtime/driver/sql/store-helpers";
-import { WaitResolution } from "tenetkit/runtime/driver/run-wait";
-import { fanOutStoreMethods } from "./store-fan-out.js";
-import { deferCancelledFanOutParent, makeCancelRun } from "./store-cancel.js";
-import {} from "tenetkit/runtime/driver/sql/tree-history";
-import {} from "tenetkit/runtime/driver/sql/inspection";
-import { withConsistentSnapshot } from "tenetkit/runtime/driver/sql/inspection-transaction";
-import { StringArray, decodePinnedEffect, decodeStoredPinnedEffect, encodeJson, } from "tenetkit/runtime/driver/sql/codecs";
-import { suspend } from "./store-suspend.js";
-import { afterTerminal, appendEvent, completeRun, emitAgentEvent, insertRun, loadEventsAfter, loadRun, requireRun, settleParent, } from "./pg-helpers.js";
-import { lockMailbox, lockRun, lockRunHierarchy, lockSpawnParent } from "./locks.js";
-import { inspectionStoreMethods } from "./store-inspection.js";
-import { programStoreMethods } from "./store-program.js";
-import { admitStart as admitExactStart } from "tenetkit/runtime/driver/sql/store-admit";
-import { activateRoot } from "tenetkit/runtime/driver/sql/store-activate";
-import { admitSend } from "./store-admit.js";
-import { associateRegistrations, loadRegistrations } from "tenetkit/runtime/driver/sql/executable-registrations";
-import { narrow } from "tenetkit/runtime/driver/executable-registration";
+import { PendingRunOutcome, RunStore } from "tenetkit/runtime/driver/run/store";
+import { admitSteering, readSteering, saveCompletionContinuation, } from "tenetkit/runtime/driver/sql/store/steering/service";
+import { messagingStoreMethods } from "./messaging.js";
+import { withSql } from "tenetkit/runtime/driver/sql/effect";
+import { make as makeEventHub } from "tenetkit/runtime/driver/sql/subscribers";
+import { check as checkSchema } from "../run-schema.js";
+import "../schema.js";
+import { transactionRunner, nextId } from "../events/transaction-events.js";
+import { eventStream } from "../events/event-stream.js";
+import { postgresClaims } from "./claims.js";
+import { postgresOperations } from "./ops.js";
+import { releaseLeasedExecution as releaseExecution } from "tenetkit/runtime/driver/sql/store/release-leased";
+import { hasAdmission, loadRunWait } from "tenetkit/runtime/driver/sql/store/statements";
+import { WaitResolution } from "tenetkit/runtime/driver/run/wait";
+import { fanOutStoreMethods } from "./fan-out.js";
+import { deferCancelledFanOutParent, cancelRunFor } from "./cancel.js";
+import "tenetkit/runtime/driver/sql/tree-history";
+import "tenetkit/runtime/driver/sql/inspection/service";
+import { withConsistentSnapshot } from "tenetkit/runtime/driver/sql/inspection/transaction";
+import { StringArray, decodePinnedEffect, decodeStoredPinnedEffect, encodeJson, } from "tenetkit/runtime/driver/sql/codec/codecs";
+import { suspend } from "./suspend.js";
+import { afterTerminal, appendEvent, completeRun, emitAgentEvent, insertRun, loadEventsAfter, loadRun, requireRun, settleParent, } from "./runtime.js";
+import { lockMailbox, lockRun, lockRunHierarchy, lockSpawnParent } from "../runs/locks.js";
+import { inspectionStoreMethods } from "./inspection.js";
+import { programStoreMethods } from "./program.js";
+import { admitStart as admitExactStart } from "tenetkit/runtime/driver/sql/store/admit";
+import { activateRoot } from "tenetkit/runtime/driver/sql/store/activate";
+import { admitSend } from "./admit.js";
+import { associateRegistrations, loadRegistrations } from "tenetkit/runtime/driver/sql/executable/registrations";
+import { narrow } from "tenetkit/runtime/driver/executable/registration";
 import { approvalResponse } from "tenetkit/runtime/driver/sql/respond-approval";
 import { settlementNotifications } from "tenetkit/runtime/driver/sql/settlement-notifications";
-import { reconcileCancellationRequested } from "tenetkit/runtime/driver/sql/session-lifecycle";
-import { cancelSessionRuns } from "./session-cancellation.js";
-import { makePostgresSessionStore } from "./session-store.js";
-import { readinessForAdmission } from "tenetkit/runtime/driver/sql/store-child-capacity";
-import { hasPendingOperationCancellation } from "tenetkit/runtime/driver/sql/store-child-settlement";
-export const makePostgresServices = (options) => Effect.gen(function* () {
+import { reconcileCancellationRequested } from "tenetkit/runtime/driver/sql/session/lifecycle";
+import { cancelSessionRuns } from "../sessions/session-cancellation.js";
+import { postgresSessionStore } from "../sessions/session-store.js";
+import { readinessForAdmission } from "tenetkit/runtime/driver/sql/store/child/capacity";
+import { hasPendingOperationCancellation } from "tenetkit/runtime/driver/sql/store/child/settlement";
+export const postgresServices = (options) => Effect.gen(function* () {
     const source = options.source ?? "postgres";
     const addressBindings = new Map(options.addresses.map((entry) => [entry.address, entry.executable]));
     yield* checkSchema(source);
@@ -56,9 +55,9 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     yield* reconcileCancellationRequested;
     const pg = yield* PgClient.PgClient;
-    const { run, runNoTxn, transactionHub } = makeTransactionRunner({ sql, pg, hub });
+    const { run, runNoTxn, transactionHub } = transactionRunner({ sql, pg, hub });
     const runInspection = (effect) => withSql(sql, withConsistentSnapshot(sql, "postgres", effect.pipe(Effect.provideService(PgClient.PgClient, pg))));
-    const cancelRun = makeCancelRun({ sql, hub: transactionHub });
+    const cancelRun = cancelRunFor({ sql, hub: transactionHub });
     const operations = postgresOperations({
         sql,
         hub: transactionHub,
@@ -70,7 +69,7 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
     });
     const store = RunStore.of({
         info: Effect.succeed({ durability: "durable", backend: "postgres", multiWorker: true }),
-        sessionStore: (sessionId) => Effect.succeed(Option.some(makePostgresSessionStore({ sessionId, run, runNoTxn }))),
+        sessionStore: (sessionId) => Effect.succeed(Option.some(postgresSessionStore({ sessionId, run, runNoTxn }))),
         hasAdmission: (input) => runNoTxn(hasAdmission(input)),
         admitSend: (input) => run(admitSend(transactionHub, addressBindings, nextId, input)),
         admitStart: (input, startOptions) => run(sql `SELECT pg_advisory_xact_lock(hashtext('tenetkit:executable-registrations'))`.pipe(Effect.andThen(admitExactStart(transactionHub, input, startOptions)))),
@@ -84,8 +83,8 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
             const digest = childDigest(input.message, executableRef, {
                 parentRunId: parent.runId,
                 invocationId: input.invocationId,
-                ...(input.label === undefined ? {} : { label: input.label }),
-                ...(input.origin === undefined ? {} : { origin: input.origin }),
+                ...(input.label === undefined ? undefined : { label: input.label }),
+                ...(input.origin === undefined ? undefined : { origin: input.origin }),
             });
             const executable = yield* decodePinnedEffect({
                 ref: executableRef,
@@ -112,7 +111,7 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
                 return {
                     runId: prior.run_id,
                     messageId: prior.message_id,
-                    acceptedSequence: Number(prior.accepted_sequence),
+                    acceptedSequence: prior.accepted_sequence,
                     duplicate: true,
                 };
             }
@@ -146,8 +145,8 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
                 prompt: input.message.prompt,
                 childDepth: parent.depth + 1,
                 readiness: childReadiness,
-                ...(input.label === undefined ? {} : { label: input.label }),
-                ...(input.origin === undefined ? {} : { origin: input.origin }),
+                ...(input.label === undefined ? undefined : { label: input.label }),
+                ...(input.origin === undefined ? undefined : { origin: input.origin }),
             });
             const child = (yield* loadRun(runId));
             yield* appendEvent(transactionHub, child, { _tag: "RunAccepted", messageId: input.message.id, address: input.message.to }, "queued");
@@ -159,7 +158,7 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
             yield* appendEvent(transactionHub, { ...started, attempt: 1 }, { _tag: "RunAttemptStarted", attempt: 1 }, "running");
             return { runId, messageId: input.message.id, acceptedSequence: 0, duplicate: false };
         })),
-        events: (input) => makeEventStream({
+        events: (input) => eventStream({
             hub,
             pg,
             runId: input.runId,
@@ -255,7 +254,7 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
             const resolution = {
                 _tag: "Signal",
                 name: input.name,
-                ...(input.payload === undefined ? {} : { payload: input.payload }),
+                ...(input.payload === undefined ? undefined : { payload: input.payload }),
             };
             yield* sql `
               UPDATE tenetkit_run_waits SET status = 'signaled', response_json = ${encodeJson(WaitResolution, resolution)}, closed_at = NOW()
@@ -295,7 +294,10 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
                 if ((yield* deferCancelledFanOutParent(sql, loaded.runId)) ||
                     (yield* hasPendingOperationCancellation(loaded.runId)))
                     return;
-                const event = yield* appendEvent(transactionHub, loaded, { _tag: "RunCancelled", ...(loaded.cancelReason === undefined ? {} : { reason: loaded.cancelReason }) }, "cancelled");
+                const event = yield* appendEvent(transactionHub, loaded, {
+                    _tag: "RunCancelled",
+                    ...(loaded.cancelReason === undefined ? undefined : { reason: loaded.cancelReason }),
+                }, "cancelled");
                 const settled = (yield* loadRun(loaded.runId));
                 yield* settleParent(transactionHub, settled, event.eventId);
                 yield* afterTerminal(transactionHub, settled);
@@ -372,6 +374,6 @@ export const makePostgresServices = (options) => Effect.gen(function* () {
         ...operations,
         ...programStoreMethods({ sql, hub: transactionHub, run, runNoTxn, lockRunHierarchy }),
     });
-    const claims = makePostgresClaims({ sql, hub: transactionHub, run, cancelRun });
+    const claims = postgresClaims({ sql, hub: transactionHub, run, cancelRun });
     return { store, claims };
 });

package/dist/postgres/{store-inspection.d.ts → store/inspection.d.ts}

@@ -1,8 +1,8 @@
 import type { PgClient } from "@effect/sql-pg";
-import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run/store";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
-import type { RunFn } from "./store-ops.js";
-import type { Run } from "./store-fan-out.js";
+import type { RunFn } from "./ops.js";
+import type { Run } from "./fan-out.js";
 export declare const inspectionStoreMethods: (deps: {
     readonly hub: EventHub;
     readonly pg: PgClient.PgClient;

package/dist/postgres/{store-inspection.js → store/inspection.js}

@@ -1,12 +1,12 @@
 import { Effect, Stream } from "effect";
 import { CursorExpired } from "tenetkit/runtime/driver/errors";
-import { loadRunSnapshot, loadTreeInspection } from "tenetkit/runtime/driver/sql/inspection";
-import { sessionRoots } from "tenetkit/runtime/driver/sql/session-lifecycle";
-import { loadChildReadiness } from "tenetkit/runtime/driver/sql/store-child-capacity";
-import { loadRunWait } from "tenetkit/runtime/driver/sql/store-helpers";
+import { loadRunSnapshot, loadTreeInspection } from "tenetkit/runtime/driver/sql/inspection/service";
+import { sessionRoots } from "tenetkit/runtime/driver/sql/session/lifecycle";
+import { loadChildReadiness } from "tenetkit/runtime/driver/sql/store/child/capacity";
+import { loadRunWait } from "tenetkit/runtime/driver/sql/store/statements";
 import { loadTreeHistory } from "tenetkit/runtime/driver/sql/tree-history";
-import { loadEventsAfter, loadRun, requireRun } from "./pg-helpers.js";
-import { NOTIFY_CHANNEL } from "./schema.js";
+import { loadEventsAfter, loadRun, requireRun } from "./runtime.js";
+import { NOTIFY_CHANNEL } from "../schema.js";
 export const inspectionStoreMethods = (deps) => ({
     inspect: (runId) => deps.runNoTxn(Effect.gen(function* () {
         const loaded = yield* requireRun(runId);
@@ -21,9 +21,9 @@ export const inspectionStoreMethods = (deps) => ({
             treePolicy: loaded.treePolicy,
             lastSequence: loaded.lastSequence,
             durability: "durable",
-            ...(loaded.parentRunId === undefined ? {} : { parentRunId: loaded.parentRunId }),
-            ...(childReadiness === undefined ? {} : { childReadiness }),
-            ...(wait === undefined ? {} : { wait }),
+            ...(loaded.parentRunId === undefined ? undefined : { parentRunId: loaded.parentRunId }),
+            ...(childReadiness === undefined ? undefined : { childReadiness }),
+            ...(wait === undefined ? undefined : { wait }),
         };
     })),
     snapshot: (runId) => deps.runInspection(loadRunSnapshot(runId)),
@@ -39,6 +39,6 @@ export const inspectionStoreMethods = (deps) => ({
     treeHistory: (input) => deps.runNoTxn(loadTreeHistory(input)),
     treeChanges: (rootRunId) => deps.hub.subscribeTree({
         rootRunId,
-        onSubscribed: deps.pg.listen(NOTIFY_CHANNEL).pipe(Stream.runForEach((runId) => deps.runNoTxn(loadRun(String(runId))).pipe(Effect.flatMap((loaded) => (loaded?.rootRunId === rootRunId ? deps.hub.wakeTree(rootRunId) : Effect.void)), Effect.ignore)), Effect.ignore),
+        onSubscribed: deps.pg.listen(NOTIFY_CHANNEL).pipe(Stream.runForEach((runId) => deps.runNoTxn(loadRun(runId)).pipe(Effect.flatMap((loaded) => (loaded?.rootRunId === rootRunId ? deps.hub.wakeTree(rootRunId) : Effect.void)), Effect.ignore)), Effect.ignore),
     }),
 });

package/dist/postgres/{store-messaging.d.ts → store/messaging.d.ts}

@@ -1,8 +1,8 @@
 import { Effect } from "effect";
 import type { SqlClient } from "effect/unstable/sql";
-import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run/store";
 import type { SqlError } from "effect/unstable/sql/SqlError";
-import type { RunFn } from "./store-ops.js";
+import type { RunFn } from "./ops.js";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
 /** The addressed-messaging half of the Postgres RunStore, kept beside the store it completes. */
 export declare const messagingStoreMethods: (input: {

package/dist/postgres/{store-messaging.js → store/messaging.js}

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { admitMessage, deliverPendingMessages, directory, listRelated, pendingMessages, registerAgentName, resolveAddress, } from "tenetkit/runtime/driver/sql/store-directory";
+import { admitMessage, deliverPendingMessages, directory, listRelated, pendingMessages, registerAgentName, resolveAddress, } from "tenetkit/runtime/driver/sql/store/directory";
 /** The addressed-messaging half of the Postgres RunStore, kept beside the store it completes. */
 export const messagingStoreMethods = (input) => ({
     directory: (runId) => input.runNoTxn(directory(runId)),

package/dist/postgres/{store-model-response.d.ts → store/model-response.d.ts}

@@ -3,16 +3,16 @@ import type { PgClient } from "@effect/sql-pg";
 import { SqlClient } from "effect/unstable/sql";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 import { RuntimeUnavailable, type RunNotFound } from "tenetkit/runtime/driver/errors";
-import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
-import type { DecodedRun } from "tenetkit/runtime/driver/sql/rows";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run/store";
+import type { DecodedRun } from "tenetkit/runtime/driver/sql/codec/rows";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
-import type { RunFn } from "./store-ops.js";
+import type { RunFn } from "./ops.js";
 type SqlR = SqlClient.SqlClient | PgClient.PgClient;
 export declare const postgresModelResponseOperations: (input: {
     readonly sql: SqlClient.SqlClient;
     readonly hub: EventHub;
     readonly run: RunFn;
     readonly requireRun: (runId: string) => Effect.Effect<DecodedRun, RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
-    readonly requireClaim: (claim: import("tenetkit/runtime/driver/run-store").ExecutionClaim) => Effect.Effect<void, import("tenetkit/runtime/driver/sql/errors").StaleClaim | RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
+    readonly requireClaim: (claim: import("tenetkit/runtime/driver/run/store").ExecutionClaim) => Effect.Effect<void, import("tenetkit/runtime/driver/sql/errors").StaleClaim | RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
 }) => Pick<RunStoreInterface, "commitModelResponse" | "commitInterruptedModelResponse">;
 export {};

package/dist/postgres/{store-model-response.js → store/model-response.js}

@@ -1,14 +1,47 @@
 import { Effect, Schema } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
-import { appendEvent, loadEventsAfter, toOperationRecord } from "./pg-helpers.js";
-import { encodeExecutableRef, encodeJson, encodeJsonValue } from "tenetkit/runtime/driver/sql/codecs";
-import { ExecutionCheckpoint } from "tenetkit/runtime/driver/execution-state";
-import { encodeContinuation } from "tenetkit/runtime/driver/steering";
-import { checkpointRef } from "tenetkit/runtime/driver/executable-manifest";
-import { sameModelResponseEvent, validateModelResponseCommit } from "tenetkit/runtime/driver/model-response-commit";
-import { sameInterruptedModelOutcome, sameInterruptedModelResponse, validateInterruptedModelResponse, } from "tenetkit/runtime/driver/model-response-interrupted";
-import { appendCompletedSessionEntry, appendInterruptedSessionEntry, verifyCompletedSessionEntry, verifyInterruptedSessionEntry, } from "./session-store.js";
+import { appendEvent, loadEventsAfter, toOperationRecord } from "./runtime.js";
+import { encodeExecutableRef, encodeJson, encodeJsonValue } from "tenetkit/runtime/driver/sql/codec/codecs";
+import { ExecutionCheckpoint } from "tenetkit/runtime/driver/execution/state";
+import { encodeContinuation } from "tenetkit/runtime/driver/run/steering";
+import { checkpointRef } from "tenetkit/runtime/driver/executable/manifest";
+import { sameModelResponseEvent, validateModelResponseCommit, } from "tenetkit/runtime/driver/execution/model-response/commit";
+import { sameInterruptedModelOutcome, sameInterruptedModelResponse, validateInterruptedModelResponse, } from "tenetkit/runtime/driver/execution/model-response/interrupted";
+import { appendCompletedSessionEntry, appendInterruptedSessionEntry, verifyCompletedSessionEntry, verifyInterruptedSessionEntry, } from "../sessions/session-store.js";
+const verifyCompletedModelRetry = (input) => Effect.gen(function* () {
+    const { current, loaded, op } = input;
+    const validated = validateModelResponseCommit({
+        record: current,
+        input: op,
+        sessionId: loaded.message.sessionId,
+    });
+    if (Schema.is(RuntimeUnavailable)(validated))
+        return yield* validated;
+    const prior = (yield* loadEventsAfter(op.runId, -1)).filter((event) => event._tag === "ModelResponseCommitted" && event.operationKey === op.event.operationKey);
+    if (prior.length !== 1 ||
+        prior[0]?._tag !== "ModelResponseCommitted" ||
+        !sameModelResponseEvent({ left: prior[0], right: validated.event })) {
+        return yield* RuntimeUnavailable.make({
+            message: `model operation ${op.operationId} has a divergent outbox retry`,
+        });
+    }
+    yield* verifyCompletedSessionEntry(validated.entry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
+    return current;
+});
+const verifySteeringOwnership = (sql, op) => Effect.gen(function* () {
+    for (const entryId of new Set(op.steeringEntryIds ?? [])) {
+        const rows = yield* sql `
+        SELECT consumed_operation_id FROM tenetkit_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`,
+            });
+        }
+    }
+});
 export const postgresModelResponseOperations = (input) => {
     const { sql, hub, run, requireRun, requireClaim } = input;
     const fenced = (claim, effect) => run(sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${claim.runId} FOR UPDATE`.pipe(Effect.andThen(requireClaim(claim)), Effect.andThen(effect)));
@@ -88,43 +121,18 @@ export const postgresModelResponseOperations = (input) => {
                 return yield* validated;
             const sessionEntry = validated.entry;
             if (current.status === "succeeded") {
-                const priorValidation = validateModelResponseCommit({
-                    record: current,
-                    input: {
-                        ...op,
-                        outcome: { _tag: "Succeeded", value: current.result },
-                    },
-                    sessionId: loaded.message.sessionId,
+                return yield* verifyCompletedModelRetry({
+                    current,
+                    loaded,
+                    op: { ...op, outcome: { _tag: "Succeeded", value: current.result } },
                 });
-                if (Schema.is(RuntimeUnavailable)(priorValidation))
-                    return yield* priorValidation;
-                const prior = (yield* loadEventsAfter(op.runId, -1)).filter((event) => event._tag === "ModelResponseCommitted" && event.operationKey === op.event.operationKey);
-                if (prior.length !== 1 ||
-                    prior[0]?._tag !== "ModelResponseCommitted" ||
-                    !sameModelResponseEvent({ left: prior[0], right: validated.event })) {
-                    return yield* RuntimeUnavailable.make({
-                        message: `model operation ${op.operationId} has a divergent outbox retry`,
-                    });
-                }
-                yield* verifyCompletedSessionEntry(sessionEntry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
-                return current;
             }
             if (current.status === "failed" || current.status === "unknown") {
                 return yield* RuntimeUnavailable.make({
                     message: `model operation ${op.operationId} already completed as ${current.status}`,
                 });
             }
-            for (const entryId of new Set(op.steeringEntryIds ?? [])) {
-                const rows = yield* sql `
-              SELECT consumed_operation_id FROM tenetkit_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`,
-                    });
-                }
-            }
+            yield* verifySteeringOwnership(sql, op);
             const executableRef = yield* Effect.try({
                 try: () => checkpointRef(loaded.executableRef, loaded.executableManifest, op.checkpoint),
                 catch: (error) => RuntimeUnavailable.make({ message: String(error) }),