@tenetkit/pg 0.40.1 → 0.41.2

package/dist/postgres/{event-stream.d.ts → events/event-stream.d.ts}

@@ -2,10 +2,10 @@ import { Effect, Stream } from "effect";
 import type { PgClient } from "@effect/sql-pg";
 import type { Cursor } from "tenetkit/runtime/driver/cursor";
 import type { CursorExpired, RunNotFound, RuntimeUnavailable, SubscriberLagged } from "tenetkit/runtime/driver/errors";
-import type { RunEvent } from "tenetkit/runtime/driver/run-event";
+import type { RunEvent } from "tenetkit/runtime/driver/run/event";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
 type EventsError = CursorExpired | RunNotFound | RuntimeUnavailable | SubscriberLagged;
-export declare const makeEventStream: (input: {
+export declare const eventStream: (input: {
     readonly hub: EventHub;
     readonly pg: PgClient.PgClient;
     readonly runId: string;

package/dist/postgres/{event-stream.js → events/event-stream.js}

@@ -1,6 +1,6 @@
 import { Effect, Schedule, Stream, SynchronizedRef } from "effect";
-import { NOTIFY_CHANNEL } from "./schema.js";
-export const makeEventStream = (input) => Stream.unwrap(Effect.gen(function* () {
+import { NOTIFY_CHANNEL } from "../schema.js";
+export const eventStream = (input) => Stream.unwrap(Effect.gen(function* () {
     const cursor = yield* SynchronizedRef.make(input.cursor);
     const catchUp = SynchronizedRef.modifyEffect(cursor, (current) => input.loadAfter(current).pipe(Effect.flatMap((events) => Effect.forEach(events, (event) => input.hub.publish(input.runId, event)).pipe(Effect.as(events.at(-1)?.sequence ?? current))), Effect.map((last) => [last, last]))).pipe(Effect.ignore);
     return input.hub.subscribe({

package/dist/postgres/{transaction-events.d.ts → events/transaction-events.d.ts}

@@ -2,8 +2,8 @@ import { Effect } from "effect";
 import { PgClient } from "@effect/sql-pg";
 import { SqlClient } from "effect/unstable/sql";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
-import type { RunFn } from "./store-ops.js";
-export declare const makeTransactionRunner: (input: {
+import type { RunFn } from "../store/ops.js";
+export declare const transactionRunner: (input: {
     readonly sql: SqlClient.SqlClient;
     readonly pg: PgClient.PgClient;
     readonly hub: EventHub;

package/dist/postgres/{transaction-events.js → events/transaction-events.js}

@@ -1,10 +1,10 @@
 import { Context, Effect, Random } from "effect";
 import { PgClient } from "@effect/sql-pg";
 import { SqlClient } from "effect/unstable/sql";
-import { withSql } from "tenetkit/runtime/driver/sql/sql-effect";
-import { NOTIFY_CHANNEL } from "./schema.js";
-const TransactionEvents = Context.Reference("tenetkit/runtime/sql/postgres/TransactionEvents", { defaultValue: () => [] });
-export const makeTransactionRunner = (input) => {
+import { withSql } from "tenetkit/runtime/driver/sql/effect";
+import { NOTIFY_CHANNEL } from "../schema.js";
+const TransactionEvents = Context.Reference("tenetkit/runtime/driver/sql/postgres/TransactionEvents", { defaultValue: () => [] });
+export const transactionRunner = (input) => {
     const transactionHub = {
         ...input.hub,
         publish: (runId, event) => Effect.flatMap(TransactionEvents, (events) => Effect.sync(() => void events.push([runId, event]))),

package/dist/postgres/run-schema.js

@@ -2,11 +2,11 @@ import { Cause, 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 { mapSqlError } from "tenetkit/runtime/driver/sql/effect";
 import { MIGRATION_NAME, MIGRATIONS_TABLE, SCHEMA_META_TABLE, SCHEMA_STATEMENTS, SCHEMA_TABLES, SCHEMA_VERSION, schemaChecksum, } from "./schema.js";
 const migrationFailure = (source, fallback) => (error) => SchemaMigrationFailed.make({
     source,
-    message: typeof error === "object" && error !== null && "message" in error ? String(error.message) : fallback,
+    message: error.message || fallback,
 });
 const readMeta = (source) => mapSqlError(Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
@@ -24,10 +24,10 @@ const readMeta = (source) => mapSqlError(Effect.gen(function* () {
     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 };
+    return { version: 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",
+    message: "message" in error ? error.message : "schema meta read failed",
 })));
 const verifyMigrationIdentity = (source) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
@@ -90,7 +90,7 @@ export const apply = (source) => Effect.gen(function* () {
       SELECT COUNT(*) AS present FROM information_schema.tables
       WHERE table_schema = current_schema() AND table_name IN ${sql.in(SCHEMA_TABLES)}
     `;
-    if (Number(existing[0]?.present ?? 0) > 0) {
+    if ((existing[0]?.present ?? 0) > 0) {
         return yield* SchemaMigrationFailed.make({
             source,
             message: "cannot create the baseline over an existing TenetKit schema",
@@ -104,7 +104,7 @@ export const markDirty = (source) => mapSqlError(Effect.gen(function* () {
     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",
+    message: "message" in error ? 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/{claims.d.ts → runs/claims.d.ts}

@@ -1,7 +1,7 @@
 import { Duration, Effect } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
-import type { ClaimedRun } from "tenetkit/runtime/driver/sql/run-claims";
+import type { ClaimedRun } from "tenetkit/runtime/driver/sql/run/claims";
 export interface ClaimOptions {
     readonly workerId: string;
     readonly limit: number;
@@ -19,7 +19,7 @@ export declare const requireClaim: (input: {
     readonly runId: string;
     readonly workerId: string;
     readonly attemptFence: number;
-}) => Effect.Effect<import("tenetkit/runtime/driver/sql/rows").DecodedRun, import("tenetkit/runtime/driver/errors").RuntimeUnavailable | import("effect/unstable/sql/SqlError").SqlError | StaleClaim, SqlClient.SqlClient>;
+}) => Effect.Effect<import("tenetkit/runtime/driver/sql/codec/rows").DecodedRun, import("tenetkit/runtime/driver/errors").RuntimeUnavailable | import("effect/unstable/sql/SqlError").SqlError | StaleClaim, SqlClient.SqlClient>;
 export declare const releaseClaim: (input: {
     readonly runId: string;
     readonly workerId: string;

package/dist/postgres/{claims.js → runs/claims.js}

@@ -1,7 +1,7 @@
 import { Clock, DateTime, Duration, Effect } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
-import { decodeRunEffect, loadRun } from "tenetkit/runtime/driver/sql/store-helpers";
+import { decodeRunEffect, loadRun } from "tenetkit/runtime/driver/sql/store/statements";
 export const claimReadyRuns = (options) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const leaseMs = Duration.toMillis(options.lease);

package/dist/postgres/{locks.d.ts → runs/locks.d.ts}

@@ -15,4 +15,4 @@ export declare const lockRunHierarchy: (runId: string) => Effect.Effect<void, im
  * on the target rather than on any one sender's Run.
  */
 export declare const lockMailbox: (targetSessionId: string) => Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient.SqlClient>;
-export declare const lockSpawnParent: (runId: string) => Effect.Effect<import("tenetkit/runtime/driver/sql/rows").DecodedRun, RunNotFound | RunTerminal | import("tenetkit/runtime/driver/errors").RuntimeUnavailable | import("effect/unstable/sql/SqlError").SqlError, SqlClient.SqlClient>;
+export declare const lockSpawnParent: (runId: string) => Effect.Effect<import("tenetkit/runtime/driver/sql/codec/rows").DecodedRun, RunNotFound | RunTerminal | import("tenetkit/runtime/driver/errors").RuntimeUnavailable | import("effect/unstable/sql/SqlError").SqlError, SqlClient.SqlClient>;

package/dist/postgres/{locks.js → runs/locks.js}

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { RunNotFound, RunTerminal } from "tenetkit/runtime/driver/errors";
 import { isTerminal } from "tenetkit/runtime/driver/run";
-import { loadRun } from "./pg-helpers.js";
+import { loadRun } from "../store/runtime.js";
 /**
  * One Run-level lock serializing admission, steering, response, resume, timeout,
  * cancellation, and terminal settlement. Always taken advisory-first, then row,
@@ -26,7 +26,7 @@ export const lockRunHierarchy = (runId) => Effect.gen(function* () {
         hierarchy.push(row.parent_run_id);
         current = row.parent_run_id;
     }
-    for (const id of hierarchy.reverse())
+    for (const id of hierarchy.toReversed())
         yield* lockRun(id);
 });
 /**

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

@@ -1,10 +1,9 @@
 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 { Runtime, type LayerOptions } from "tenetkit/runtime/driver/service";
+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 { SchemaMigrationFailed, type SchemaChecksumMismatch, type SchemaDirty, type SchemaUpgradeRequired, type SchemaVersionUnsupported } from "tenetkit/runtime/driver/sql/errors";
 export interface PostgresStoreOptions extends LayerOptions {
     readonly url: string;

package/dist/postgres/runtime-layer.js

@@ -1,13 +1,13 @@
 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 { makeRuntime } from "tenetkit/runtime/driver/memory/layer";
+import { Runtime } from "tenetkit/runtime/driver/service";
+import { RunStore } from "tenetkit/runtime/driver/run/store";
+import { RunClaims } from "tenetkit/runtime/driver/sql/run/claims";
+import { postgresServices } from "./store/index.js";
+import { ExecutionHost, make as makeExecutionHost } from "tenetkit/runtime/driver/execution/host";
+import { layer as activeExecutionsLayer } from "tenetkit/runtime/driver/execution/active-executions";
+import { layer as modelPreviewLayer } from "tenetkit/runtime/driver/execution/model-response/preview";
 import { SchemaMigrationFailed, } from "tenetkit/runtime/driver/sql/errors";
 export const layerPostgres = (options) => {
     const maxConnections = options.maxConnections ?? 10;
@@ -20,7 +20,7 @@ export const layerPostgres = (options) => {
         }
         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 services = Layer.effectContext(postgresServices(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));

package/dist/postgres/{session-cancellation.js → sessions/session-cancellation.js}

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { activeSessionRuns, sessionRoots, sessionRuns } from "tenetkit/runtime/driver/sql/session-lifecycle";
+import { activeSessionRuns, sessionRoots, sessionRuns } from "tenetkit/runtime/driver/sql/session/lifecycle";
 export const cancelSessionRuns = (input) => Effect.gen(function* () {
     const roots = yield* sessionRoots(input.sessionId);
     const runs = yield* sessionRuns(input.sessionId);

package/dist/postgres/{session-storage.d.ts → sessions/session-storage.d.ts}

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 import { Session } from "tenetkit";
 import { SqlClient } from "effect/unstable/sql";
 import type { SqlError } from "effect/unstable/sql/SqlError";
-import { type EntryRow, type SessionRow } from "tenetkit/runtime/driver/sql/session-store";
+import { type EntryRow, type SessionRow } from "tenetkit/runtime/driver/sql/session/store";
 declare const insertEntry: (input: {
     readonly sessionId: string;
     readonly id: string;
@@ -17,7 +17,7 @@ declare const advanceSession: (input: {
     readonly nextSeq: number;
     readonly ownerToken?: string;
 }) => Effect.Effect<void, SqlError, SqlClient.SqlClient>;
-export declare const PostgresSessionStorage: {
+interface PostgresSessionStorage {
     readonly encodePayload: (payload: Session.EntryPayload) => string;
     readonly entryPayloadEquivalence: (self: Session.EntryPayload, that: Session.EntryPayload) => boolean;
     readonly storeError: (message: string) => Session.SessionStoreError;
@@ -28,5 +28,6 @@ export declare const PostgresSessionStorage: {
     readonly requireActive: (rows: ReadonlyArray<EntryRow>, leaf: string | null, entryId: string, reason?: "stale-leaf" | "checkpoint-not-on-active-path") => Session.SessionConflict | undefined;
     readonly insertEntry: typeof insertEntry;
     readonly advanceSession: typeof advanceSession;
-};
+}
+export declare const PostgresSessionStorage: PostgresSessionStorage;
 export {};

package/dist/postgres/{session-storage.js → sessions/session-storage.js}

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { Session } from "tenetkit";
 import { SqlClient } from "effect/unstable/sql";
-import { SessionStorage } from "tenetkit/runtime/driver/sql/session-store";
+import { SessionStorage } from "tenetkit/runtime/driver/sql/session/store";
 const { encodePayload, entryPayloadEquivalence, pathFromRows, requireActive, storeError, toEntry } = SessionStorage;
 const lockSession = (sessionId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;

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

@@ -2,10 +2,10 @@ import { Effect } from "effect";
 import { Session } from "tenetkit";
 import { SqlClient } from "effect/unstable/sql";
 import type { SqlError } from "effect/unstable/sql/SqlError";
-import type { CompletedSessionEntry } from "tenetkit/runtime/driver/model-response-commit";
-import type { InterruptedSessionEntry } from "tenetkit/runtime/driver/agent-event";
-import { type HandoffSessionEntry } from "tenetkit/runtime/driver/handoff-session";
-import type { RunFn } from "./store-ops.js";
+import type { CompletedSessionEntry } from "tenetkit/runtime/driver/execution/model-response/commit";
+import type { InterruptedSessionEntry } from "tenetkit/runtime/driver/execution/agent/event";
+import { type HandoffSessionEntry } from "tenetkit/runtime/driver/session/handoff";
+import type { RunFn } from "../store/ops.js";
 /** Append or verify one exact completed assistant projection in the caller's PostgreSQL transaction. */
 export declare const appendCompletedSessionEntry: (input: CompletedSessionEntry) => Effect.Effect<Session.Entry, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
 /** Verify an exact completed assistant projection in the caller's PostgreSQL transaction. */
@@ -17,7 +17,7 @@ export declare const verifyInterruptedSessionEntry: (input: InterruptedSessionEn
 export declare const appendHandoffSessionEntry: (input: HandoffSessionEntry) => Effect.Effect<Session.HandoffEntry, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
 export declare const verifyHandoffSessionEntry: (input: HandoffSessionEntry) => Effect.Effect<void, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
 /** Dialect-native durable PostgreSQL Session authority bound to one session identity. */
-export declare const makePostgresSessionStore: (options: {
+export declare const postgresSessionStore: (options: {
     readonly sessionId: string;
     readonly run: RunFn;
     readonly runNoTxn: RunFn;

package/dist/postgres/{session-store.js → sessions/session-store.js}

@@ -1,11 +1,22 @@
 import { Effect, Schema } from "effect";
 import { Session } from "tenetkit";
 import { SqlClient } from "effect/unstable/sql";
-import { handoffPayload } from "tenetkit/runtime/driver/handoff-session";
-import {} from "tenetkit/runtime/driver/sql/session-store";
+import { handoffPayload } from "tenetkit/runtime/driver/session/handoff";
 import { PostgresSessionStorage } from "./session-storage.js";
 const { advanceSession, entryPayloadEquivalence, insertEntry, loadEntries, lockSession, pathFromRows, requireActive, storeError, toEntry, } = PostgresSessionStorage;
 const appendMatches = (entry, input, parentId) => entry.parentId === parentId && entryPayloadEquivalence(entry, input);
+const nextGeneratedId = (sql, sessionId, firstSequence) => Effect.gen(function* () {
+    let sequence = firstSequence;
+    while (true) {
+        const collision = yield* sql `
+        SELECT entry_id FROM tenetkit_session_entries
+        WHERE session_id = ${sessionId} AND entry_id = ${String(sequence)}
+      `;
+        if (collision[0] === undefined)
+            return { id: String(sequence), sequence };
+        sequence += 1;
+    }
+});
 const completedPayload = (input) => ({
     _tag: "ModelResponse",
     content: input.content,
@@ -27,8 +38,7 @@ export const appendCompletedSessionEntry = (input) => Effect.gen(function* () {
     const existing = rows[0];
     const payload = completedPayload(input);
     if (existing !== undefined) {
-        if (existing.parent_id !== input.parentId ||
-            !entryPayloadEquivalence(toEntry(existing), payload)) {
+        if (existing.parent_id !== input.parentId || !entryPayloadEquivalence(toEntry(existing), payload)) {
             return yield* Session.SessionConflict.make({
                 reason: "entry-id-reused",
                 message: `Session entry id ${input.entryId} does not match the completed response`,
@@ -49,14 +59,14 @@ export const appendCompletedSessionEntry = (input) => Effect.gen(function* () {
         sessionId: input.sessionId,
         id: input.entryId,
         parentId: input.parentId,
-        seq: Number(session.next_seq),
+        seq: session.next_seq,
         tag: "ModelResponse",
-        payload: payload,
+        payload,
     });
     yield* advanceSession({
         sessionId: input.sessionId,
         leafId: input.entryId,
-        nextSeq: Number(session.next_seq) + 1,
+        nextSeq: session.next_seq + 1,
     });
     return { ...payload, id: input.entryId, parentId: input.parentId };
 });
@@ -92,8 +102,7 @@ export const appendInterruptedSessionEntry = (input) => Effect.gen(function* ()
     const existing = rows[0];
     const payload = interruptedPayload(input);
     if (existing !== undefined) {
-        if (existing.parent_id !== input.parentId ||
-            !entryPayloadEquivalence(toEntry(existing), payload)) {
+        if (existing.parent_id !== input.parentId || !entryPayloadEquivalence(toEntry(existing), payload)) {
             return yield* Session.SessionConflict.make({
                 reason: "entry-id-reused",
                 message: `Session entry id ${input.entryId} was reused with different interrupted response content`,
@@ -114,14 +123,14 @@ export const appendInterruptedSessionEntry = (input) => Effect.gen(function* ()
         sessionId: input.sessionId,
         id: input.entryId,
         parentId: input.parentId,
-        seq: Number(session.next_seq),
+        seq: session.next_seq,
         tag: "ModelResponse",
-        payload: payload,
+        payload,
     });
     yield* advanceSession({
         sessionId: input.sessionId,
         leafId: input.entryId,
-        nextSeq: Number(session.next_seq) + 1,
+        nextSeq: session.next_seq + 1,
     });
     return { ...payload, id: input.entryId, parentId: input.parentId };
 });
@@ -156,8 +165,7 @@ export const appendHandoffSessionEntry = (input) => Effect.gen(function* () {
     const existing = rows[0];
     const payload = handoffPayload(input);
     if (existing !== undefined) {
-        if (existing.parent_id !== input.parentId ||
-            !entryPayloadEquivalence(toEntry(existing), payload)) {
+        if (existing.parent_id !== input.parentId || !entryPayloadEquivalence(toEntry(existing), payload)) {
             return yield* Session.SessionConflict.make({
                 reason: "entry-id-reused",
                 message: `Session entry id ${input.entryId} does not match the handoff projection`,
@@ -166,7 +174,14 @@ export const appendHandoffSessionEntry = (input) => Effect.gen(function* () {
         const conflict = requireActive(yield* loadEntries(input.sessionId), session.leaf_id, input.entryId);
         if (conflict !== undefined)
             return yield* conflict;
-        return toEntry(existing);
+        const entry = toEntry(existing);
+        if (entry._tag !== "Handoff") {
+            return yield* Session.SessionConflict.make({
+                reason: "entry-id-reused",
+                message: `Session entry id ${input.entryId} does not contain a handoff projection`,
+            });
+        }
+        return entry;
     }
     if (session.leaf_id !== input.parentId) {
         return yield* Session.SessionConflict.make({
@@ -178,14 +193,14 @@ export const appendHandoffSessionEntry = (input) => Effect.gen(function* () {
         sessionId: input.sessionId,
         id: input.entryId,
         parentId: input.parentId,
-        seq: Number(session.next_seq),
+        seq: session.next_seq,
         tag: "Handoff",
         payload,
     });
     yield* advanceSession({
         sessionId: input.sessionId,
         leafId: input.entryId,
-        nextSeq: Number(session.next_seq) + 1,
+        nextSeq: session.next_seq + 1,
     });
     return { ...payload, id: input.entryId, parentId: input.parentId };
 });
@@ -214,7 +229,7 @@ const mapSessionError = (effect) => Effect.mapError(effect, (error) => Schema.is
     : storeError(String(error)));
 const mapReadError = (effect) => Effect.mapError(effect, (error) => (Schema.is(Session.SessionStoreError)(error) ? error : storeError(String(error))));
 /** Dialect-native durable PostgreSQL Session authority bound to one session identity. */
-export const makePostgresSessionStore = (options) => {
+export const postgresSessionStore = (options) => {
     const { sessionId, run, runNoTxn } = options;
     const append = (entry, appendOptions) => Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
@@ -245,32 +260,23 @@ export const makePostgresSessionStore = (options) => {
                 message: `Expected Session leaf ${String(appendOptions.expectedLeafId)} but found ${String(session.leaf_id)}`,
             });
         }
-        let generatedSequence = Number(session.next_seq);
-        if (appendOptions?.id === undefined) {
-            while (true) {
-                const collision = yield* sql `
-            SELECT entry_id FROM tenetkit_session_entries
-            WHERE session_id = ${sessionId} AND entry_id = ${String(generatedSequence)}
-          `;
-                if (collision[0] === undefined)
-                    break;
-                generatedSequence += 1;
-            }
-        }
-        const id = appendOptions?.id ?? String(generatedSequence);
+        const generated = appendOptions?.id === undefined
+            ? yield* nextGeneratedId(sql, sessionId, session.next_seq)
+            : { id: appendOptions.id, sequence: session.next_seq };
+        const id = generated.id;
         yield* insertEntry({
             sessionId,
             id,
             parentId: session.leaf_id,
-            seq: Number(session.next_seq),
+            seq: session.next_seq,
             tag: entry._tag,
             payload: entry,
         });
         yield* advanceSession({
             sessionId,
             leafId: id,
-            nextSeq: appendOptions?.id === undefined ? generatedSequence + 1 : Number(session.next_seq) + 1,
-            ...(appendOptions?.ownerToken === undefined ? {} : { ownerToken: appendOptions.ownerToken }),
+            nextSeq: generated.sequence + 1,
+            ...(appendOptions?.ownerToken === undefined ? undefined : { ownerToken: appendOptions.ownerToken }),
         });
         return { ...entry, id, parentId: session.leaf_id };
     });
@@ -317,22 +323,22 @@ export const makePostgresSessionStore = (options) => {
             parentId: prepared.parentId,
             projectedHistory: prepared.projectedHistory,
             telemetry: prepared.telemetry,
-            ...(prepared.compactionCommit === undefined ? {} : { compactionCommit: prepared.compactionCommit }),
-            ...(prepared.summary === undefined ? {} : { summary: prepared.summary }),
+            ...(prepared.compactionCommit === undefined ? undefined : { compactionCommit: prepared.compactionCommit }),
+            ...(prepared.summary === undefined ? undefined : { summary: prepared.summary }),
         };
         yield* insertEntry({
             sessionId,
             id: checkpoint.id,
             parentId: checkpoint.parentId,
-            seq: Number(session.next_seq),
+            seq: session.next_seq,
             tag: "Compaction",
             payload: checkpoint,
         });
         yield* advanceSession({
             sessionId,
             leafId: checkpoint.id,
-            nextSeq: Number(session.next_seq) + 1,
-            ...(prepared.ownerToken === undefined ? {} : { ownerToken: prepared.ownerToken }),
+            nextSeq: session.next_seq + 1,
+            ...(prepared.ownerToken === undefined ? undefined : { ownerToken: prepared.ownerToken }),
         });
         return { _tag: "Appended", checkpoint, leafId: checkpoint.id };
     });
@@ -340,7 +346,7 @@ export const makePostgresSessionStore = (options) => {
         reserveEntryId: run(Effect.gen(function* () {
             const sql = yield* SqlClient.SqlClient;
             const session = yield* lockSession(sessionId);
-            let sequence = Number(session.next_seq);
+            let sequence = session.next_seq;
             while (true) {
                 const collision = yield* sql `
             SELECT entry_id FROM tenetkit_session_entries

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

@@ -1,8 +1,8 @@
 import { Effect } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { AddressNotFound, IdempotencyConflict, RunIdConflict, TreePolicyInvalid } from "tenetkit/runtime/driver/errors";
-import type { PinnedExecutable } from "tenetkit/runtime/driver/executable-manifest";
-import type { AdmitSendInput } from "tenetkit/runtime/driver/run-store";
+import { type PinnedExecutable } from "tenetkit/runtime/driver/executable/manifest";
+import type { AdmitSendInput } from "tenetkit/runtime/driver/run/store";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
 /** Exact addressed admission for the PostgreSQL store. */
 export declare const admitSend: {

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

@@ -1,12 +1,12 @@
 import { Effect, Function } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { AddressNotFound, IdempotencyConflict, RunIdConflict, TreePolicyInvalid } from "tenetkit/runtime/driver/errors";
-import { equals } from "tenetkit/runtime/driver/executable-manifest";
+import { equals } from "tenetkit/runtime/driver/executable/manifest";
 import { rootDigest } from "tenetkit/runtime/driver/memory/digest";
-import { appendEvent, enqueueLane, insertRun, loadRun } from "./pg-helpers.js";
-import { associateRegistrations, persistRegistrations } from "tenetkit/runtime/driver/sql/executable-registrations";
-import { decodePinnedEffect, decodeStoredPinnedEffect } from "tenetkit/runtime/driver/sql/codecs";
-import { normalize as normalizeTreePolicy } from "tenetkit/runtime/driver/tree-policy";
+import { appendEvent, enqueueLane, insertRun, loadRun } from "./runtime.js";
+import { associateRegistrations, persistRegistrations } from "tenetkit/runtime/driver/sql/executable/registrations";
+import { decodePinnedEffect, decodeStoredPinnedEffect } from "tenetkit/runtime/driver/sql/codec/codecs";
+import { normalize as normalizeTreePolicy } from "tenetkit/runtime/driver/tree/policy";
 /** Exact addressed admission for the PostgreSQL store. */
 export const admitSend = Function.dual(4, (hub, addressBindings, nextId, input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
@@ -50,7 +50,7 @@ export const admitSend = Function.dual(4, (hub, addressBindings, nextId, input)
         return {
             runId: prior.run_id,
             messageId: prior.message_id,
-            acceptedSequence: Number(prior.accepted_sequence),
+            acceptedSequence: prior.accepted_sequence,
             duplicate: true,
         };
     }

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

@@ -8,7 +8,7 @@ export declare const deferCancelledFanOutParent: {
     (runId: string): (sql: SqlClient.SqlClient) => Effect.Effect<boolean, SqlError, SqlClient.SqlClient>;
     (sql: SqlClient.SqlClient, runId: string): Effect.Effect<boolean, SqlError, SqlClient.SqlClient>;
 };
-export declare const makeCancelRun: (input: {
+export declare const cancelRunFor: (input: {
     readonly sql: SqlClient.SqlClient;
     readonly hub: EventHub;
 }) => (runId: string, reason: string | undefined) => Effect.Effect<void, RunNotFound | RuntimeUnavailable | SqlError, SqlClient.SqlClient | PgClient.PgClient>;