@tenetkit/pg 0.42.0 → 0.43.0

package/README.md

@@ -1,3 +1,37 @@
 # @tenetkit/pg
 
 PostgreSQL runtime backend for TenetKit.
+
+## Shared client
+
+`layer(options)` uses a caller-supplied Effect `PgClient`. Provide the same client Layer to the host so host SQL and TenetKit Runtime operations share one transaction service:
+
+```ts
+import { PgClient } from "@effect/sql-pg"
+import { Effect, Layer, Redacted } from "effect"
+import { SqlClient } from "effect/unstable/sql"
+import { layer } from "@tenetkit/pg"
+import { Run, Runtime } from "tenetkit/runtime"
+
+declare const options: Parameters<typeof layer>[0]
+declare const admission: Runtime.AdmitInput
+
+const client = PgClient.layer({ url: Redacted.make("postgres://localhost/app") })
+const app = layer(options).pipe(Layer.provideMerge(client))
+
+const admitWithHostRow = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient
+  const runtime = yield* Runtime.Runtime
+  const receipt: Run.RunReceipt = yield* sql.withTransaction(
+    Effect.gen(function* () {
+      yield* sql`INSERT INTO host_jobs (id) VALUES (${admission.idempotencyKey})`
+      return yield* runtime.admit(admission)
+    }),
+  )
+  return receipt
+}).pipe(Effect.provide(app))
+```
+
+Runtime admission nests through the exact same Effect SQL transaction service, so nested use keeps Effect SQL savepoint behavior. PostgreSQL notifications run on that transaction connection and become visible only after the outermost commit; rollback removes both host and Runtime rows without emitting a notification.
+
+`layerPostgres(options)` remains the convenient URL-backed constructor. Schema deployment stays separate through `RunSchema.plan`, `RunSchema.check`, and `RunSchema.apply`.

package/dist/postgres/events/transaction-events.d.ts

@@ -1,8 +1,11 @@
 import { Effect } from "effect";
 import { PgClient } from "@effect/sql-pg";
 import { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
 import type { RunFn } from "../store/ops.js";
+/** @experimental Notify event followers through the active SQL connection. */
+export declare const notifyRun: (runId: string) => Effect.Effect<void, SqlError, SqlClient.SqlClient>;
 export declare const transactionRunner: (input: {
     readonly sql: SqlClient.SqlClient;
     readonly pg: PgClient.PgClient;

package/dist/postgres/events/transaction-events.js

@@ -4,6 +4,8 @@ import { SqlClient } from "effect/unstable/sql";
 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: () => [] });
+/** @experimental Notify event followers through the active SQL connection. */
+export const notifyRun = (runId) => SqlClient.SqlClient.pipe(Effect.flatMap((sql) => sql `SELECT pg_notify(${NOTIFY_CHANNEL}, ${runId})`), Effect.asVoid);
 export const transactionRunner = (input) => {
     const transactionHub = {
         ...input.hub,
@@ -13,10 +15,9 @@ export const transactionRunner = (input) => {
     const run = (effect) => runRaw(Effect.gen(function* () {
         const events = [];
         const result = yield* effect.pipe(Effect.provideService(TransactionEvents, events));
-        return [result, events];
-    })).pipe(Effect.tap(([, events]) => Effect.forEach(new Set(events.map(([runId]) => runId)), (runId) => input.pg
-        .notify(NOTIFY_CHANNEL, runId)
-        .pipe(Effect.catch((error) => Effect.logWarning("runtime.postgres.event_notification.failed").pipe(Effect.annotateLogs({ "tenetkit.run.id": runId, "tenetkit.failure": String(error) })))), { discard: true })), Effect.map(([result]) => result));
+        yield* Effect.forEach(new Set(events.map(([runId]) => runId)), notifyRun, { discard: true });
+        return result;
+    }));
     const runNoTxn = (effect) => withSql(input.sql, effect.pipe(Effect.provideService(PgClient.PgClient, input.pg)));
     return { run, runNoTxn, transactionHub };
 };

package/dist/postgres/index.d.ts

@@ -1,3 +1,3 @@
-export { layerPostgres, type PostgresStoreOptions, type PostgresStoreError } from "./runtime-layer.js";
+export { layer, layerPostgres, type PostgresOptions, type PostgresUrlOptions, type PostgresStoreError, } from "./runtime-layer.js";
 export * as RunSchema from "./run-schema.js";
 export * from "tenetkit/runtime";

package/dist/postgres/index.js

@@ -1,3 +1,3 @@
-export { layerPostgres } from "./runtime-layer.js";
+export { layer, layerPostgres, } from "./runtime-layer.js";
 export * as RunSchema from "./run-schema.js";
 export * from "tenetkit/runtime";

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

@@ -1,14 +1,30 @@
 import { Layer } from "effect";
+import { PgClient } from "@effect/sql-pg";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 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;
+/** @experimental PostgreSQL Runtime options independent of client acquisition. */
+export interface PostgresOptions extends LayerOptions {
     readonly source?: string;
+}
+/** @experimental PostgreSQL Runtime options for the URL-backed convenience Layer. */
+export interface PostgresUrlOptions extends PostgresOptions {
+    readonly url: string;
     readonly maxConnections?: number;
 }
+/** @experimental PostgreSQL Runtime construction failures. */
 export type PostgresStoreError = SchemaDirty | SchemaChecksumMismatch | SchemaVersionUnsupported | SchemaUpgradeRequired | SchemaMigrationFailed;
-export declare const layerPostgres: (options: PostgresStoreOptions) => Layer.Layer<Runtime | RunStore | RunClaims | ExecutionHost, PostgresStoreError | SqlError>;
+type PostgresServices = Runtime | RunStore | RunClaims | ExecutionHost;
+/**
+ * @experimental Build the PostgreSQL Runtime from the caller's `PgClient`.
+ *
+ * Host transactions must use the `SqlClient` exposed by the same client Layer. Runtime operations
+ * then nest through that exact transaction service and therefore use PostgreSQL savepoints.
+ */
+export declare const layer: (options: PostgresOptions) => Layer.Layer<PostgresServices, PostgresStoreError | SqlError, PgClient.PgClient>;
+/** @experimental Build the PostgreSQL Runtime and its client from a URL. */
+export declare const layerPostgres: (options: PostgresUrlOptions) => Layer.Layer<PostgresServices, PostgresStoreError | SqlError>;
+export {};

package/dist/postgres/runtime-layer.js

@@ -1,4 +1,6 @@
 import { Context, Effect, Layer } from "effect";
+import { PgClient } from "@effect/sql-pg";
+import { SqlClient } from "effect/unstable/sql";
 import { makeRuntime } from "tenetkit/runtime/driver/memory/layer";
 import { Runtime } from "tenetkit/runtime/driver/service";
 import { RunStore } from "tenetkit/runtime/driver/run/store";
@@ -9,6 +11,21 @@ import { layer as activeExecutionsLayer } from "tenetkit/runtime/driver/executio
 import { layer as modelPreviewLayer } from "tenetkit/runtime/driver/execution/model-response/preview";
 import { SchemaMigrationFailed, } from "tenetkit/runtime/driver/sql/errors";
 import { layerClient } from "./client.js";
+/**
+ * @experimental Build the PostgreSQL Runtime from the caller's `PgClient`.
+ *
+ * Host transactions must use the `SqlClient` exposed by the same client Layer. Runtime operations
+ * then nest through that exact transaction service and therefore use PostgreSQL savepoints.
+ */
+export const layer = (options) => {
+    const client = Layer.effectContext(PgClient.PgClient.pipe(Effect.map((pg) => Context.make(PgClient.PgClient, pg).pipe(Context.add(SqlClient.SqlClient, pg)))));
+    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));
+    return Layer.mergeAll(runtime, host, services);
+};
+/** @experimental Build the PostgreSQL Runtime and its client from a URL. */
 export const layerPostgres = (options) => {
     const maxConnections = options.maxConnections ?? 10;
     const client = Layer.unwrap(Effect.gen(function* () {
@@ -20,9 +37,5 @@ export const layerPostgres = (options) => {
         }
         return layerClient({ url: options.url, maxConnections });
     }));
-    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));
-    return Layer.mergeAll(runtime, host, services);
+    return layer(options).pipe(Layer.provide(client));
 };

package/dist/postgres/store/claims.d.ts

@@ -9,7 +9,8 @@ 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 postgresClaims: (input: {
-    readonly sql: SqlClient.SqlClient;
+    readonly pg: PgClient.PgClient;
+    readonly source: string;
     readonly hub: EventHub;
     readonly run: RunFn;
     readonly cancelRun: (runId: string, reason: string | undefined) => Effect.Effect<void, RunNotFound | RunTerminal | RuntimeUnavailable | SqlError, SqlR>;

package/dist/postgres/store/claims.js

@@ -1,5 +1,6 @@
-import { Effect, Schema } from "effect";
+import { Cause, Duration, Effect, Queue, Redacted, Schema, Stream } from "effect";
 import { SqlClient } from "effect/unstable/sql";
+import { Client, escapeIdentifier } from "pg";
 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";
@@ -8,9 +9,54 @@ 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";
+import { NOTIFY_CHANNEL } from "../schema.js";
+import { notifyRun } from "../events/transaction-events.js";
+const wakeupChanges = (config, source) => Stream.callback((queue) => {
+    const client = new Client({
+        connectionString: config.url === undefined ? undefined : Redacted.value(config.url),
+        user: config.username,
+        host: config.host,
+        database: config.database,
+        password: config.password === undefined ? undefined : Redacted.value(config.password),
+        ssl: config.ssl,
+        port: config.port,
+        ...(config.stream === undefined ? undefined : { stream: config.stream }),
+        connectionTimeoutMillis: config.connectTimeout === undefined ? undefined : Duration.toMillis(config.connectTimeout),
+        application_name: `tenetkit-runtime-worker:${source}`.slice(0, 63),
+        types: config.types,
+    });
+    const failure = (cause) => RuntimeUnavailable.make({ message: `PostgreSQL RunClaims wakeup listener failed: ${String(cause)}` });
+    const onNotification = (notification) => {
+        if (notification.channel === NOTIFY_CHANNEL)
+            Queue.offerUnsafe(queue, undefined);
+    };
+    const onFailure = (cause) => Queue.failCauseUnsafe(queue, Cause.fail(failure(cause)));
+    const onEnd = () => onFailure("PostgreSQL listener connection ended");
+    const close = Effect.tryPromise(() => client.end()).pipe(Effect.ignore);
+    const acquire = Effect.acquireRelease(Effect.sync(() => {
+        client.on("notification", onNotification);
+        client.on("error", onFailure);
+        client.on("end", onEnd);
+    }), () => Effect.sync(() => {
+        client.off("notification", onNotification);
+        client.off("error", onFailure);
+        client.off("end", onEnd);
+    }).pipe(Effect.andThen(close)));
+    const connect = Effect.tryPromise({
+        try: () => client.connect(),
+        catch: failure,
+    }).pipe(Effect.andThen(Effect.tryPromise({
+        try: () => client.query(`LISTEN ${escapeIdentifier(NOTIFY_CHANNEL)}`),
+        catch: failure,
+    })), Effect.andThen(Effect.sync(() => {
+        Queue.offerUnsafe(queue, undefined);
+    })));
+    return acquire.pipe(Effect.andThen(connect));
+}, { bufferSize: 1, strategy: "sliding" });
 export const postgresClaims = (input) => {
     const { hub, run, cancelRun } = input;
     return RunClaims.of({
+        changes: wakeupChanges(input.pg.config, input.source),
         claimReadyRuns: (claimInput) => run(Effect.gen(function* () {
             const claimed = yield* claimReadyRuns({
                 workerId: claimInput.workerId,
@@ -34,10 +80,13 @@ export const postgresClaims = (input) => {
             cancellationRequested: leaseInput.cancellationRequested,
             lease: leaseInput.lease ?? "30 seconds",
         })),
-        releaseClaim: (releaseInput) => run(releaseClaim({
-            runId: releaseInput.runId,
-            workerId: releaseInput.workerId,
-            attemptFence: releaseInput.attemptFence,
+        releaseClaim: (releaseInput) => run(Effect.gen(function* () {
+            yield* releaseClaim({
+                runId: releaseInput.runId,
+                workerId: releaseInput.workerId,
+                attemptFence: releaseInput.attemptFence,
+            });
+            yield* notifyRun(releaseInput.runId);
         })),
         commitWithClaim: (commitInput) => run(Effect.gen(function* () {
             yield* lockRunHierarchy(commitInput.runId);

package/dist/postgres/store/fan-out.d.ts

@@ -1,15 +1,13 @@
 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 { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
 import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/effect";
 import type { SqlError } from "effect/unstable/sql/SqlError";
-type SqlR = SqlClient.SqlClient | PgClient.PgClient;
+type SqlR = SqlClient.SqlClient;
 export type Run = <A, E>(effect: Effect.Effect<A, E | SqlError, SqlR>) => Effect.Effect<A, WithoutSqlError<E | SqlError> | import("tenetkit/runtime/driver/errors").RuntimeUnavailable>;
 export declare const fanOutStoreMethods: (input: {
     readonly sql: SqlClient.SqlClient;
-    readonly pg: PgClient.PgClient;
     readonly hub: EventHub;
     readonly run: Run;
     readonly runNoTxn: Run;

package/dist/postgres/store/fan-out.js

@@ -1,10 +1,8 @@
 import { Effect, Function } from "effect";
 import { admitFanOut, inspectFanOut } from "tenetkit/runtime/driver/sql/store/fan-out/service";
-import { NOTIFY_CHANNEL } from "../schema.js";
+import { notifyRun } from "../events/transaction-events.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))))
-        .pipe(Effect.tap((receipt) => input.runNoTxn(Effect.forEach([receipt.parentRunId, ...receipt.childRunIds], (runId) => input.pg.notify(NOTIFY_CHANNEL, runId), { discard: true })))),
+    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)), Effect.tap((receipt) => Effect.forEach([receipt.parentRunId, ...receipt.childRunIds], notifyRun, { discard: true })))),
     inspectFanOut: (fanOutId) => input.runNoTxn(inspectFanOut(fanOutId)),
 });
 export const cancelOwnedFanOuts = Function.dual(2, (sql, parentRunId) => Effect.gen(function* () {

package/dist/postgres/store/index.d.ts

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

@@ -24,7 +24,7 @@ import { hasAdmission, loadRunWait } from "tenetkit/runtime/driver/sql/store/sta
 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/tree-replay";
 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";
@@ -370,10 +370,10 @@ export const postgresServices = (options) => Effect.gen(function* () {
         releaseExecution: (input) => run(releaseExecution(input)),
         saveExecution: (input) => run(saveExecution(input)),
         retryExecution: (input) => run(lockRun(input.runId).pipe(Effect.andThen(retryExecution(transactionHub, input)))),
-        ...fanOutStoreMethods({ sql, pg, hub: transactionHub, run, runNoTxn }),
+        ...fanOutStoreMethods({ sql, hub: transactionHub, run, runNoTxn }),
         ...operations,
         ...programStoreMethods({ sql, hub: transactionHub, run, runNoTxn, lockRunHierarchy }),
     });
-    const claims = postgresClaims({ sql, hub: transactionHub, run, cancelRun });
+    const claims = postgresClaims({ pg, source, hub: transactionHub, run, cancelRun });
     return { store, claims };
 });

package/dist/postgres/store/inspection.d.ts

@@ -9,4 +9,4 @@ export declare const inspectionStoreMethods: (deps: {
     readonly run: Run;
     readonly runNoTxn: Run;
     readonly runInspection: RunFn;
-}) => Pick<RunStoreInterface, "inspect" | "snapshot" | "sessionRoots" | "inspectTree" | "history" | "treeHistory" | "treeChanges">;
+}) => Pick<RunStoreInterface, "inspect" | "snapshot" | "sessionRoots" | "treeCheckpoint" | "history" | "treeReplay" | "treeChanges">;

package/dist/postgres/store/inspection.js

@@ -1,10 +1,10 @@
 import { Effect, Stream } from "effect";
 import { CursorExpired } from "tenetkit/runtime/driver/errors";
-import { loadRunSnapshot, loadTreeInspection } from "tenetkit/runtime/driver/sql/inspection/service";
+import { loadRunSnapshot, loadTreeCheckpoint } 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 { loadTreeReplay } from "tenetkit/runtime/driver/sql/tree-replay";
 import { loadEventsAfter, loadRun, requireRun } from "./runtime.js";
 import { NOTIFY_CHANNEL } from "../schema.js";
 export const inspectionStoreMethods = (deps) => ({
@@ -28,7 +28,7 @@ export const inspectionStoreMethods = (deps) => ({
     })),
     snapshot: (runId) => deps.runInspection(loadRunSnapshot(runId)),
     sessionRoots: (sessionId) => deps.runNoTxn(sessionRoots(sessionId)),
-    inspectTree: (rootRunId) => deps.runInspection(loadTreeInspection(rootRunId)),
+    treeCheckpoint: (rootRunId) => deps.runInspection(loadTreeCheckpoint(rootRunId)),
     history: (input) => deps.runNoTxn(Effect.gen(function* () {
         const loaded = yield* requireRun(input.runId);
         if (input.cursor < -1 || input.cursor > loaded.lastSequence) {
@@ -36,7 +36,7 @@ export const inspectionStoreMethods = (deps) => ({
         }
         return (yield* loadEventsAfter(input.runId, input.cursor)).slice(0, input.limit);
     })),
-    treeHistory: (input) => deps.runNoTxn(loadTreeHistory(input)),
+    treeReplay: (input) => deps.runNoTxn(loadTreeReplay(input)),
     treeChanges: (rootRunId) => deps.hub.subscribeTree({
         rootRunId,
         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/runtime.js

@@ -6,10 +6,10 @@ import { isTerminal } from "tenetkit/runtime/driver/run";
 import { StringArray, decodeMessage, decodeEvent, decodeQueue, encodeExecutableManifest, encodeExecutableRef, encodeEvent, encodeJson, encodeMessage, encodeQueue, } from "tenetkit/runtime/driver/sql/codec/codecs";
 import { reconcileFanOutWith } from "tenetkit/runtime/driver/sql/store/fan-out/service";
 import { decodePersistedEvents, decodeRunEffect, nowIso } from "tenetkit/runtime/driver/sql/store/statements";
-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 { notifyRun } from "../events/transaction-events.js";
 import { admitChildSettlementFromEventId } from "tenetkit/runtime/driver/sql/settlement-notifications";
 import { discardPendingSteering } from "tenetkit/runtime/driver/sql/store/steering/disposition";
 import { hasPendingOperationCancellation, hasUnsettledChild, loadTerminalEvent, reconcileChildWaitWith, } from "tenetkit/runtime/driver/sql/store/child/settlement";
@@ -83,7 +83,6 @@ export const allocateSequence = (runId) => Effect.gen(function* () {
 });
 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);
@@ -148,7 +147,7 @@ export const appendEvent = Function.dual((args) => args.length >= 4 || (args.len
         WHERE run_id = ${run.runId}
       `;
     }
-    yield* pg.notify(NOTIFY_CHANNEL, run.runId);
+    yield* notifyRun(run.runId);
     return event;
 }));
 export const promoteHead = Function.dual(3, (hub, address, sessionId) => Effect.gen(function* () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -40,7 +40,7 @@
   "dependencies": {
     "@effect/sql-pg": "4.0.0-rc.111",
     "pg": "8.23.0",
-    "tenetkit": "0.42.0"
+    "tenetkit": "0.43.0"
   },
   "devDependencies": {
     "@effect/vitest": "4.0.0-rc.111",