@qlever-llc/trellis 0.10.22 → 0.11.0-rc.1

package/esm/server/service.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _InternalStoreHandle_nc, _TrellisService_instances, _TrellisService_server, _TrellisService_nc, _TrellisService_handlerTrellis, _TrellisService_operationTransfer, _TrellisService_stopHealthPublishing, _TrellisService_managedJobWorkers, _TrellisService_waitPromise, _TrellisService_stopPromise, _TrellisService_createBoundHealth, _TrellisService_createBoundEventFacade, _TrellisService_createHandleFacade, _TrellisService_createBoundHandleFacade, _TrellisService_operation;
+var _InternalStoreHandle_nc, _TrellisService_instances, _TrellisService_server, _TrellisService_nc, _TrellisService_handlerTrellis, _TrellisService_operationTransfer, _TrellisService_stopHealthPublishing, _TrellisService_managedJobWorkers, _TrellisService_contractJobs, _TrellisService_jobsBinding, _TrellisService_ownedOutboxDispatchers, _TrellisService_waitPromise, _TrellisService_stopPromise, _TrellisService_createHandleFacade, _TrellisService_createSqlOutboxBinding, _TrellisService_createSqlOutbox, _TrellisService_operation;
 import { headers as natsHeaders, jwtAuthenticator, } from "@nats-io/nats-core";
 import { TypedKV } from "../kv.js";
 import { TypedStore, } from "../store.js";
@@ -28,13 +28,72 @@ import { ServiceTransfer } from "./transfer.js";
 import { logger as noopLogger } from "../globals.js";
 import { DEFAULT_RUNTIME_MAX_RECONNECT_ATTEMPTS, DEFAULT_SERVICE_RUNTIME_WAIT_ON_FIRST_CONNECT, loadDefaultRuntimeTransport, selectRuntimeTransportServers, } from "../runtime_transport.js";
 import { serverLogger } from "../server_logger.js";
-import { TransportError, UnexpectedError, } from "../errors/index.js";
-import { ActiveJob as PublicActiveJob, JobRef, JobWorkerHostAdapter, } from "../jobs.js";
-import { JobManager as InternalJobManager, JobProcessError as InternalJobProcessError, } from "./internal_jobs/job-manager.js";
+import { TransportError, UnexpectedError, ValidationError, } from "../errors/index.js";
+import { ActiveJob as PublicActiveJob, JobNotEnqueuedError, JobRef, JobWorkerHostAdapter, } from "../jobs.js";
+import { ulid } from "ulid";
+import { createJobContext, JobManager as InternalJobManager, JobProcessError as InternalJobProcessError, } from "./internal_jobs/job-manager.js";
 import { startNatsWorkerHostFromBinding } from "./internal_jobs/runtime-worker.js";
+import { createNatsJobKeyCoordinator, normalizeJobKeyPolicy, } from "./internal_jobs/key-coordinator.js";
 import { JobEventSchema, } from "./internal_jobs/types.js";
 import { observeNatsTrellisConnection, } from "../connection.js";
 import { initTelemetry } from "../telemetry/init.js";
+import { recordTrellisDuration } from "../telemetry/mod.js";
+import { defaultSqlOutboxTables, OutboxDispatcher, preparedTrellisEventToOutboxRecord, SqlOutboxRepository, } from "../service/outbox_inbox.js";
+function normalizeResourceJobsBinding(binding) {
+    const queues = {};
+    for (const [name, queue] of Object.entries(binding.queues)) {
+        const baseQueue = baseJobsQueueBinding(queue);
+        if (!queue.keyConcurrency) {
+            queues[name] = {
+                ...baseQueue,
+                ...(queue.queue ? { queue: normalizeQueuePolicy(queue.queue) } : {}),
+            };
+            continue;
+        }
+        const policy = normalizeJobKeyPolicy({
+            keyConcurrency: queue.keyConcurrency,
+            queue: queue.queue,
+        });
+        queues[name] = {
+            ...baseQueue,
+            keyConcurrency: {
+                key: policy.key,
+                maxActive: policy.maxActive,
+                heartbeatIntervalMs: policy.heartbeatIntervalMs,
+                heartbeatTtlMs: policy.heartbeatTtlMs,
+                stalePolicy: policy.stalePolicy,
+            },
+            queue: policy.queue,
+        };
+    }
+    return { namespace: binding.namespace, queues };
+}
+function baseJobsQueueBinding(queue) {
+    return {
+        queueType: queue.queueType,
+        publishPrefix: queue.publishPrefix,
+        workSubject: queue.workSubject,
+        consumerName: queue.consumerName,
+        payload: queue.payload,
+        ...(queue.result ? { result: queue.result } : {}),
+        maxDeliver: queue.maxDeliver,
+        backoffMs: queue.backoffMs,
+        ackWaitMs: queue.ackWaitMs,
+        ...(queue.defaultDeadlineMs !== undefined
+            ? { defaultDeadlineMs: queue.defaultDeadlineMs }
+            : {}),
+        progress: queue.progress,
+        logs: queue.logs,
+        dlq: queue.dlq,
+        concurrency: queue.concurrency,
+    };
+}
+function normalizeQueuePolicy(queue) {
+    return {
+        maxQueuedPerKey: queue.maxQueuedPerKey ?? 0,
+        whenFull: queue.whenFull ?? "reject",
+    };
+}
 const ClientTransportEndpointsSchema = Type.Object({
     natsServers: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
 });
@@ -509,6 +568,7 @@ export async function createConnectedService(args) {
             metadata: args.contractEventConsumers,
             bindings: args.bindings.eventConsumers,
         },
+        durableEventConsumerBeforeReadinessCheck: args.durableEventConsumerBeforeReadinessCheck,
         connection,
     });
     let transfer;
@@ -534,6 +594,7 @@ export async function createConnectedService(args) {
         prepare: (event, data) => outbound.prepare(event, data),
         publish: (event, data) => outbound.publish(event, data),
         publishPrepared: (event) => outbound.publishPrepared(event),
+        stopEventListeners: () => outbound.stopEventListeners(),
         get kv() {
             return getHandlerResources().kv;
         },
@@ -637,6 +698,147 @@ function toUnexpectedError(cause) {
         ? cause
         : new UnexpectedError({ cause });
 }
+function resolveSqlOutboxTables(tables) {
+    return {
+        outbox: tables?.outbox ?? defaultSqlOutboxTables.outbox,
+        inbox: tables?.inbox ?? defaultSqlOutboxTables.inbox,
+    };
+}
+function createSqlOutboxBaseExecutor(options) {
+    return options.executor;
+}
+function createSqlOutboxTransactionRunner(options) {
+    return options.transaction;
+}
+function createSqlOutboxEventEnqueueFacade(args) {
+    const facade = {};
+    const source = args.event;
+    for (const [groupName, leaves] of Object.entries(source)) {
+        const group = {};
+        for (const [leafName, leaf] of Object.entries(leaves)) {
+            group[leafName] = {
+                enqueue: (payload) => AsyncResult.from((async () => {
+                    const prepared = leaf.prepare(payload).take();
+                    if (isErr(prepared))
+                        return Result.err(prepared.error);
+                    const record = preparedTrellisEventToOutboxRecord(prepared);
+                    try {
+                        const message = await args.repository.enqueue(record);
+                        args.onEnqueued();
+                        return Result.ok(message);
+                    }
+                    catch (cause) {
+                        return Result.err(toUnexpectedError(cause));
+                    }
+                })()),
+            };
+        }
+        Object.defineProperty(facade, groupName, {
+            value: group,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return facade;
+}
+function createSqlOutboxJobEnqueueFacade(args) {
+    const facade = {};
+    for (const queueType of Object.keys(args.contractJobs)) {
+        const queueBinding = args.jobsBinding?.queues[queueType];
+        const queue = queueType;
+        facade[queue] = {
+            create: (payload) => {
+                if (!queueBinding) {
+                    return AsyncResult.err(new ValidationError({
+                        errors: [{
+                                path: "/",
+                                message: `Jobs binding unavailable for queue '${queue}'`,
+                            }],
+                    }));
+                }
+                const submissionId = ulid();
+                const jobId = ulid();
+                const context = createJobContext();
+                const record = {
+                    id: submissionId,
+                    kind: "job.create",
+                    name: queue,
+                    subject: `${queueBinding.publishPrefix}.${jobId}.created`,
+                    payload: JSON.stringify({
+                        ...payload,
+                        jobId,
+                        submissionId,
+                    }),
+                    headers: {
+                        "request-id": context.requestId,
+                        "traceparent": context.traceparent,
+                        ...(context.tracestate ? { "tracestate": context.tracestate } : {}),
+                    },
+                };
+                return AsyncResult.from((async () => {
+                    try {
+                        await args.repository.enqueue(record);
+                        args.onEnqueued();
+                        return Result.ok({
+                            submissionId,
+                            jobId,
+                            queue,
+                            mode: "create",
+                        });
+                    }
+                    catch (cause) {
+                        return Result.err(toUnexpectedError(cause));
+                    }
+                })());
+            },
+            submit: (payload) => {
+                if (!queueBinding) {
+                    return AsyncResult.err(new ValidationError({
+                        errors: [{
+                                path: "/",
+                                message: `Jobs binding unavailable for queue '${queue}'`,
+                            }],
+                    }));
+                }
+                const submissionId = ulid();
+                const jobId = ulid();
+                const context = createJobContext();
+                const record = {
+                    id: submissionId,
+                    kind: "job.submit",
+                    name: queue,
+                    subject: `${queueBinding.publishPrefix}.${jobId}.created`,
+                    payload: JSON.stringify({
+                        ...payload,
+                        jobId,
+                        submissionId,
+                    }),
+                    headers: {
+                        "request-id": context.requestId,
+                        "traceparent": context.traceparent,
+                        ...(context.tracestate ? { "tracestate": context.tracestate } : {}),
+                    },
+                };
+                return AsyncResult.from((async () => {
+                    try {
+                        await args.repository.enqueue(record);
+                        args.onEnqueued();
+                        return Result.ok({
+                            submissionId,
+                            jobId,
+                            queue,
+                            mode: "submit",
+                        });
+                    }
+                    catch (cause) {
+                        return Result.err(toUnexpectedError(cause));
+                    }
+                })());
+            },
+        };
+    }
+    return facade;
+}
 function serializeJobHandlerError(error) {
     try {
         return JSON.stringify(error.toSerializable());
@@ -661,7 +863,8 @@ function wrapVoidTask(task) {
 }
 function isTerminalJobState(state) {
     return state === "completed" || state === "failed" || state === "cancelled" ||
-        state === "expired" || state === "dead" || state === "dismissed";
+        state === "expired" || state === "skipped" || state === "stale" ||
+        state === "dead" || state === "dismissed";
 }
 function isTerminalJobSnapshot(snapshot) {
     return isTerminalJobState(snapshot.state);
@@ -759,6 +962,9 @@ function snapshotFromLifecycleEvent(current, event) {
         case "failed":
         case "cancelled":
         case "expired":
+        case "skipped":
+        case "stale":
+        case "staleCompletionIgnored":
         case "dead":
         case "dismissed":
             return event.error === undefined ? base : {
@@ -935,17 +1141,20 @@ function createJobsFacade(args) {
     const handlers = new Map();
     const jobsFacade = {};
     const lifecycle = createJobLifecycleTracker(args.nc);
+    const keyCoordinator = createNatsJobKeyCoordinator(args.nc);
+    const jobsBinding = args.jobsBinding
+        ? normalizeResourceJobsBinding(args.jobsBinding)
+        : undefined;
     let activeHost;
     let startupPromise;
     let stopPromise;
     for (const queueType of Object.keys(args.contractJobs ?? {})) {
-        const queueBinding = args.jobsBinding?.queues[queueType];
+        const queueBinding = jobsBinding?.queues[queueType];
         if (queueBinding)
             lifecycle.watch(queueBinding);
         jobsFacade[queueType] = {
             create: (payload) => AsyncResult.from((async () => {
                 try {
-                    const jobsBinding = args.jobsBinding;
                     if (!jobsBinding) {
                         return Result.err(toUnexpectedError(new Error("Jobs bindings are unavailable")));
                     }
@@ -956,6 +1165,7 @@ function createJobsFacade(args) {
                     const manager = new InternalJobManager({
                         nc: args.nc,
                         jobs: jobsBinding,
+                        keyCoordinator,
                     });
                     await args.nc.flush();
                     const created = await manager.create(queueType, payload);
@@ -968,6 +1178,60 @@ function createJobsFacade(args) {
                         lifecycle,
                     }));
                 }
+                catch (cause) {
+                    if (cause instanceof JobNotEnqueuedError) {
+                        return Result.err(cause);
+                    }
+                    return Result.err(toUnexpectedError(cause));
+                }
+            })()),
+            submit: (payload) => AsyncResult.from((async () => {
+                try {
+                    if (!jobsBinding) {
+                        return Result.err(toUnexpectedError(new Error("Jobs bindings are unavailable")));
+                    }
+                    const queueBinding = jobsBinding.queues[queueType];
+                    if (!queueBinding) {
+                        return Result.err(toUnexpectedError(new Error(`Jobs binding for queue '${queueType}' is unavailable`)));
+                    }
+                    const manager = new InternalJobManager({
+                        nc: args.nc,
+                        jobs: jobsBinding,
+                        keyCoordinator,
+                    });
+                    await args.nc.flush();
+                    const outcome = await manager.submit(queueType, payload);
+                    if (outcome.kind === "accepted") {
+                        return Result.ok({
+                            kind: "accepted",
+                            key: outcome.key,
+                            ref: createJobRef({
+                                nc: args.nc,
+                                queueType,
+                                jobsBinding,
+                                queueBinding,
+                                seed: outcome.job,
+                                lifecycle,
+                            }),
+                        });
+                    }
+                    if (outcome.kind === "replaced") {
+                        return Result.ok({
+                            kind: "replaced",
+                            key: outcome.key,
+                            replaced: outcome.replaced,
+                            ref: createJobRef({
+                                nc: args.nc,
+                                queueType,
+                                jobsBinding,
+                                queueBinding,
+                                seed: outcome.job,
+                                lifecycle,
+                            }),
+                        });
+                    }
+                    return Result.ok(outcome);
+                }
                 catch (cause) {
                     return Result.err(toUnexpectedError(cause));
                 }
@@ -1001,10 +1265,9 @@ function createJobsFacade(args) {
                     activeHost = host;
                     return Result.ok(host);
                 }
-                if (!args.jobsBinding || !args.workStream) {
+                if (!jobsBinding || !args.workStream) {
                     return Result.err(toUnexpectedError(new Error("Jobs infrastructure bindings are unavailable for this service")));
                 }
-                const jobsBinding = args.jobsBinding;
                 const workStream = args.workStream;
                 const hosts = [];
                 try {
@@ -1020,6 +1283,7 @@ function createJobsFacade(args) {
                         const manager = new InternalJobManager({
                             nc: args.nc,
                             jobs: jobsBinding,
+                            keyCoordinator,
                         });
                         const host = await startNatsWorkerHostFromBinding({
                             jobs: jobsBinding,
@@ -1029,6 +1293,7 @@ function createJobsFacade(args) {
                             instanceId: `${args.serviceName}-worker`,
                             queueTypes: [queueType],
                             manager,
+                            heartbeatPublisher: args.nc,
                             getProjectedJob: async (job) => {
                                 return lifecycle.get({
                                     service: job.service,
@@ -1137,24 +1402,6 @@ function createJobsFacade(args) {
     });
     return jobsFacade;
 }
-function createBoundJobsFacade(args) {
-    const boundJobs = {};
-    const jobs = args.jobs;
-    for (const queueType of Object.keys(jobs)) {
-        const queue = jobs[queueType];
-        if (!queue)
-            continue;
-        boundJobs[queueType] = {
-            create: (payload) => queue.create(payload),
-            handle: (handler) => queue.handle(({ job, client }) => handler({
-                job,
-                client,
-                deps: args.deps,
-            })),
-        };
-    }
-    return boundJobs;
-}
 /**
  * Connects a service with caller-supplied runtime dependencies for tests and
  * Trellis-owned internals. This helper is intentionally not re-exported from
@@ -1164,6 +1411,7 @@ function createBoundJobsFacade(args) {
  */
 export function connectTrellisServiceWithRuntimeDeps(args, deps) {
     return AsyncResult.from((async () => {
+        const totalStartedAt = performance.now();
         try {
             const runtimeDeps = {
                 ...(await loadDefaultServiceRuntimeDeps()),
@@ -1174,6 +1422,7 @@ export function connectTrellisServiceWithRuntimeDeps(args, deps) {
             }
             const auth = await createAuth({ sessionKeySeed: args.sessionKeySeed });
             const bootstrapLog = resolveServiceLogger(args.server?.log);
+            const bootstrapStartedAt = performance.now();
             const bootstrap = await fetchServiceBootstrapInfo({
                 trellisUrl: args.trellisUrl,
                 serviceName: args.name,
@@ -1183,12 +1432,18 @@ export function connectTrellisServiceWithRuntimeDeps(args, deps) {
                 auth,
                 log: bootstrapLog,
             });
+            recordTrellisDuration("trellis.connect.duration", performance.now() - bootstrapStartedAt, {
+                phase: "bootstrap",
+                participantKind: "service",
+                outcome: "ok",
+            });
             const { authenticator: authTokenAuthenticator, inboxPrefix } = await auth
                 .natsConnectOptions({
                 contractDigest: args.contract.CONTRACT_DIGEST,
             });
             let nc;
             try {
+                const natsStartedAt = performance.now();
                 nc = await runtimeDeps.connect({
                     servers: selectRuntimeTransportServers(bootstrap.connectInfo.transports),
                     maxReconnectAttempts: DEFAULT_RUNTIME_MAX_RECONNECT_ATTEMPTS,
@@ -1199,6 +1454,11 @@ export function connectTrellisServiceWithRuntimeDeps(args, deps) {
                         jwtAuthenticator(bootstrap.connectInfo.transport.sentinel.jwt, new TextEncoder().encode(bootstrap.connectInfo.transport.sentinel.seed)),
                     ],
                 });
+                recordTrellisDuration("trellis.connect.duration", performance.now() - natsStartedAt, {
+                    phase: "nats_connect",
+                    participantKind: "service",
+                    outcome: "ok",
+                });
             }
             catch (cause) {
                 throw new TransportError({
@@ -1224,7 +1484,7 @@ export function connectTrellisServiceWithRuntimeDeps(args, deps) {
                         ...(args.server ?? {}),
                         api: args.contract.API.owned,
                     };
-                return Result.ok(await createConnectedService({
+                const service = await createConnectedService({
                     name: args.name,
                     auth,
                     nc,
@@ -1235,7 +1495,14 @@ export function connectTrellisServiceWithRuntimeDeps(args, deps) {
                     contractEventConsumers: args.contract.CONTRACT.eventConsumers,
                     server,
                     bindings: bootstrap.binding.resources,
-                }));
+                    durableEventConsumerBeforeReadinessCheck: runtimeDeps.durableEventConsumerBeforeReadinessCheck,
+                });
+                recordTrellisDuration("trellis.connect.duration", performance.now() - totalStartedAt, {
+                    phase: "total",
+                    participantKind: "service",
+                    outcome: "ok",
+                });
+                return Result.ok(service);
             }
             catch (cause) {
                 await closeFailedServiceBootstrapConnection(nc);
@@ -1312,6 +1579,9 @@ export class TrellisService {
         _TrellisService_operationTransfer.set(this, void 0);
         _TrellisService_stopHealthPublishing.set(this, void 0);
         _TrellisService_managedJobWorkers.set(this, void 0);
+        _TrellisService_contractJobs.set(this, void 0);
+        _TrellisService_jobsBinding.set(this, void 0);
+        _TrellisService_ownedOutboxDispatchers.set(this, new Set());
         _TrellisService_waitPromise.set(this, void 0);
         _TrellisService_stopPromise.set(this, void 0);
         if (token !== trellisServiceConstructorToken) {
@@ -1346,33 +1616,20 @@ export class TrellisService {
         });
         this.jobs = jobs;
         __classPrivateFieldSet(this, _TrellisService_managedJobWorkers, jobs[MANAGED_JOB_WORKERS], "f");
+        __classPrivateFieldSet(this, _TrellisService_contractJobs, contractJobs, "f");
+        __classPrivateFieldSet(this, _TrellisService_jobsBinding, bindings.jobs, "f");
         this.health = health;
         this.handle = __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_createHandleFacade).call(this);
         this.connection = connection;
         __classPrivateFieldSet(this, _TrellisService_stopHealthPublishing, stopHealthPublishing, "f");
     }
     /**
-     * Returns a service wrapper that injects application dependencies into
-     * service-owned handler argument objects as `args.deps`.
+     * Creates an explicit SQL outbox helper for service-owned transactions.
+     * Services should create this at startup and close over it in handlers.
      */
-    with(deps) {
-        return {
-            name: this.name,
-            auth: this.auth,
-            event: __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_createBoundEventFacade).call(this, deps),
-            kv: this.kv,
-            store: this.store,
-            jobs: createBoundJobsFacade({ jobs: this.jobs, deps }),
-            health: __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_createBoundHealth).call(this, deps),
-            handle: __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_createBoundHandleFacade).call(this, deps),
-            connection: this.connection,
-            createTransfer: (args) => this.createTransfer(args),
-            completeOperation: (operationId, output) => this.completeOperation(operationId, output),
-            publishPrepared: (event) => this.publishPrepared(event),
-            wait: () => this.wait(),
-            stop: () => this.stop(),
-            with: (nextDeps) => this.with(nextDeps),
-        };
+    createSqlOutbox(options) {
+        const binding = __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_createSqlOutboxBinding).call(this, options);
+        return __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_createSqlOutbox).call(this, binding);
     }
     /** Publishes a prepared event through the service runtime connection. */
     publishPrepared(event) {
@@ -1433,6 +1690,11 @@ export class TrellisService {
     async stop() {
         __classPrivateFieldSet(this, _TrellisService_stopPromise, __classPrivateFieldGet(this, _TrellisService_stopPromise, "f") ?? (async () => {
             this.connection.stopObserving();
+            __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f").stopEventListeners();
+            for (const dispatcher of __classPrivateFieldGet(this, _TrellisService_ownedOutboxDispatchers, "f")) {
+                dispatcher.stop();
+            }
+            __classPrivateFieldGet(this, _TrellisService_ownedOutboxDispatchers, "f").clear();
             try {
                 await __classPrivateFieldGet(this, _TrellisService_stopHealthPublishing, "f").call(this);
             }
@@ -1459,91 +1721,13 @@ export class TrellisService {
         await __classPrivateFieldGet(this, _TrellisService_stopPromise, "f");
     }
 }
-_TrellisService_server = new WeakMap(), _TrellisService_nc = new WeakMap(), _TrellisService_handlerTrellis = new WeakMap(), _TrellisService_operationTransfer = new WeakMap(), _TrellisService_stopHealthPublishing = new WeakMap(), _TrellisService_managedJobWorkers = new WeakMap(), _TrellisService_waitPromise = new WeakMap(), _TrellisService_stopPromise = new WeakMap(), _TrellisService_instances = new WeakSet(), _TrellisService_createBoundHealth = function _TrellisService_createBoundHealth(deps) {
-    const health = this.health;
-    return {
-        serviceName: health.serviceName,
-        kind: health.kind,
-        instanceId: health.instanceId,
-        contractId: health.contractId,
-        contractDigest: health.contractDigest,
-        startedAt: health.startedAt,
-        publishIntervalMs: health.publishIntervalMs,
-        setInfo(info) {
-            if (typeof info !== "function") {
-                health.setInfo(info);
-                return;
-            }
-            health.setInfo(() => info({ deps }));
-        },
-        add(name, check) {
-            return health.add(name, () => check({ deps }));
-        },
-        checks: () => health.checks(),
-        response: () => health.response(),
-        heartbeat: () => health.heartbeat(),
-    };
-}, _TrellisService_createBoundEventFacade = function _TrellisService_createBoundEventFacade(deps) {
-    const event = {};
-    const source = this.event;
-    for (const [groupName, leaves] of Object.entries(source)) {
-        const group = {};
-        for (const [leafName, leaf] of Object.entries(leaves)) {
-            group[leafName] = {
-                prepare: (payload) => leaf.prepare(payload),
-                publish: (payload) => leaf.publish(payload),
-                listen: (handler, subjectData, opts) => leaf.listen((payload, context) => handler({
-                    event: payload,
-                    context,
-                    client: __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f"),
-                    deps,
-                }), subjectData, opts),
-            };
-        }
-        Object.defineProperty(event, groupName, {
-            value: group,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return event;
-}, _TrellisService_createHandleFacade = function _TrellisService_createHandleFacade() {
-    const rpc = {};
-    for (const method of Object.keys(__classPrivateFieldGet(this, _TrellisService_server, "f").api.rpc ?? {})) {
-        addSurfaceLeaf(rpc, method, (handler) => __classPrivateFieldGet(this, _TrellisService_server, "f").mountRuntime(method, async ({ input, context }) => await Promise.resolve(handler({
-            input,
-            context,
-            client: __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f"),
-        }))));
-    }
-    const feed = {};
-    for (const feedName of Object.keys(__classPrivateFieldGet(this, _TrellisService_server, "f").api.feeds ?? {})) {
-        addSurfaceLeaf(feed, feedName, (handler) => __classPrivateFieldGet(this, _TrellisService_server, "f").feedHandle(feedName).handle((context) => handler({
-            ...context,
-            client: __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f"),
-        })));
-    }
-    const operation = {};
-    for (const operationName of Object.keys(__classPrivateFieldGet(this, _TrellisService_server, "f").api.operations ?? {})) {
-        const registration = __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_operation).call(this, operationName);
-        const leaf = Object.assign((handler) => registration.handle((context) => handler({
-            ...context,
-            client: __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f"),
-        })), {
-            accept: (args) => registration.accept(args),
-            control: (operationId) => registration.control(operationId),
-        });
-        addSurfaceLeaf(operation, operationName, leaf);
-    }
-    return { rpc, feed, operation };
-}, _TrellisService_createBoundHandleFacade = function _TrellisService_createBoundHandleFacade(deps) {
+_TrellisService_server = new WeakMap(), _TrellisService_nc = new WeakMap(), _TrellisService_handlerTrellis = new WeakMap(), _TrellisService_operationTransfer = new WeakMap(), _TrellisService_stopHealthPublishing = new WeakMap(), _TrellisService_managedJobWorkers = new WeakMap(), _TrellisService_contractJobs = new WeakMap(), _TrellisService_jobsBinding = new WeakMap(), _TrellisService_ownedOutboxDispatchers = new WeakMap(), _TrellisService_waitPromise = new WeakMap(), _TrellisService_stopPromise = new WeakMap(), _TrellisService_instances = new WeakSet(), _TrellisService_createHandleFacade = function _TrellisService_createHandleFacade() {
     const rpc = {};
     for (const method of Object.keys(__classPrivateFieldGet(this, _TrellisService_server, "f").api.rpc ?? {})) {
         addSurfaceLeaf(rpc, method, (handler) => __classPrivateFieldGet(this, _TrellisService_server, "f").mountRuntime(method, async ({ input, context }) => await Promise.resolve(handler({
             input,
             context,
             client: __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f"),
-            deps,
         }))));
     }
     const feed = {};
@@ -1551,7 +1735,6 @@ _TrellisService_server = new WeakMap(), _TrellisService_nc = new WeakMap(), _Tre
         addSurfaceLeaf(feed, feedName, (handler) => __classPrivateFieldGet(this, _TrellisService_server, "f").feedHandle(feedName).handle((context) => handler({
             ...context,
             client: __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f"),
-            deps,
         })));
     }
     const operation = {};
@@ -1560,7 +1743,6 @@ _TrellisService_server = new WeakMap(), _TrellisService_nc = new WeakMap(), _Tre
         const leaf = Object.assign((handler) => registration.handle((context) => handler({
             ...context,
             client: __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f"),
-            deps,
         })), {
             accept: (args) => registration.accept(args),
             control: (operationId) => registration.control(operationId),
@@ -1568,6 +1750,66 @@ _TrellisService_server = new WeakMap(), _TrellisService_nc = new WeakMap(), _Tre
         addSurfaceLeaf(operation, operationName, leaf);
     }
     return { rpc, feed, operation };
+}, _TrellisService_createSqlOutboxBinding = function _TrellisService_createSqlOutboxBinding(options) {
+    const tables = resolveSqlOutboxTables(options.tables);
+    const executor = createSqlOutboxBaseExecutor(options);
+    const repository = new SqlOutboxRepository(executor, options.dialect, tables);
+    const dispatchRuntime = {
+        publishPreparedEvent: (event) => __classPrivateFieldGet(this, _TrellisService_handlerTrellis, "f").publishPrepared(event),
+        // dispatchJobSubmission: stub — filled in by Phase 3
+    };
+    const dispatcher = new OutboxDispatcher(repository, dispatchRuntime, options.dispatcher);
+    __classPrivateFieldGet(this, _TrellisService_ownedOutboxDispatchers, "f").add(dispatcher);
+    return {
+        dialect: options.dialect,
+        tables,
+        transaction: createSqlOutboxTransactionRunner(options),
+        dispatcher,
+    };
+}, _TrellisService_createSqlOutbox = function _TrellisService_createSqlOutbox(binding) {
+    return {
+        transaction: (work) => AsyncResult.from((() => {
+            let enqueued = 0;
+            const toResultError = (cause) => {
+                if (cause instanceof ValidationError ||
+                    cause instanceof UnexpectedError) {
+                    return Result.err(cause);
+                }
+                return Result.err(toUnexpectedError(cause));
+            };
+            let transaction;
+            try {
+                transaction = binding.transaction(({ tx, executor }) => {
+                    const repository = new SqlOutboxRepository(executor, binding.dialect, binding.tables);
+                    const event = createSqlOutboxEventEnqueueFacade({
+                        event: this.event,
+                        repository,
+                        onEnqueued: () => {
+                            enqueued += 1;
+                        },
+                    });
+                    const job = createSqlOutboxJobEnqueueFacade({
+                        serviceName: this.name,
+                        contractJobs: __classPrivateFieldGet(this, _TrellisService_contractJobs, "f"),
+                        jobsBinding: __classPrivateFieldGet(this, _TrellisService_jobsBinding, "f"),
+                        repository,
+                        onEnqueued: () => {
+                            enqueued += 1;
+                        },
+                    });
+                    return work({ tx, event, job });
+                });
+            }
+            catch (cause) {
+                return Promise.resolve(toResultError(cause));
+            }
+            return transaction.then((result) => {
+                if (enqueued > 0)
+                    binding.dispatcher.notify();
+                return Result.ok(result);
+            }, toResultError);
+        })()),
+    };
 }, _TrellisService_operation = function _TrellisService_operation(operation) {
     const registration = __classPrivateFieldGet(this, _TrellisService_server, "f").operationHandle(operation);
     return {