@abloatai/transaction 0.57.0 → 0.58.0

package/src/source/adapters/prisma.ts

@@ -20,18 +20,19 @@ import type {
   AdapterReadRequest,
   DataSourceAdapter,
   Row,
-} from '../adapter.js';
-import { defineDatabaseAdapter } from '../adapterFactory.js';
-import { postgresAdapterProfile } from '../adapterProfile.js';
-import type { ChangeSet, EventsPage, Migration, Operation, OutboxEvent } from '../contract.js';
-import { outboxEventSchema } from '../contract.js';
-import { adapterTableMigrations } from '../migrations.js';
+} from './adapter.js';
+import { defineDatabaseAdapter } from './adapterFactory.js';
+import { postgresAdapterProfile } from './adapterProfile.js';
+import type { ChangeSet, Operation } from './contract.js';
+import type { Migration } from './migration.js';
+import type { EventsPage, OutboxEvent } from '../outbox/index.js';
+import { adapterTableMigrations } from './migrations.js';
 import {
   assertSourceIdempotencyIntent,
   assertSourceIdempotencyRetention,
   SOURCE_IDEMPOTENCY_RETENTION,
   sourceChangeIntentHash,
-} from '../idempotency.js';
+} from './idempotency.js';
 import type { SchemaRecord, Schema } from '../../schema/schema.js';
 import { toSchemaJSON } from '../../schema/serialize.js';
 import { camelToSnake } from '../../schema/ddl.js';
@@ -48,7 +49,11 @@ import {
   sourceSyncGroups,
   sourceSubjectRule,
   sourceSubjectValues,
-} from '../subjectAuthorization.js';
+} from './subjectAuthorization.js';
+import {
+  decodeDatabaseOutboxEvent,
+  ENDPOINT_OUTBOX_PRUNE_BATCH_SIZE,
+} from '../outbox/index.js';
 
 /** A Prisma model delegate — the subset of its methods the adapter calls. */
 export interface PrismaDelegate {
@@ -280,9 +285,9 @@ export function prismaDataSource<S extends SchemaRecord>(
           // Transactional outbox: one event per operation, written in this same transaction.
           await tx.$executeRawUnsafe(
             `INSERT INTO ablo_outbox (
-               id, model, entity_id, type, data, sync_groups,
+               id, model, entity_id, type, data, event_version, sync_groups,
                correlation_id, transaction_id, occurred_at
-             ) VALUES ($1, $2, $3, $4, $5::jsonb, $6::text[], $7, $8, $9)`,
+             ) VALUES ($1, $2, $3, $4, $5::jsonb, 2, $6::text[], $7, $8, $9)`,
             `${change.correlationId}:${index}`,
             op.model,
             entityId,
@@ -319,35 +324,31 @@ export function prismaDataSource<S extends SchemaRecord>(
       });
     },
 
+    async acknowledgeEvents(acknowledgedThrough: string): Promise<void> {
+      await prisma.$transaction(async (tx) => {
+        await tx.$executeRawUnsafe(
+          `DELETE FROM ablo_outbox
+            WHERE cursor IN (
+              SELECT cursor FROM ablo_outbox
+               WHERE cursor <= $1 ORDER BY cursor ASC LIMIT $2
+            )`,
+          acknowledgedThrough,
+          ENDPOINT_OUTBOX_PRUNE_BATCH_SIZE,
+        );
+      });
+    },
+
     async events(cursor: string | null, limit: number): Promise<EventsPage> {
-      const after = cursor ? cursor : '0';
+      const after = cursor ?? '0';
       const rows = await prisma.$queryRawUnsafe<Record<string, unknown>[]>(
-        `SELECT cursor, id, model, entity_id, type, data, sync_groups, organization_id,
+        `SELECT cursor, id, model, entity_id, type, data, event_version, sync_groups, organization_id,
                 client_tx_id, correlation_id, transaction_id, occurred_at
          FROM ablo_outbox WHERE cursor > $1 ORDER BY cursor ASC LIMIT $2`,
         after,
         limit,
       );
-      const events: OutboxEvent[] = rows.map((r) =>
-        outboxEventSchema.parse({
-          id: r.id,
-          model: r.model,
-          entityId: r.entity_id,
-          type: r.type,
-          data: r.data ?? null,
-          syncGroups: r.sync_groups ?? [],
-          organizationId: r.organization_id ?? null,
-          clientTxId: r.client_tx_id ?? null,
-          correlationId: r.correlation_id ?? null,
-          transactionId: r.transaction_id ?? null,
-          occurredAt: r.occurred_at != null ? Number(r.occurred_at) : null,
-          cursor: String(r.cursor),
-        }),
-      );
-      return {
-        events,
-        nextCursor: events.at(-1)?.cursor ?? null,
-      };
+      const events: OutboxEvent[] = rows.map(decodeDatabaseOutboxEvent);
+      return { events, nextCursor: events.at(-1)?.cursor ?? null };
     },
   });
 }

package/src/source/{subjectAuthorization.ts → adapters/subjectAuthorization.ts}

@@ -1,4 +1,4 @@
-import { AbloPermissionError, AbloValidationError } from '../errors.js';
+import { AbloPermissionError, AbloValidationError } from '../../errors.js';
 import {
   composeEntitySyncGroups,
   syncGroupsForRow,
@@ -8,7 +8,7 @@ import {
   type Schema,
   type SchemaRecord,
   type SubjectRule,
-} from '../schema/index.js';
+} from '../../schema/index.js';
 import type { AdapterReadRequest, Row } from './adapter.js';
 import type { ChangeSet, Operation } from './contract.js';
 

package/src/source/{connector.ts → connector/client.ts}

@@ -26,6 +26,7 @@
 
 import {
   SOURCE_CONNECTOR_PROTOCOL_VERSION,
+  SOURCE_CONNECTOR_SUPERSEDED_CLOSE_CODE,
   SOURCE_CONNECTOR_WS_PATH,
   sourceConnectorSubprotocols,
   encodeFrame,
@@ -35,8 +36,8 @@ import {
   type RequestFrame,
   type ResponseFrame,
   type ReadyFrame,
-} from './connectorProtocol.js';
-import { ABLO_HOSTED_HTTP_BASE_URL } from '../auth/hostedEndpoints.js';
+} from './protocol.js';
+import { ABLO_HOSTED_HTTP_BASE_URL } from '../../auth/hostedEndpoints.js';
 
 /**
  * The default Ablo base URL the connector dials, to which it appends
@@ -130,6 +131,20 @@ export interface SourceConnector {
   run(signal: AbortSignal): Promise<void>;
 }
 
+/** The connector lost its source lease to a newer process and will not reconnect. */
+export class SourceConnectorSupersededError extends Error {
+  readonly code = 'source_connector_superseded';
+
+  constructor() {
+    super(
+      'A newer local connector took ownership of this source; this connector has stopped.',
+    );
+    this.name = 'SourceConnectorSupersededError';
+  }
+}
+
+type ConnectionOutcome = 'retry' | 'ready' | 'superseded';
+
 export function createSourceConnector(
   options: SourceConnectorOptions,
 ): SourceConnector {
@@ -148,7 +163,7 @@ export function createSourceConnector(
         if (signal.aborted) return;
 
         options.onStatus?.('connecting');
-        const becameReady = await connectOnce({
+        const outcome = await connectOnce({
           url,
           apiKey: options.apiKey,
           handler: options.handler,
@@ -158,9 +173,10 @@ export function createSourceConnector(
           onError: options.onError,
           signal,
         });
+        if (outcome === 'superseded') return;
         // A connection that reached `ready` resets the backoff so the next
         // drop reconnects immediately; one that never readied keeps escalating.
-        attempt = becameReady ? 0 : attempt + 1;
+        attempt = outcome === 'ready' ? 0 : attempt + 1;
       }
     },
   };
@@ -169,8 +185,10 @@ export function createSourceConnector(
 /**
  * Runs one connection: open the socket, register, then serve requests until the
  * socket closes or `signal` aborts. Resolves to whether the connection reached the
- * `ready` state, which the caller uses to reset the reconnect backoff. It never
- * rejects, because a dropped transport is expected and simply drives a reconnect.
+ * `ready` state, which the caller uses to reset the reconnect backoff, or the
+ * terminal `superseded` fence, which stops this process from taking ownership
+ * back from its replacement. It never rejects because ordinary transport drops
+ * are expected and simply drive a reconnect.
  */
 function connectOnce(params: {
   readonly url: string;
@@ -181,8 +199,8 @@ function connectOnce(params: {
   readonly onStatus: ((status: ConnectorStatus) => void) | undefined;
   readonly onError: ((error: unknown) => void) | undefined;
   readonly signal: AbortSignal;
-}): Promise<boolean> {
-  return new Promise<boolean>((resolve) => {
+}): Promise<ConnectionOutcome> {
+  return new Promise<ConnectionOutcome>((resolve) => {
     let ws: ConnectorWebSocket;
     try {
       ws = params.factory(
@@ -191,18 +209,18 @@ function connectOnce(params: {
       );
     } catch (err) {
       params.onError?.(err);
-      resolve(false);
+      resolve('retry');
       return;
     }
 
     let ready = false;
     let settled = false;
-    const finish = (): void => {
+    const finish = (outcome: ConnectionOutcome = ready ? 'ready' : 'retry'): void => {
       if (settled) return;
       settled = true;
       params.signal.removeEventListener('abort', onAbort);
       params.onStatus?.('disconnected');
-      resolve(ready);
+      resolve(outcome);
     };
 
     const onAbort = (): void => {
@@ -243,7 +261,12 @@ function connectOnce(params: {
       // `close` always follows `error`; finish() runs there.
     });
 
-    ws.addEventListener('close', () => {
+    ws.addEventListener('close', (event) => {
+      if (event.code === SOURCE_CONNECTOR_SUPERSEDED_CLOSE_CODE) {
+        params.onError?.(new SourceConnectorSupersededError());
+        finish('superseded');
+        return;
+      }
       finish();
     });
 

package/src/source/connector/index.ts

@@ -0,0 +1,3 @@
+/** Outbound Data Source connector boundary: client runtime and wire protocol. */
+export * from './client.js';
+export * from './protocol.js';

package/src/source/{connectorProtocol.ts → connector/protocol.ts}

@@ -22,8 +22,8 @@
 
 import { z } from 'zod';
 
-import { environmentSchema } from '../environment.js';
-import { WS_BEARER_SUBPROTOCOL_PREFIX } from '../auth/credentialSource.js';
+import { environmentSchema } from '../../environment.js';
+import { WS_BEARER_SUBPROTOCOL_PREFIX } from '../../auth/credentialSource.js';
 
 /**
  * The wire-protocol version. It increases on any breaking change to a frame's
@@ -43,6 +43,14 @@ export const SOURCE_CONNECTOR_WS_PATH = '/v1/source/listen';
  */
 export const WS_SOURCE_SUBPROTOCOL = 'ablo.source.v1';
 
+/**
+ * Private WebSocket close code used when a newer connector takes ownership of
+ * the same source. This is a fencing decision, not a transient disconnect: the
+ * superseded process must stop reconnecting or two `ablo dev --local`
+ * processes will continuously replace each other.
+ */
+export const SOURCE_CONNECTOR_SUPERSEDED_CLOSE_CODE = 4009;
+
 /**
  * Builds the `Sec-WebSocket-Protocol` list a connector offers during the
  * handshake: the source subprotocol followed by the bearer credential, encoded as

package/src/source/delivery/index.ts

@@ -0,0 +1,2 @@
+/** Data Source push-delivery boundary. */
+export * from './pushQueue.js';

package/src/source/{pushQueue.ts → delivery/pushQueue.ts}

@@ -23,8 +23,8 @@
  * interface against your own outbox table for production durability.
  */
 
-import { ABLO_SOURCE_HEADERS, signAbloSourceRequest } from './signing.js';
-import type { SourceEvent } from './types.js';
+import { ABLO_SOURCE_HEADERS, signAbloSourceRequest } from '../endpoint/signing.js';
+import type { SourceEvent } from '../types.js';
 
 /** One queued delivery: a batch of source events plus its retry bookkeeping. */
 export interface PushQueueItem {

package/src/source/{factory.ts → endpoint/factory.ts}

@@ -10,18 +10,18 @@ import type {
   Schema,
   SchemaRecord,
   InferCreate,
-} from '../schema/schema.js';
-import type { DataSourceAdapter } from './adapter.js';
-import type { AdapterReadRequest, Row } from './adapter.js';
-import { changeSetSchema } from './contract.js';
-import { AbloError, AbloPermissionError } from '../errors.js';
+} from '../../schema/schema.js';
+import type { DataSourceAdapter } from '../adapters/adapter.js';
+import type { AdapterReadRequest, Row } from '../adapters/adapter.js';
+import { changeSetSchema } from '../adapters/contract.js';
+import { AbloError, AbloPermissionError } from '../../errors.js';
 import {
   authorizeSourceChange,
   authorizeSourceRead,
   lockSourceSubjectCreates,
   sourceSubjectRule,
   sourceSubjectValues,
-} from './subjectAuthorization.js';
+} from '../adapters/subjectAuthorization.js';
 import {
   SourceSignatureError,
   verifyAbloSourceRequest,
@@ -41,7 +41,7 @@ import type {
   SourceRequestContext,
   SourceScope,
   SourceSubjectTransactionHandler,
-} from './types.js';
+} from '../types.js';
 
 type SourceModels<S extends SchemaRecord, TAuth> = Partial<{
   readonly [K in keyof S & string]: SourceModelHandlers<
@@ -204,15 +204,19 @@ async function handleViaAdapter(
   }
 
   if (body.type === 'events') {
+    if (body.acknowledgedThrough) {
+      await adapter.acknowledgeEvents(body.acknowledgedThrough);
+    }
     const page = await adapter.events(body.cursor ?? null, body.limit ?? 100);
     return json({
       events: page.events.map((event) => ({
         id: event.id,
+        version: event.version,
         model: event.model,
         entityId: event.entityId,
         type: event.type,
         ...(event.data !== undefined && event.data !== null ? { data: event.data } : {}),
-        syncGroups: event.syncGroups,
+        ...(event.syncGroups ? { syncGroups: event.syncGroups } : {}),
         ...(event.organizationId ? { organizationId: event.organizationId } : {}),
         ...(event.clientTxId ? { clientTxId: event.clientTxId } : {}),
         ...(event.correlationId ? { correlationId: event.correlationId } : {}),
@@ -564,6 +568,7 @@ export function dataSource<const S extends SchemaRecord, TAuth = unknown>(
       }
       const result = await options.events({
         cursor: body.cursor,
+        acknowledgedThrough: body.acknowledgedThrough,
         limit: body.limit,
         context,
       });

package/src/source/endpoint/index.ts

@@ -0,0 +1,4 @@
+/** Signed Data Source endpoint boundary: factory, signing, and framework adapter. */
+export * from './factory.js';
+export * from './signing.js';
+export * from './next.js';

package/src/source/{next.ts → endpoint/next.ts}

@@ -5,7 +5,7 @@
  * `POST` so your route file can export it in one line.
  *
  *   // app/api/ablo/source/route.ts
- *   import { dataSourceNext } from '@abloatai/transaction/source/next';
+ *   import { dataSourceNext } from '@abloatai/transaction/source/endpoint';
  *   import { prismaDataSource } from '@abloatai/transaction/source';
  *   import { schema } from '@/ablo/schema';
  *   import { prisma } from '@/lib/prisma';
@@ -20,7 +20,7 @@
  * directly and export its result however that framework expects.
  */
 
-import type { SchemaRecord } from '../schema/schema.js';
+import type { SchemaRecord } from '../../schema/schema.js';
 import { dataSource, type DataSourceOptions } from './factory.js';
 
 /**

package/src/source/{signing.ts → endpoint/signing.ts}

@@ -1,5 +1,5 @@
 /**
- * Canonically signs and verifies source requests using the Standard Webhooks scheme.
+ * Canonically signs and verifies source endpoint requests using the Standard Webhooks scheme.
  *
  * Every request Ablo sends to a data source is signed with that source's API
  * key, and the receiving endpoint verifies the signature before any handler

package/src/source/index.ts

@@ -56,16 +56,16 @@ export {
   type SourceSignatureOptions,
   type SourceSignatureVerificationOptions,
   type SourceSignatureVerificationResult,
-} from './signing.js';
+} from './endpoint/signing.js';
 
 export {
   dataSource,
   type DataSourceOptions,
-} from './factory.js';
+} from './endpoint/factory.js';
 
 export {
   sourceSubjectCreateLockKey,
-} from './subjectAuthorization.js';
+} from './adapters/subjectAuthorization.js';
 
 export {
   createPushQueue,
@@ -75,7 +75,7 @@ export {
   type PushQueueItem,
   type PushQueueOptions,
   type PushQueueStorage,
-} from './pushQueue.js';
+} from './delivery/pushQueue.js';
 
 // The reverse-channel connector — an outbound transport for the load, list, and
 // commit leg, and the dial-out counterpart to `createPushQueue`. It lets you serve
@@ -84,14 +84,16 @@ export {
 export {
   createSourceConnector,
   DEFAULT_RECONNECT_SCHEDULE,
+  SourceConnectorSupersededError,
   type SourceConnector,
   type SourceConnectorOptions,
   type ConnectorWebSocket,
   type ConnectorWebSocketFactory,
   type ConnectorStatus,
-} from './connector.js';
+} from './connector/client.js';
 export {
   SOURCE_CONNECTOR_PROTOCOL_VERSION,
+  SOURCE_CONNECTOR_SUPERSEDED_CLOSE_CODE,
   SOURCE_CONNECTOR_WS_PATH,
   WS_SOURCE_SUBPROTOCOL,
   sourceConnectorSubprotocols,
@@ -105,7 +107,7 @@ export {
   type RequestFrame,
   type ResponseFrame,
   type ErrorFrame,
-} from './connectorProtocol.js';
+} from './connector/protocol.js';
 
 // The Data Source adapter interface and its Zod contract, with per-ORM implementations.
 export {
@@ -114,7 +116,7 @@ export {
   type AdapterReadRequest,
   type AdapterCommitResult,
   type Row as AdapterRow,
-} from './adapter.js';
+} from './adapters/adapter.js';
 export {
   adapterBindingSchema,
   databaseAdapterProfileSchema,
@@ -127,8 +129,8 @@ export {
   type DatabaseKind,
   type ObservationProfile,
   type PostgresBinding,
-} from './adapterProfile.js';
-export { defineDatabaseAdapter } from './adapterFactory.js';
+} from './adapters/adapterProfile.js';
+export { defineDatabaseAdapter } from './adapters/adapterFactory.js';
 export {
   operationSchema,
   operationTypeSchema,
@@ -137,25 +139,26 @@ export {
   sourceCommitEchoMarkerSchema,
   sourceCommitEchoIntentSchema,
   changeSetSchema,
-  outboxEventSchema,
-  eventsPageSchema,
-  migrationSchema,
   adapterCapabilitiesSchema,
   type Operation,
   type ChangeSet,
-  type OutboxEvent,
-  type EventsPage,
-  type Migration,
   type AdapterCapabilities,
   type SourceCommitEchoMarkerWire,
   type SourceCommitEchoIntent,
-} from './contract.js';
+} from './adapters/contract.js';
+export { migrationSchema, type Migration } from './adapters/migration.js';
+export {
+  endpointOutboxMigrations,
+  eventsPageSchema,
+  outboxEventSchema,
+  type EventsPage,
+  type OutboxEvent,
+} from './outbox/index.js';
 export { prismaDataSource, type PrismaLike, type PrismaDataSourceOptions } from './adapters/prisma.js';
 export {
   adapterTableMigrations,
-  endpointOutboxMigrations,
   idempotencyLedgerMigrations,
-} from './migrations.js';
+} from './adapters/migrations.js';
 export {
   createKyselyMutationAdapter,
   createKyselyMutationCore,
@@ -183,7 +186,7 @@ export {
   encodeSourceEchoTransactionId,
   decodeSourceEchoTransactionId,
   type SourceEchoTransactionId,
-} from './idempotency.js';
+} from './adapters/idempotency.js';
 // What Ablo leaves inside a customer's database, declared once — read by the
 // setup SQL, the replication runtime, and the audit that reports it back.
 export {

package/src/source/outbox/contract.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { commitOperationTypeSchema } from '../../coordination/schema.js';
+import { correlationIdSchema } from '../../commit/contract.js';
+import { ABLO_SOURCE_CLIENT_TX_ID_MAX_LENGTH } from '../types.js';
+
+const jsonObject = z.record(z.string(), z.unknown());
+
+/** The immutable, versioned event envelope stored in `ablo_outbox`. */
+export const outboxEventSchema = z.object({
+  /** Version 1 predates durable routes; version 2 captures them atomically. */
+  version: z.union([z.literal(1), z.literal(2)]),
+  /** Stable, globally unique replay-protection identity. */
+  id: z.string().min(1),
+  model: z.string().min(1),
+  entityId: z.string().min(1),
+  type: commitOperationTypeSchema,
+  /** Declared schema-field names, never physical database column names. */
+  data: jsonObject.nullish(),
+  /** Exact routes captured in the writing transaction; version 2 requires them. */
+  syncGroups: z.array(z.string().min(1)).readonly().optional(),
+  organizationId: z.string().nullish(),
+  clientTxId: z.string().nullish(),
+  correlationId: correlationIdSchema.nullish(),
+  transactionId: z
+    .string()
+    .min(1)
+    .max(ABLO_SOURCE_CLIENT_TX_ID_MAX_LENGTH)
+    .nullish(),
+  occurredAt: z.number().nullish(),
+  /** Monotonic database position, represented as a string to preserve bigint. */
+  cursor: z.string().min(1),
+}).superRefine((event, ctx) => {
+  if (event.version === 1 && event.syncGroups !== undefined) {
+    ctx.addIssue({
+      code: 'custom',
+      path: ['syncGroups'],
+      message: 'Outbox event version 1 cannot carry syncGroups',
+    });
+  }
+  if (event.version === 2 && event.syncGroups === undefined) {
+    ctx.addIssue({
+      code: 'custom',
+      path: ['syncGroups'],
+      message: 'Outbox event version 2 requires durable syncGroups',
+    });
+  }
+});
+
+export type OutboxEvent = z.infer<typeof outboxEventSchema>;
+
+export const eventsPageSchema = z.object({
+  events: z.array(outboxEventSchema),
+  nextCursor: z.string().nullable(),
+});
+
+export type EventsPage = z.infer<typeof eventsPageSchema>;

package/src/source/outbox/envelope.ts

@@ -0,0 +1,47 @@
+import { AbloValidationError } from '../../errors.js';
+import { outboxEventSchema, type OutboxEvent } from './contract.js';
+
+/** Decode the versioned routing envelope without turning absence into `[]`. */
+export function decodeOutboxEventEnvelope(
+  eventVersion: unknown,
+  syncGroups: unknown,
+  cursor: unknown,
+): { readonly version: 1 | 2; readonly syncGroups?: readonly string[] } {
+  const version = eventVersion == null
+    ? (Array.isArray(syncGroups) ? 2 : 1)
+    : Number(eventVersion);
+  if (version !== 1 && version !== 2) {
+    throw new AbloValidationError(
+      `Endpoint outbox event at cursor ${String(cursor)} has unsupported event version ${String(eventVersion)}.`,
+      { code: 'source_event_invalid' },
+    );
+  }
+  if (version === 2 && !Array.isArray(syncGroups)) {
+    throw new AbloValidationError(
+      `Endpoint outbox event at cursor ${String(cursor)} is version 2 but has no durable sync_groups.`,
+      { code: 'source_event_invalid' },
+    );
+  }
+  return version === 2
+    ? { version, syncGroups: syncGroups as readonly string[] }
+    : { version };
+}
+
+/** Canonical snake_case database row → versioned source event decoder. */
+export function decodeDatabaseOutboxEvent(row: Readonly<Record<string, unknown>>): OutboxEvent {
+  const envelope = decodeOutboxEventEnvelope(row.event_version, row.sync_groups, row.cursor);
+  return outboxEventSchema.parse({
+    ...envelope,
+    id: row.id,
+    model: row.model,
+    entityId: row.entity_id,
+    type: row.type,
+    data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data ?? null,
+    organizationId: row.organization_id ?? null,
+    clientTxId: row.client_tx_id ?? null,
+    correlationId: row.correlation_id ?? null,
+    transactionId: row.transaction_id ?? null,
+    occurredAt: row.occurred_at != null ? Number(row.occurred_at) : null,
+    cursor: String(row.cursor),
+  });
+}

package/src/source/outbox/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Endpoint transactional-outbox subsystem.
+ *
+ * Start here, then descend into contract, envelope, migrations, or retention.
+ * ORM adapters depend on this boundary; the subsystem never depends on them.
+ */
+export {
+  outboxEventSchema,
+  eventsPageSchema,
+  type OutboxEvent,
+  type EventsPage,
+} from './contract.js';
+export { decodeDatabaseOutboxEvent, decodeOutboxEventEnvelope } from './envelope.js';
+export { endpointOutboxMigrations } from './migrations.js';
+export { ENDPOINT_OUTBOX_PRUNE_BATCH_SIZE } from './retention.js';