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

package/src/server/service.ts

@@ -51,8 +51,8 @@ import { Value } from "typebox/value";
 import {
   type HealthCheckFn,
   ServiceHealth,
-  type ServiceHealthCheck,
-  type ServiceHealthInfo,
+  type ServiceHealthCheckFn,
+  type ServiceHealthInfoFn,
 } from "./health.js";
 import { mountStandardHealthRpc } from "./health_rpc.js";
 import type { EventDesc, RPCDesc } from "../contracts.js";
@@ -67,6 +67,7 @@ import type {
   FeedRegistration as RootFeedRegistration,
   HandlerTrellis,
   OperationHandlerContext,
+  OperationHandlerErrorOf,
   OperationOutputOf,
   OperationProgressOf,
   OperationRegistration as RootOperationRegistration,
@@ -105,17 +106,33 @@ import {
   ActiveJob as PublicActiveJob,
   type JobIdentity,
   type JobLogEntry,
+  JobNotEnqueuedError,
   type JobProgress,
   JobRef,
   type JobSnapshot,
+  type JobSubmitOutcome,
   JobWorkerHostAdapter,
   type TerminalJob,
 } 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 type {
+  JobKeyConcurrencyBinding,
+  JobQueuePolicyBinding,
+} from "./internal_jobs/key-coordinator.js";
+import type {
+  JobsBinding,
+  JobsQueueBinding,
+} from "./internal_jobs/bindings.js";
 import type { ActiveJob as InternalActiveJob } from "./internal_jobs/active-job.js";
 import {
   type Job as InternalJob,
@@ -128,6 +145,20 @@ import {
   type TrellisConnection,
 } from "../connection.js";
 import { initTelemetry } from "../telemetry/init.js";
+import { recordTrellisDuration } from "../telemetry/mod.js";
+import {
+  defaultSqlOutboxTables,
+  OutboxDispatcher,
+  type OutboxDispatcherOptions,
+  type OutboxDispatchRuntime,
+  type OutboxMessage,
+  type PreparedOutboxRecord,
+  preparedTrellisEventToOutboxRecord,
+  type SqlDialect,
+  type SqlExecutor,
+  SqlOutboxRepository,
+  type SqlOutboxTables,
+} from "../service/outbox_inbox.js";
 
 type ExtraNatsConnectOpts = Omit<
   NatsConnectOpts,
@@ -149,6 +180,8 @@ type ResourceBindingJobsQueue = {
   logs: boolean;
   dlq: boolean;
   concurrency: number;
+  keyConcurrency?: JobKeyConcurrencyBinding;
+  queue?: JobQueuePolicyBinding;
 };
 
 type ResourceBindingJobs = {
@@ -157,6 +190,71 @@ type ResourceBindingJobs = {
   queues: Record<string, ResourceBindingJobsQueue>;
 };
 
+function normalizeResourceJobsBinding(
+  binding: ResourceBindingJobs,
+): JobsBinding {
+  const queues: Record<string, JobsQueueBinding> = {};
+  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: ResourceBindingJobsQueue,
+): Omit<JobsQueueBinding, "keyConcurrency" | "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: JobQueuePolicyBinding,
+): JobsQueueBinding["queue"] {
+  return {
+    maxQueuedPerKey: queue.maxQueuedPerKey ?? 0,
+    whenFull: queue.whenFull ?? "reject",
+  };
+}
+
 type ResourceBindingEventConsumer = {
   stream: string;
   consumerName: string;
@@ -981,14 +1079,6 @@ type ContractKvOf<
   >,
 > = NonNullable<TContract[typeof CONTRACT_KV_METADATA]>;
 
-type ContractJobName<
-  TContract extends ServiceContract<
-    TrellisAPI,
-    TrellisAPI | undefined,
-    ContractJobsMetadata
-  >,
-> = keyof ContractJobsOf<TContract> & string;
-
 type ContractEventName<
   TContract extends ServiceContract<
     TrellisAPI,
@@ -997,14 +1087,6 @@ type ContractEventName<
   >,
 > = ServiceEventName<ContractTrellisApi<TContract>>;
 
-type ContractFeedName<
-  TContract extends ServiceContract<
-    TrellisAPI,
-    TrellisAPI | undefined,
-    ContractJobsMetadata
-  >,
-> = keyof ContractOwnedApi<TContract>["feeds"] & string;
-
 type ContractOperationName<
   TContract extends ServiceContract<
     TrellisAPI,
@@ -1013,59 +1095,6 @@ type ContractOperationName<
   >,
 > = keyof ContractOwnedApi<TContract>["operations"] & string;
 
-type ContractJobPayload<
-  TContract extends ServiceContract<
-    TrellisAPI,
-    TrellisAPI | undefined,
-    ContractJobsMetadata
-  >,
-  TJob extends ContractJobName<TContract>,
-> = ContractJobsOf<TContract>[TJob]["payload"];
-
-type ContractJobResult<
-  TContract extends ServiceContract<
-    TrellisAPI,
-    TrellisAPI | undefined,
-    ContractJobsMetadata
-  >,
-  TJob extends ContractJobName<TContract>,
-> = ContractJobsOf<TContract>[TJob]["result"];
-
-/** Arguments passed to a typed Trellis service job handler. */
-export type JobArgs<
-  TContract extends ServiceContract<
-    TrellisAPI,
-    TrellisAPI | undefined,
-    ContractJobsMetadata,
-    ContractKvMetadata
-  >,
-  TJob extends ContractJobName<TContract>,
-  TDeps = undefined,
-> = {
-  job: PublicActiveJob<
-    ContractJobPayload<TContract, TJob>,
-    ContractJobResult<TContract, TJob>
-  >;
-  client: Trellis<
-    ContractTrellisApi<TContract>,
-    ContractKvOf<TContract>,
-    ContractJobsOf<TContract>
-  >;
-} & WithDeps<TDeps>;
-
-/** Result returned by a typed Trellis service job handler. */
-export type JobResult<
-  TContract extends ServiceContract<
-    TrellisAPI,
-    TrellisAPI | undefined,
-    ContractJobsMetadata,
-    ContractKvMetadata
-  >,
-  TJob extends ContractJobName<TContract>,
-> = Result<ContractJobResult<TContract, TJob>, BaseError>;
-
-type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
-
 /** Typed RPC handler function for an extracted Trellis service handler. */
 export type RpcHandler<
   TContract extends ServiceContract<
@@ -1075,7 +1104,6 @@ export type RpcHandler<
     ContractKvMetadata
   >,
   M extends RpcMethodName<ContractOwnedApi<TContract>>,
-  TDeps = undefined,
 > = ({
   input,
   context,
@@ -1088,7 +1116,7 @@ export type RpcHandler<
     ContractKvOf<TContract>,
     ContractJobsOf<TContract>
   >;
-} & WithDeps<TDeps>) =>
+}) =>
   | Promise<
     Result<
       RpcMethodOutput<ContractOwnedApi<TContract>, M>,
@@ -1109,7 +1137,6 @@ export type ServiceEventHandler<
     ContractKvMetadata
   >,
   E extends ContractEventName<TContract>,
-  TDeps = undefined,
 > = (
   args: {
     event: ServiceEventOf<ContractTrellisApi<TContract>, E>;
@@ -1119,49 +1146,9 @@ export type ServiceEventHandler<
       ContractKvOf<TContract>,
       ContractJobsOf<TContract>
     >;
-  } & WithDeps<TDeps>,
+  },
 ) => MaybeAsync<void, BaseError>;
 
-/** Typed feed handler function for an extracted Trellis service handler. */
-export type FeedHandler<
-  TContract extends ServiceContract<
-    TrellisAPI,
-    TrellisAPI | undefined,
-    ContractJobsMetadata,
-    ContractKvMetadata
-  >,
-  F extends ContractFeedName<TContract>,
-  TDeps = undefined,
-> = (
-  context: {
-    input: FeedInputOf<ContractOwnedApi<TContract>, F>;
-    caller: unknown;
-    signal: AbortSignal;
-    emit(
-      event: FeedEventOf<ContractOwnedApi<TContract>, F>,
-    ): AsyncResult<void, ValidationError | UnexpectedError>;
-    client: Trellis<
-      ContractTrellisApi<TContract>,
-      ContractKvOf<TContract>,
-      ContractJobsOf<TContract>
-    >;
-  } & WithDeps<TDeps>,
-) => unknown | Promise<unknown>;
-
-/** Typed job handler function for an extracted Trellis service job handler. */
-export type JobHandler<
-  TContract extends ServiceContract<
-    TrellisAPI,
-    TrellisAPI | undefined,
-    ContractJobsMetadata,
-    ContractKvMetadata
-  >,
-  TJob extends ContractJobName<TContract>,
-  TDeps = undefined,
-> = (args: JobArgs<TContract, TJob, TDeps>) => Promise<
-  JobResult<TContract, TJob>
->;
-
 /** Typed operation handler function for an extracted Trellis service handler. */
 export type OperationHandler<
   TContract extends ServiceContract<
@@ -1171,14 +1158,14 @@ export type OperationHandler<
     ContractKvMetadata
   >,
   O extends ContractOperationName<TContract>,
-  TDeps = undefined,
 > = (
   args:
     & OperationHandlerContext<
       InferSchemaType<ContractOwnedApi<TContract>["operations"][O]["input"]>,
       OperationProgressOf<ContractOwnedApi<TContract>, O>,
       OperationOutputOf<ContractOwnedApi<TContract>, O>,
-      OperationTransferContextOf<ContractOwnedApi<TContract>, O>
+      OperationTransferContextOf<ContractOwnedApi<TContract>, O>,
+      OperationHandlerErrorOf<ContractOwnedApi<TContract>, O>
     >
     & {
       client: Trellis<
@@ -1186,19 +1173,14 @@ export type OperationHandler<
         ContractKvOf<TContract>,
         ContractJobsOf<TContract>
       >;
-    }
-    & WithDeps<TDeps>,
+    },
 ) => unknown | Promise<unknown>;
 
-/** Typed health info function for an extracted bound service health handler. */
-export type HealthInfoHandler<TDeps = undefined> = (
-  args: WithDeps<TDeps>,
-) => ServiceHealthInfo | undefined | Promise<ServiceHealthInfo | undefined>;
+/** Typed health info function for an extracted service health handler. */
+export type HealthInfoHandler = ServiceHealthInfoFn;
 
-/** Typed health check function for an extracted bound service health handler. */
-export type HealthCheckHandler<TDeps = undefined> = (
-  args: WithDeps<TDeps>,
-) => ServiceHealthCheck | Promise<ServiceHealthCheck>;
+/** Typed health check function for an extracted service health handler. */
+export type HealthCheckHandler = ServiceHealthCheckFn;
 
 export type JobQueue<
   TPayload,
@@ -1208,6 +1190,9 @@ export type JobQueue<
   TJobs extends ContractJobsMetadata = {},
 > = {
   create(payload: TPayload): AsyncResult<JobRef<TPayload, TResult>, BaseError>;
+  submit(
+    payload: TPayload,
+  ): AsyncResult<JobSubmitOutcome<TPayload, TResult>, BaseError>;
   handle(
     handler: (args: {
       job: PublicActiveJob<TPayload, TResult>;
@@ -1239,28 +1224,42 @@ type ServiceEventOf<
 type ServiceEventPayloadOf<
   TA extends TrellisAPI,
   E extends ServiceEventName<TA>,
-> = Omit<ServiceEventOf<TA, E>, "header">;
+> = ServiceEventOf<TA, E> & Record<string, unknown>;
+
+/** Runs SQL outbox work inside a caller-owned service database transaction. */
+export type SqlOutboxTransactionRunner<TTx> = <TResult>(
+  work: (context: { tx: TTx; executor: SqlExecutor }) =>
+    | Promise<TResult>
+    | TResult,
+) => Promise<TResult>;
+
+/** Options shared by all Trellis SQL outbox service bindings. */
+export type TrellisServiceSqlOutboxCommonOptions = {
+  /** SQL dialect used by the Trellis helper tables. */
+  readonly dialect: SqlDialect;
+  /** Optional Trellis helper-table names; omitted names use Trellis defaults. */
+  readonly tables?: Partial<SqlOutboxTables>;
+  /** Optional process-local dispatcher tuning. */
+  readonly dispatcher?: OutboxDispatcherOptions;
+};
 
-type BoundEventHandleFn<
-  TEventApi extends TrellisAPI,
-  TTrellisApi extends TrellisAPI,
-  E extends ServiceEventName<TEventApi>,
-  TKv extends ContractKvMetadata,
-  TJobs extends ContractJobsMetadata,
-  TDeps,
-> = (args: {
-  event: ServiceEventOf<TEventApi, E>;
-  context: EventListenerContext;
-  client: Trellis<TTrellisApi, TKv, TJobs>;
-  deps: TDeps;
-}) => MaybeAsync<void, BaseError>;
+/** Options for binding a Trellis service to generic caller-owned SQL storage. */
+export type TrellisServiceSqlOutboxExecutorOptions<TTx> =
+  & TrellisServiceSqlOutboxCommonOptions
+  & {
+    /** Non-transactional executor used by the process-local dispatcher. */
+    readonly executor: SqlExecutor;
+    /** Service-owned transaction runner for handler-scoped work. */
+    readonly transaction: SqlOutboxTransactionRunner<TTx>;
+  };
 
-type BoundActiveEventFacade<
-  TEventApi extends TrellisAPI,
-  TTrellisApi extends TrellisAPI,
-  TKv extends ContractKvMetadata,
-  TJobs extends ContractJobsMetadata,
-  TDeps,
+/** Options for binding a Trellis service to caller-owned SQL outbox storage. */
+export type TrellisServiceSqlOutboxOptions<TTx> =
+  TrellisServiceSqlOutboxExecutorOptions<TTx>;
+
+/** Typed transaction-scoped event facade that enqueues prepared events. */
+export type SqlOutboxEventEnqueueFacade<
+  TEventApi extends TrellisAPI = TrellisAPI,
 > = {
   readonly [TGroup in SurfaceGroupName<ServiceEventName<TEventApi>>]: {
     readonly [
@@ -1269,237 +1268,64 @@ type BoundActiveEventFacade<
         TGroup
       > as SurfaceLeafName<E>
     ]: {
-      prepare(
-        event: ServiceEventPayloadOf<TEventApi, E>,
-      ): Result<
-        PreparedTrellisEvent<ServiceEventPayloadOf<TEventApi, E>>,
-        ValidationError | UnexpectedError
-      >;
-      publish(
+      enqueue(
         event: ServiceEventPayloadOf<TEventApi, E>,
-      ): AsyncResult<void, ValidationError | UnexpectedError>;
-      listen(
-        handler: BoundEventHandleFn<
-          TEventApi,
-          TTrellisApi,
-          E,
-          TKv,
-          TJobs,
-          TDeps
-        >,
-        subjectData?: Record<string, unknown>,
-        opts?: EventOpts,
-      ): AsyncResult<void, ValidationError | UnexpectedError>;
+      ): AsyncResult<OutboxMessage, ValidationError | UnexpectedError>;
     };
   };
 };
 
-type BoundRpcHandleFn<
-  TOwnedApi extends TrellisAPI,
-  TTrellisApi extends TrellisAPI,
-  M extends RpcMethodName<TOwnedApi>,
-  TKv extends ContractKvMetadata,
-  TJobs extends ContractJobsMetadata,
-  TDeps,
-> = (args: {
-  input: RpcMethodInput<TOwnedApi, M>;
-  context: RpcHandlerContext;
-  client: Trellis<TTrellisApi, TKv, TJobs>;
-  deps: TDeps;
-}) =>
-  | Promise<
-    Result<RpcMethodOutput<TOwnedApi, M>, RpcHandlerErrorOf<TOwnedApi, M>>
-  >
-  | Result<RpcMethodOutput<TOwnedApi, M>, RpcHandlerErrorOf<TOwnedApi, M>>;
-
-type BoundFeedHandleFn<
-  TOwnedApi extends TrellisAPI,
-  TTrellisApi extends TrellisAPI,
-  F extends keyof TOwnedApi["feeds"] & string,
-  TKv extends ContractKvMetadata,
-  TJobs extends ContractJobsMetadata,
-  TDeps,
-> = (context: {
-  input: FeedInputOf<TOwnedApi, F>;
-  caller: unknown;
-  signal: AbortSignal;
-  emit(
-    event: FeedEventOf<TOwnedApi, F>,
-  ): AsyncResult<void, ValidationError | UnexpectedError>;
-  client: Trellis<TTrellisApi, TKv, TJobs>;
-  deps: TDeps;
-}) => unknown | Promise<unknown>;
-
-type BoundOperationHandleFn<
-  TOwnedApi extends TrellisAPI,
-  TTrellisApi extends TrellisAPI,
-  O extends keyof TOwnedApi["operations"] & string,
-  TKv extends ContractKvMetadata,
-  TJobs extends ContractJobsMetadata,
-  TDeps,
-> =
-  & ((
-    handler: (
-      context:
-        & OperationHandlerContext<
-          InferSchemaType<TOwnedApi["operations"][O]["input"]>,
-          OperationProgressOf<TOwnedApi, O>,
-          OperationOutputOf<TOwnedApi, O>,
-          OperationTransferContextOf<TOwnedApi, O>
-        >
-        & {
-          client: Trellis<TTrellisApi, TKv, TJobs>;
-          deps: TDeps;
-        },
-    ) => unknown | Promise<unknown>,
-  ) => Promise<void>)
-  & Pick<
-    OperationHandleFn<TOwnedApi, TTrellisApi, O, TKv, TJobs>,
-    "accept" | "control"
-  >;
+/** Returned by outbox.job.<queue>.create/submit inside a transaction. */
+export type SqlOutboxJobSubmission = {
+  readonly submissionId: string;
+  readonly jobId: string;
+  readonly queue: string;
+  readonly mode: "create" | "submit";
+};
 
-type BoundTypedServiceHandleFacade<
-  TOwnedApi extends TrellisAPI,
-  TTrellisApi extends TrellisAPI,
-  TKv extends ContractKvMetadata,
-  TJobs extends ContractJobsMetadata,
-  TDeps,
-> = {
-  readonly rpc: {
-    readonly [TGroup in SurfaceGroupName<RpcMethodName<TOwnedApi>>]: {
-      readonly [
-        M in SurfaceKeysForGroup<
-          RpcMethodName<TOwnedApi>,
-          TGroup
-        > as SurfaceLeafName<M>
-      ]: (
-        handler: BoundRpcHandleFn<TOwnedApi, TTrellisApi, M, TKv, TJobs, TDeps>,
-      ) => Promise<void>;
-    };
-  };
-  readonly feed: {
-    readonly [TGroup in SurfaceGroupName<keyof TOwnedApi["feeds"] & string>]: {
-      readonly [
-        F in SurfaceKeysForGroup<
-          keyof TOwnedApi["feeds"] & string,
-          TGroup
-        > as SurfaceLeafName<F>
-      ]: (
-        handler: BoundFeedHandleFn<
-          TOwnedApi,
-          TTrellisApi,
-          F,
-          TKv,
-          TJobs,
-          TDeps
-        >,
-      ) => Promise<void>;
-    };
-  };
-  readonly operation: {
-    readonly [
-      TGroup in SurfaceGroupName<keyof TOwnedApi["operations"] & string>
-    ]: {
-      readonly [
-        O in SurfaceKeysForGroup<
-          keyof TOwnedApi["operations"] & string,
-          TGroup
-        > as SurfaceLeafName<O>
-      ]: BoundOperationHandleFn<TOwnedApi, TTrellisApi, O, TKv, TJobs, TDeps>;
-    };
+/** Transaction-scoped facade for enqueuing job creation/submission intents. */
+export type SqlOutboxJobEnqueueFacade<TJobs extends ContractJobsMetadata> = {
+  readonly [K in keyof TJobs]: {
+    create(
+      payload: TJobs[K]["payload"],
+    ): AsyncResult<SqlOutboxJobSubmission, ValidationError | UnexpectedError>;
+    submit(
+      payload: TJobs[K]["payload"],
+    ): AsyncResult<SqlOutboxJobSubmission, ValidationError | UnexpectedError>;
   };
 };
 
-type BoundJobQueue<
-  TPayload,
-  TResult,
-  TTrellisApi extends TrellisAPI,
-  TKv extends ContractKvMetadata,
-  TJobs extends ContractJobsMetadata,
-  TDeps,
+/** Context supplied to `outbox.transaction(...)` work callbacks. */
+export type SqlOutboxTransactionContext<
+  TTx,
+  TEventApi extends TrellisAPI = TrellisAPI,
+  TJobs extends ContractJobsMetadata = ContractJobsMetadata,
 > = {
-  create(payload: TPayload): AsyncResult<JobRef<TPayload, TResult>, BaseError>;
-  handle(
-    handler: (args: {
-      job: PublicActiveJob<TPayload, TResult>;
-      client: Trellis<TTrellisApi, TKv, TJobs>;
-      deps: TDeps;
-    }) => Promise<Result<TResult, BaseError>>,
-  ): void;
+  /** Service-owned transaction object supplied by the configured runner. */
+  readonly tx: TTx;
+  /** Transaction-scoped typed event enqueue facade. */
+  readonly event: SqlOutboxEventEnqueueFacade<TEventApi>;
+  /** Transaction-scoped typed job enqueue facade. */
+  readonly job: SqlOutboxJobEnqueueFacade<TJobs>;
 };
 
-type BoundJobsFacadeOf<
-  TJobs extends ContractJobsMetadata,
-  TTrellisApi extends TrellisAPI,
-  TKv extends ContractKvMetadata,
-  TDeps,
+/** Startup-created SQL outbox dependency for transactional event/job enqueue. */
+export type SqlOutbox<
+  TTx,
+  TEventApi extends TrellisAPI = TrellisAPI,
+  TJobs extends ContractJobsMetadata = ContractJobsMetadata,
 > = {
-  [K in keyof TJobs]: BoundJobQueue<
-    TJobs[K]["payload"],
-    TJobs[K]["result"],
-    TTrellisApi,
-    TKv,
-    TJobs,
-    TDeps
-  >;
-};
-
-type BoundServiceHealth<TDeps> = Omit<ServiceHealth, "add" | "setInfo"> & {
-  setInfo(info: ServiceHealthInfo | HealthInfoHandler<TDeps>): void;
-  add(
-    name: string,
-    check: HealthCheckHandler<TDeps>,
-  ): () => void;
+  /**
+   * Runs service DB work and typed event/job enqueue operations in one SQL
+   * transaction, notifying the dispatcher once after a successful commit.
+   */
+  transaction<TResult>(
+    work: (context: SqlOutboxTransactionContext<TTx, TEventApi, TJobs>) =>
+      | Promise<TResult>
+      | TResult,
+  ): AsyncResult<TResult, ValidationError | UnexpectedError>;
 };
 
-/** Service wrapper returned by `TrellisService.with(deps)`. */
-export type BoundTrellisService<
-  TOwnedApi extends TrellisAPI = TrellisAPI,
-  TTrellisApi extends TrellisAPI = TOwnedApi,
-  TJobs extends ContractJobsMetadata = {},
-  TKv extends ContractKvMetadata = ContractKvMetadata,
-  TDeps = unknown,
-> =
-  & Pick<
-    TrellisService<TOwnedApi, TTrellisApi, TJobs, TKv>,
-    | "name"
-    | "auth"
-    | "kv"
-    | "store"
-    | "connection"
-    | "createTransfer"
-    | "completeOperation"
-    | "publishPrepared"
-    | "wait"
-    | "stop"
-  >
-  & {
-    readonly event: BoundActiveEventFacade<
-      TTrellisApi,
-      TTrellisApi,
-      TKv,
-      TJobs,
-      TDeps
-    >;
-    readonly health: BoundServiceHealth<TDeps>;
-    readonly jobs: BoundJobsFacadeOf<TJobs, TTrellisApi, TKv, TDeps>;
-    readonly handle: BoundTypedServiceHandleFacade<
-      TOwnedApi,
-      TTrellisApi,
-      TKv,
-      TJobs,
-      TDeps
-    >;
-    /** Returns a new bound wrapper that injects the provided dependencies. */
-    with<TNextDeps>(deps: TNextDeps): BoundTrellisService<
-      TOwnedApi,
-      TTrellisApi,
-      TJobs,
-      TKv,
-      TNextDeps
-    >;
-  };
-
 const MANAGED_JOB_WORKERS = Symbol("trellis.managedJobWorkers");
 
 type ManagedJobWorkers = {
@@ -1520,10 +1346,16 @@ type ServiceHandleOperationLeaf =
   & {
     accept(
       args: { sessionKey: string },
-    ): AsyncResult<AcceptedOperation, UnexpectedError>;
+    ): AsyncResult<
+      AcceptedOperation<unknown, unknown, BaseError>,
+      UnexpectedError
+    >;
     control(
       operationId: string,
-    ): AsyncResult<OperationRuntimeHandle, BaseError>;
+    ): AsyncResult<
+      OperationRuntimeHandle<unknown, unknown, BaseError>,
+      BaseError
+    >;
   };
 
 type ServiceHandleFacade = {
@@ -1561,19 +1393,6 @@ type ServiceEventLeaf = ServiceEventPublishLeaf & {
   ): AsyncResult<void, ValidationError | UnexpectedError>;
 };
 
-type BoundServiceEventLeaf<TDeps> = ServiceEventPublishLeaf & {
-  listen(
-    handler: (args: {
-      event: unknown;
-      context: EventListenerContext;
-      client: unknown;
-      deps: TDeps;
-    }) => MaybeAsync<void, BaseError>,
-    subjectData?: Record<string, unknown>,
-    opts?: EventOpts,
-  ): AsyncResult<void, ValidationError | UnexpectedError>;
-};
-
 function createServiceEventPublishFacade<TA extends TrellisAPI>(outbound: {
   readonly api: TA;
   prepare(
@@ -1708,7 +1527,8 @@ type OperationHandleFn<
           InferSchemaType<TOwnedApi["operations"][O]["input"]>,
           OperationProgressOf<TOwnedApi, O>,
           OperationOutputOf<TOwnedApi, O>,
-          OperationTransferContextOf<TOwnedApi, O>
+          OperationTransferContextOf<TOwnedApi, O>,
+          OperationHandlerErrorOf<TOwnedApi, O>
         >
         & { client: Trellis<TTrellisApi, TKv, TJobs> },
     ) => unknown | Promise<unknown>,
@@ -1717,14 +1537,16 @@ type OperationHandleFn<
     accept(args: { sessionKey: string }): AsyncResult<
       AcceptedOperation<
         OperationProgressOf<TOwnedApi, O>,
-        OperationOutputOf<TOwnedApi, O>
+        OperationOutputOf<TOwnedApi, O>,
+        OperationHandlerErrorOf<TOwnedApi, O>
       >,
       UnexpectedError
     >;
     control(operationId: string): AsyncResult<
       OperationRuntimeHandle<
         OperationProgressOf<TOwnedApi, O>,
-        OperationOutputOf<TOwnedApi, O>
+        OperationOutputOf<TOwnedApi, O>,
+        OperationHandlerErrorOf<TOwnedApi, O>
       >,
       BaseError
     >;
@@ -1742,7 +1564,8 @@ export type OperationRegistration<
   }): AsyncResult<
     AcceptedOperation<
       OperationProgressOf<TOwnedApi, O>,
-      OperationOutputOf<TOwnedApi, O>
+      OperationOutputOf<TOwnedApi, O>,
+      OperationHandlerErrorOf<TOwnedApi, O>
     >,
     UnexpectedError
   >;
@@ -1755,7 +1578,8 @@ export type OperationRegistration<
   ): AsyncResult<
     OperationRuntimeHandle<
       OperationProgressOf<TOwnedApi, O>,
-      OperationOutputOf<TOwnedApi, O>
+      OperationOutputOf<TOwnedApi, O>,
+      OperationHandlerErrorOf<TOwnedApi, O>
     >,
     BaseError
   >;
@@ -1766,7 +1590,8 @@ export type OperationRegistration<
           InferSchemaType<TOwnedApi["operations"][O]["input"]>,
           OperationProgressOf<TOwnedApi, O>,
           OperationOutputOf<TOwnedApi, O>,
-          OperationTransferContextOf<TOwnedApi, O>
+          OperationTransferContextOf<TOwnedApi, O>,
+          OperationHandlerErrorOf<TOwnedApi, O>
         >
         & { client: Trellis<TTrellisApi, TKv, TJobs> },
     ) => unknown | Promise<unknown>,
@@ -1827,6 +1652,9 @@ export async function createConnectedService<
   contractEventConsumers?: ContractEventConsumers;
   server: TrellisServiceRuntimeCreateOpts<TOwnedApi, TTrellisApi>;
   bindings: ResourceBindings;
+  durableEventConsumerBeforeReadinessCheck?: TrellisServiceRuntimeDeps[
+    "durableEventConsumerBeforeReadinessCheck"
+  ];
 }): Promise<TrellisService<TOwnedApi, TTrellisApi, TJobs, TKv>> {
   const resolvedLog = resolveServiceLogger(args.server.log);
   const connection = observeNatsTrellisConnection({
@@ -1886,6 +1714,8 @@ export async function createConnectedService<
         metadata: args.contractEventConsumers,
         bindings: args.bindings.eventConsumers,
       },
+      durableEventConsumerBeforeReadinessCheck:
+        args.durableEventConsumerBeforeReadinessCheck,
       connection,
     },
   );
@@ -1922,6 +1752,7 @@ export async function createConnectedService<
     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;
     },
@@ -2054,6 +1885,190 @@ function toUnexpectedError(cause: unknown): UnexpectedError {
     : new UnexpectedError({ cause });
 }
 
+function resolveSqlOutboxTables(
+  tables: Partial<SqlOutboxTables> | undefined,
+): SqlOutboxTables {
+  return {
+    outbox: tables?.outbox ?? defaultSqlOutboxTables.outbox,
+    inbox: tables?.inbox ?? defaultSqlOutboxTables.inbox,
+  };
+}
+
+function createSqlOutboxBaseExecutor<TTx>(
+  options: TrellisServiceSqlOutboxOptions<TTx>,
+): SqlExecutor {
+  return options.executor;
+}
+
+function createSqlOutboxTransactionRunner<TTx>(
+  options: TrellisServiceSqlOutboxOptions<TTx>,
+): SqlOutboxTransactionRunner<TTx> {
+  return options.transaction;
+}
+
+type SqlOutboxEventEnqueueLeaf = {
+  enqueue(
+    event: Record<string, unknown>,
+  ): AsyncResult<OutboxMessage, ValidationError | UnexpectedError>;
+};
+
+function createSqlOutboxEventEnqueueFacade<TEventApi extends TrellisAPI>(args: {
+  event: ActiveEventFacade<TEventApi>;
+  repository: SqlOutboxRepository;
+  onEnqueued(): void;
+}): SqlOutboxEventEnqueueFacade<TEventApi> {
+  const facade: Record<string, Record<string, SqlOutboxEventEnqueueLeaf>> = {};
+  const source = args.event as Record<
+    string,
+    Record<string, ServiceEventLeaf>
+  >;
+
+  for (const [groupName, leaves] of Object.entries(source)) {
+    const group: Record<string, SqlOutboxEventEnqueueLeaf> = {};
+    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 as SqlOutboxEventEnqueueFacade<TEventApi>;
+}
+
+function createSqlOutboxJobEnqueueFacade<TJobs extends ContractJobsMetadata>(
+  args: {
+    serviceName: string;
+    contractJobs: TJobs;
+    jobsBinding?: ResourceBindingJobs;
+    repository: SqlOutboxRepository;
+    onEnqueued(): void;
+  },
+): SqlOutboxJobEnqueueFacade<TJobs> {
+  const facade: Record<string, Record<string, unknown>> = {};
+
+  for (
+    const queueType of Object.keys(args.contractJobs as Record<string, unknown>)
+  ) {
+    const queueBinding = args.jobsBinding?.queues[queueType];
+    const queue = queueType;
+    facade[queue] = {
+      create: (payload: unknown) => {
+        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: PreparedOutboxRecord = {
+          id: submissionId,
+          kind: "job.create",
+          name: queue,
+          subject: `${queueBinding.publishPrefix}.${jobId}.created`,
+          payload: JSON.stringify({
+            ...(payload as Record<string, unknown>),
+            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: unknown) => {
+        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: PreparedOutboxRecord = {
+          id: submissionId,
+          kind: "job.submit",
+          name: queue,
+          subject: `${queueBinding.publishPrefix}.${jobId}.created`,
+          payload: JSON.stringify({
+            ...(payload as Record<string, unknown>),
+            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 as SqlOutboxJobEnqueueFacade<TJobs>;
+}
+
 function serializeJobHandlerError(error: BaseError): string {
   try {
     return JSON.stringify(error.toSerializable());
@@ -2081,7 +2096,8 @@ function isTerminalJobState(
   state: string,
 ): state is TerminalJob<unknown, unknown>["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<TPayload, TResult>(
@@ -2202,6 +2218,9 @@ function snapshotFromLifecycleEvent<TPayload, TResult>(
     case "failed":
     case "cancelled":
     case "expired":
+    case "skipped":
+    case "stale":
+    case "staleCompletionIgnored":
     case "dead":
     case "dismissed":
       return event.error === undefined ? base : {
@@ -2359,8 +2378,8 @@ function createJobLifecycleTracker(nc: NatsConnection): JobLifecycleTracker {
 function createJobRef<TPayload, TResult>(args: {
   nc: NatsConnection;
   queueType: string;
-  jobsBinding: ResourceBindingJobs;
-  queueBinding: ResourceBindingJobsQueue;
+  jobsBinding: JobsBinding;
+  queueBinding: JobsQueueBinding;
   seed: JobSnapshot<TPayload, TResult>;
   lifecycle: JobLifecycleTracker;
 }): JobRef<TPayload, TResult> {
@@ -2467,6 +2486,10 @@ function createJobsFacade<
   const handlers = new Map<string, RegisteredJobHandler<unknown, unknown>>();
   const jobsFacade: Record<string, unknown> = {};
   const lifecycle = createJobLifecycleTracker(args.nc);
+  const keyCoordinator = createNatsJobKeyCoordinator(args.nc);
+  const jobsBinding = args.jobsBinding
+    ? normalizeResourceJobsBinding(args.jobsBinding)
+    : undefined;
   let activeHost: JobWorkerHostAdapter | undefined;
   let startupPromise:
     | Promise<Result<JobWorkerHostAdapter, BaseError>>
@@ -2474,14 +2497,13 @@ function createJobsFacade<
   let stopPromise: Promise<Result<void, BaseError>> | undefined;
 
   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")),
@@ -2499,6 +2521,7 @@ function createJobsFacade<
             const manager = new InternalJobManager<unknown, unknown>({
               nc: args.nc,
               jobs: jobsBinding,
+              keyCoordinator,
             });
             await args.nc.flush();
             const created = await manager.create(queueType, payload);
@@ -2510,6 +2533,67 @@ function createJobsFacade<
               seed: created as JobSnapshot<unknown, unknown>,
               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<unknown, unknown>({
+              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 as JobSnapshot<unknown, unknown>,
+                  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 as JobSnapshot<unknown, unknown>,
+                  lifecycle,
+                }),
+              });
+            }
+            return Result.ok(outcome);
           } catch (cause) {
             return Result.err(toUnexpectedError(cause));
           }
@@ -2554,7 +2638,7 @@ function createJobsFacade<
           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",
@@ -2562,7 +2646,6 @@ function createJobsFacade<
           ));
         }
 
-        const jobsBinding = args.jobsBinding;
         const workStream = args.workStream;
 
         const hosts = [] as Array<{ stop(): Promise<void> }>;
@@ -2582,6 +2665,7 @@ function createJobsFacade<
             const manager = new InternalJobManager<unknown, unknown>({
               nc: args.nc,
               jobs: jobsBinding,
+              keyCoordinator,
             });
             const host = await startNatsWorkerHostFromBinding<unknown>({
               jobs: jobsBinding,
@@ -2591,6 +2675,7 @@ function createJobsFacade<
               instanceId: `${args.serviceName}-worker`,
               queueTypes: [queueType],
               manager,
+              heartbeatPublisher: args.nc,
               getProjectedJob: async (job) => {
                 return lifecycle.get({
                   service: job.service,
@@ -2730,47 +2815,6 @@ function createJobsFacade<
   return jobsFacade as ManagedJobsFacade<TJobs, TTrellisApi, TKv>;
 }
 
-function createBoundJobsFacade<
-  TJobs extends ContractJobsMetadata,
-  TTrellisApi extends TrellisAPI,
-  TKv extends ContractKvMetadata,
-  TDeps,
->(args: {
-  jobs: JobsFacadeOf<TJobs, TTrellisApi, TKv>;
-  deps: TDeps;
-}): BoundJobsFacadeOf<TJobs, TTrellisApi, TKv, TDeps> {
-  const boundJobs: Record<string, unknown> = {};
-  const jobs = args.jobs as Record<
-    string,
-    JobQueue<unknown, unknown, TTrellisApi, TKv, TJobs>
-  >;
-
-  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,
-          })
-        ),
-    } satisfies BoundJobQueue<
-      unknown,
-      unknown,
-      TTrellisApi,
-      TKv,
-      TJobs,
-      TDeps
-    >;
-  }
-
-  return boundJobs as BoundJobsFacadeOf<TJobs, TTrellisApi, TKv, TDeps>;
-}
-
 /**
  * Connects a service with caller-supplied runtime dependencies for tests and
  * Trellis-owned internals. This helper is intentionally not re-exported from
@@ -2798,6 +2842,7 @@ export function connectTrellisServiceWithRuntimeDeps<
   TransportError | UnexpectedError
 > {
   return AsyncResult.from((async () => {
+    const totalStartedAt = performance.now();
     try {
       type TOwnedApi = ContractOwnedApi<TContract>;
       type TTrellisApi = ContractTrellisApi<TContract>;
@@ -2811,6 +2856,7 @@ export function connectTrellisServiceWithRuntimeDeps<
       }
       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,
@@ -2820,6 +2866,15 @@ export function connectTrellisServiceWithRuntimeDeps<
         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,
@@ -2827,6 +2882,7 @@ export function connectTrellisServiceWithRuntimeDeps<
 
       let nc: NatsConnection;
       try {
+        const natsStartedAt = performance.now();
         nc = await runtimeDeps.connect({
           servers: selectRuntimeTransportServers(
             bootstrap.connectInfo.transports,
@@ -2844,6 +2900,15 @@ export function connectTrellisServiceWithRuntimeDeps<
             ),
           ],
         });
+        recordTrellisDuration(
+          "trellis.connect.duration",
+          performance.now() - natsStartedAt,
+          {
+            phase: "nats_connect",
+            participantKind: "service",
+            outcome: "ok",
+          },
+        );
       } catch (cause) {
         throw new TransportError({
           code: "trellis.runtime.connect_failed",
@@ -2871,31 +2936,41 @@ export function connectTrellisServiceWithRuntimeDeps<
             api: args.contract.API.owned,
           };
 
-        return Result.ok(
-          await createConnectedService<
-            TOwnedApi,
-            TTrellisApi,
-            ContractJobsOf<TContract>,
-            ContractKvOf<TContract>
-          >({
-            name: args.name,
-            auth,
-            nc,
-            contractId: args.contract.CONTRACT_ID,
-            contractDigest: args.contract.CONTRACT_DIGEST,
-            contractJobs:
-              (args.contract[CONTRACT_JOBS_METADATA] ?? {}) as ContractJobsOf<
-                TContract
-              >,
-            contractKv:
-              (args.contract[CONTRACT_KV_METADATA] ?? {}) as ContractKvOf<
-                TContract
-              >,
-            contractEventConsumers: args.contract.CONTRACT.eventConsumers,
-            server,
-            bindings: bootstrap.binding.resources,
-          }),
+        const service = await createConnectedService<
+          TOwnedApi,
+          TTrellisApi,
+          ContractJobsOf<TContract>,
+          ContractKvOf<TContract>
+        >({
+          name: args.name,
+          auth,
+          nc,
+          contractId: args.contract.CONTRACT_ID,
+          contractDigest: args.contract.CONTRACT_DIGEST,
+          contractJobs:
+            (args.contract[CONTRACT_JOBS_METADATA] ?? {}) as ContractJobsOf<
+              TContract
+            >,
+          contractKv:
+            (args.contract[CONTRACT_KV_METADATA] ?? {}) as ContractKvOf<
+              TContract
+            >,
+          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);
         throw cause;
@@ -2931,6 +3006,9 @@ export class TrellisService<
   readonly #operationTransfer: ServiceTransfer;
   readonly #stopHealthPublishing: () => Promise<void>;
   readonly #managedJobWorkers: ManagedJobWorkers;
+  readonly #contractJobs: TJobs;
+  readonly #jobsBinding?: ResourceBindingJobs;
+  readonly #ownedOutboxDispatchers = new Set<OutboxDispatcher>();
   #waitPromise?: Promise<void>;
   #stopPromise?: Promise<void>;
 
@@ -2987,6 +3065,8 @@ export class TrellisService<
     });
     this.jobs = jobs;
     this.#managedJobWorkers = jobs[MANAGED_JOB_WORKERS];
+    this.#contractJobs = contractJobs;
+    this.#jobsBinding = bindings.jobs;
     this.health = health;
     this.handle = this.#createHandleFacade() as TypedServiceHandleFacade<
       TOwnedApi,
@@ -2999,30 +3079,14 @@ export class TrellisService<
   }
 
   /**
-   * 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<TDeps>(
-    deps: TDeps,
-  ): BoundTrellisService<TOwnedApi, TTrellisApi, TJobs, TKv, TDeps> {
-    return {
-      name: this.name,
-      auth: this.auth,
-      event: this.#createBoundEventFacade(deps),
-      kv: this.kv,
-      store: this.store,
-      jobs: createBoundJobsFacade({ jobs: this.jobs, deps }),
-      health: this.#createBoundHealth(deps),
-      handle: this.#createBoundHandleFacade(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<TTx>(
+    options: TrellisServiceSqlOutboxExecutorOptions<TTx>,
+  ): SqlOutbox<TTx, TTrellisApi, TJobs> {
+    const binding = this.#createSqlOutboxBinding(options);
+    return this.#createSqlOutbox(binding);
   }
 
   /** Publishes a prepared event through the service runtime connection. */
@@ -3032,77 +3096,6 @@ export class TrellisService<
     return this.#handlerTrellis.publishPrepared(event);
   }
 
-  #createBoundHealth<TDeps>(deps: TDeps): BoundServiceHealth<TDeps> {
-    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(),
-    };
-  }
-
-  #createBoundEventFacade<TDeps>(
-    deps: TDeps,
-  ): BoundActiveEventFacade<TTrellisApi, TTrellisApi, TKv, TJobs, TDeps> {
-    const event = {} as BoundActiveEventFacade<
-      TTrellisApi,
-      TTrellisApi,
-      TKv,
-      TJobs,
-      TDeps
-    >;
-    const source = this.event as Record<
-      string,
-      Record<string, ServiceEventLeaf>
-    >;
-    for (const [groupName, leaves] of Object.entries(source)) {
-      const group: Record<string, BoundServiceEventLeaf<TDeps>> = {};
-      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: this.#handlerTrellis,
-                  deps,
-                }),
-              subjectData,
-              opts,
-            ),
-        };
-      }
-      Object.defineProperty(event, groupName, {
-        value: group,
-        enumerable: true,
-        configurable: true,
-      });
-    }
-
-    return event;
-  }
-
   #createHandleFacade(): ServiceHandleFacade {
     const rpc: ServiceHandleFacade["rpc"] = {};
     for (const method of Object.keys(this.#server.api.rpc ?? {})) {
@@ -3168,80 +3161,100 @@ export class TrellisService<
     return { rpc, feed, operation };
   }
 
-  #createBoundHandleFacade<TDeps>(
-    deps: TDeps,
-  ): BoundTypedServiceHandleFacade<TOwnedApi, TTrellisApi, TKv, TJobs, TDeps> {
-    const rpc: ServiceHandleFacade["rpc"] = {};
-    for (const method of Object.keys(this.#server.api.rpc ?? {})) {
-      addSurfaceLeaf(rpc, method, (handler) =>
-        this.#server.mountRuntime(
-          method,
-          async ({ input, context }) =>
-            await Promise.resolve(
-              (handler as (
-                args: unknown,
-              ) =>
-                | Promise<Result<unknown, BaseError>>
-                | Result<unknown, BaseError>)({
-                  input,
-                  context,
-                  client: this.#handlerTrellis,
-                  deps,
-                }),
-            ),
-        ));
-    }
-
-    const feed: ServiceHandleFacade["feed"] = {};
-    for (const feedName of Object.keys(this.#server.api.feeds ?? {})) {
-      addSurfaceLeaf(
-        feed,
-        feedName,
-        (handler) =>
-          this.#server.feedHandle(feedName).handle((context) =>
-            (handler as (args: unknown) => unknown | Promise<unknown>)({
-              ...context,
-              client: this.#handlerTrellis,
-              deps,
-            })
-          ),
-      );
-    }
-
-    const operation: Record<
-      string,
-      Record<string, ServiceHandleOperationLeaf>
-    > = {};
-    for (
-      const operationName of Object.keys(this.#server.api.operations ?? {})
-    ) {
-      const registration = this.#operation(
-        operationName as keyof TOwnedApi["operations"] & string,
-      );
-      const leaf = Object.assign(
-        (handler: (context: unknown) => unknown) =>
-          registration.handle((context) =>
-            handler({
-              ...context,
-              client: this.#handlerTrellis,
-              deps,
-            })
-          ),
-        {
-          accept: (args: { sessionKey: string }) => registration.accept(args),
-          control: (operationId: string) => registration.control(operationId),
-        },
-      ) as ServiceHandleOperationLeaf;
-      addSurfaceLeaf(operation, operationName, leaf);
-    }
+  #createSqlOutboxBinding<TTx>(
+    options: TrellisServiceSqlOutboxOptions<TTx>,
+  ): {
+    readonly dialect: SqlDialect;
+    readonly tables: SqlOutboxTables;
+    readonly transaction: SqlOutboxTransactionRunner<TTx>;
+    readonly dispatcher: OutboxDispatcher;
+  } {
+    const tables = resolveSqlOutboxTables(options.tables);
+    const executor = createSqlOutboxBaseExecutor(options);
+    const repository = new SqlOutboxRepository(
+      executor,
+      options.dialect,
+      tables,
+    );
+    const dispatchRuntime: OutboxDispatchRuntime = {
+      publishPreparedEvent: (event) =>
+        this.#handlerTrellis.publishPrepared(event),
+      // dispatchJobSubmission: stub — filled in by Phase 3
+    };
+    const dispatcher = new OutboxDispatcher(
+      repository,
+      dispatchRuntime,
+      options.dispatcher,
+    );
+    this.#ownedOutboxDispatchers.add(dispatcher);
+    return {
+      dialect: options.dialect,
+      tables,
+      transaction: createSqlOutboxTransactionRunner(options),
+      dispatcher,
+    };
+  }
 
-    return { rpc, feed, operation } as BoundTypedServiceHandleFacade<
-      TOwnedApi,
-      TTrellisApi,
-      TKv,
-      TJobs,
-      TDeps
-    >;
+  #createSqlOutbox<TTx>(binding: {
+    readonly dialect: SqlDialect;
+    readonly tables: SqlOutboxTables;
+    readonly transaction: SqlOutboxTransactionRunner<TTx>;
+    readonly dispatcher: OutboxDispatcher;
+  }): SqlOutbox<TTx, TTrellisApi, TJobs> {
+    return {
+      transaction: <TResult>(
+        work: (
+          context: SqlOutboxTransactionContext<TTx, TTrellisApi, TJobs>,
+        ) => Promise<TResult> | TResult,
+      ) =>
+        AsyncResult.from((() => {
+          let enqueued = 0;
+          const toResultError = (
+            cause: unknown,
+          ): Result<TResult, ValidationError | UnexpectedError> => {
+            if (
+              cause instanceof ValidationError ||
+              cause instanceof UnexpectedError
+            ) {
+              return Result.err(cause);
+            }
+            return Result.err(toUnexpectedError(cause));
+          };
+          let transaction: Promise<TResult>;
+          try {
+            transaction = binding.transaction<TResult>(({ 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: this.#contractJobs,
+                jobsBinding: this.#jobsBinding,
+                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);
+        })()),
+    };
   }
 
   /**
@@ -3339,6 +3352,11 @@ export class TrellisService<
   async stop(): Promise<void> {
     this.#stopPromise ??= (async () => {
       this.connection.stopObserving();
+      this.#handlerTrellis.stopEventListeners();
+      for (const dispatcher of this.#ownedOutboxDispatchers) {
+        dispatcher.stop();
+      }
+      this.#ownedOutboxDispatchers.clear();
 
       try {
         await this.#stopHealthPublishing();
@@ -3373,7 +3391,8 @@ export class TrellisService<
       InferSchemaType<TOwnedApi["operations"][O]["input"]>,
       OperationProgressOf<TOwnedApi, O>,
       OperationOutputOf<TOwnedApi, O>,
-      OperationTransferContextOf<TOwnedApi, O>
+      OperationTransferContextOf<TOwnedApi, O>,
+      BaseError
     >;
 
     return {
@@ -3386,7 +3405,8 @@ export class TrellisService<
               InferSchemaType<TOwnedApi["operations"][O]["input"]>,
               OperationProgressOf<TOwnedApi, O>,
               OperationOutputOf<TOwnedApi, O>,
-              OperationTransferContextOf<TOwnedApi, O>
+              OperationTransferContextOf<TOwnedApi, O>,
+              BaseError
             >
             & { client: Trellis<TTrellisApi, TKv, TJobs> },
         ) => unknown | Promise<unknown>,