@abloatai/transaction 0.57.0 → 0.58.0

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

@@ -24,13 +24,13 @@
  * you want to override one of those while the adapter serves the rest.
  */
 
-import type { SourceListQuery, SourceRequestContext } from './types.js';
+import type { SourceListQuery, SourceRequestContext } from '../types.js';
 import type {
   AdapterCapabilities,
   ChangeSet,
-  EventsPage,
-  Migration,
 } from './contract.js';
+import type { Migration } from './migration.js';
+import type { EventsPage } from '../outbox/index.js';
 import type { DatabaseAdapterProfile } from './adapterProfile.js';
 
 /**
@@ -83,8 +83,12 @@ export interface MutationAdapter {
  */
 export interface DataSourceAdapter extends MutationAdapter {
   readonly capabilities: AdapterCapabilities & { readonly outboxEvents: true };
-  /** Reads outbox events after `cursor` (`null` starts from the beginning), up to `limit` events. */
+  /** Pure read of events after `cursor`; `null` starts at the beginning. */
   events(cursor: string | null, limit: number): Promise<EventsPage>;
+  /** Bounded cleanup through a consumer position Ablo has durably committed. */
+  acknowledgeEvents(acknowledgedThrough: string): Promise<void>;
 }
 
-export type { AdapterCapabilities, ChangeSet, Migration, OutboxEvent, EventsPage } from './contract.js';
+export type { AdapterCapabilities, ChangeSet } from './contract.js';
+export type { Migration } from './migration.js';
+export type { EventsPage, OutboxEvent } from '../outbox/index.js';

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

@@ -6,7 +6,7 @@
  * binding, observation, and advertised guarantees.
  */
 
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../../errors.js';
 import type { MutationAdapter } from './adapter.js';
 import { databaseAdapterProfileSchema } from './adapterProfile.js';
 

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

@@ -302,4 +302,4 @@ export function runDataSourceTests(
   }
 }
 
-export { memoryDataSource } from './adapters/memory.js';
+export { memoryDataSource } from './memory.js';

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

@@ -5,8 +5,8 @@
  * failing deep inside a transaction, and each TypeScript type is inferred from the
  * one schema that validates it.
  *
- * These schemas describe the adapter's own contract: the change set it commits,
- * the outbox row it stores, and the table migrations it ships. The operation
+ * These schemas describe the adapter's mutation contract: the change set it
+ * commits and the capabilities it advertises. The operation
  * vocabulary is not restated here — `operationSchema` is projected from the
  * core's `commitOperationSchema`, so an action or field added to the commit
  * contract reaches a data source by construction. The assertion at the end of
@@ -16,11 +16,11 @@
  */
 
 import { z } from 'zod';
-import { correlationIdSchema } from '../wire/commit.js';
+import { correlationIdSchema } from '../../commit/contract.js';
 import {
   commitOperationSchema,
   commitOperationTypeSchema,
-} from '../coordination/schema.js';
+} from '../../coordination/schema.js';
 import {
   ABLO_SOURCE_CLIENT_TX_ID_MAX_LENGTH,
   ABLO_SOURCE_ECHO_MAX_OPERATIONS,
@@ -28,8 +28,8 @@ import {
   type SourceCommitEcho,
   type SourceCommitEchoMarker,
   type SourceOperation,
-} from './types.js';
-import type { SourceRequestContext } from './types.js';
+} from '../types.js';
+import type { SourceRequestContext } from '../types.js';
 
 const jsonObject = z.record(z.string(), z.unknown());
 
@@ -45,15 +45,15 @@ export type OperationType = z.infer<typeof operationTypeSchema>;
  * A single operation within a change set, and the runtime validator for it.
  *
  * The field set is projected from `commitOperationSchema` — an operation
- * reaching a data source is a commit operation minus the two fields the core
- * settles internally (`bypass`, `fenceToken`). The two `min(1)` overrides are
+ * reaching a data source is a commit operation minus the fencing field the
+ * core settles internally. The two `min(1)` overrides are
  * deliberate and local: this is a customer-implemented boundary, so an empty
  * model name or row id is rejected here rather than forwarded. Stating them as
  * an extension keeps the tightening visible as a choice instead of hiding it
  * inside a second copy of the shape.
  */
 export const operationSchema = commitOperationSchema
-  .omit({ bypass: true, fenceToken: true })
+  .omit({ fenceToken: true })
   .extend({
     model: z.string().min(1),
     id: z.string().min(1).nullish(),
@@ -161,61 +161,6 @@ export const changeSetSchema = z.object({
 });
 export type ChangeSet = z.infer<typeof changeSetSchema>;
 
-/**
- * A row in the adapter's `ablo_outbox` table. The adapter writes it in the same
- * transaction as the underlying row change — the transactional-outbox pattern — so
- * a change and its event commit together or not at all. The `events()` feed later
- * reads these rows back and hands them to Ablo, and `cursor` is the monotonic
- * ordering key Ablo round-trips to resume where it left off.
- */
-export const outboxEventSchema = z.object({
-  /** Stable, globally-unique id — Ablo's replay-protection key. */
-  id: z.string().min(1),
-  model: z.string().min(1),
-  entityId: z.string().min(1),
-  type: operationTypeSchema,
-  /** The changed row, in the key shape `SourceEvent.data` defines: the model's
-   *  declared schema fields, never the table's physical column names. */
-  data: jsonObject.nullish(),
-  /** Exact record routes captured in the same transaction as the row change. */
-  syncGroups: z.array(z.string().min(1)).readonly(),
-  organizationId: z.string().nullish(),
-  /** Legacy source transaction id. Never use this field to settle a queued commit. */
-  clientTxId: z.string().nullish(),
-  /** Scoped server-authored identity that correlates this event to a queued commit. */
-  correlationId: correlationIdSchema.nullish(),
-  /** Stable identity of this operation within the correlated source commit. */
-  transactionId: z
-    .string()
-    .min(1)
-    .max(ABLO_SOURCE_CLIENT_TX_ID_MAX_LENGTH)
-    .nullish(),
-  occurredAt: z.number().nullish(),
-  /** Monotonic ordering key (bigint as string). `events()` pages by `cursor > ?`. */
-  cursor: z.string().min(1),
-});
-export type OutboxEvent = z.infer<typeof outboxEventSchema>;
-
-/** A page of outbox events returned by `events()`. */
-export const eventsPageSchema = z.object({
-  events: z.array(outboxEventSchema),
-  nextCursor: z.string().nullable(),
-});
-export type EventsPage = z.infer<typeof eventsPageSchema>;
-
-/**
- * A table-creation migration an adapter ships, so you never hand-write the
- * `ablo_idempotency` and `ablo_outbox` tables yourself. An adapter returns these
- * from its `migrations()` method.
- */
-export const migrationSchema = z.object({
-  /** Stable name, used as the migration filename + applied-ledger key. */
-  name: z.string().min(1),
-  /** The forward SQL. */
-  up: z.string().min(1),
-});
-export type Migration = z.infer<typeof migrationSchema>;
-
 /** Describes what an adapter's backend supports, so callers check a capability rather than infer it from behavior. */
 export const adapterCapabilitiesSchema = z.object({
   /** `commit` is atomic across all operations in the change set. */
@@ -255,6 +200,13 @@ const _echoContractInSync: [_AssertEchoMatchesWire, _AssertWireMatchesEcho] = [
 ];
 void _echoContractInSync;
 
+// Compatibility façade. New implementation code follows the owned subsystem
+// downward from `outbox/index.ts` and imports migrations from `migration.ts`.
+export { eventsPageSchema, outboxEventSchema } from '../outbox/contract.js';
+export type { EventsPage, OutboxEvent } from '../outbox/contract.js';
+export { migrationSchema } from './migration.js';
+export type { Migration } from './migration.js';
+
 type _AssertEchoMarkerMatchesWire = SourceCommitEchoMarkerWire extends SourceCommitEchoMarker
   ? true
   : never;

package/src/source/adapters/drizzle.ts

@@ -41,18 +41,18 @@ import type {
   AdapterReadRequest,
   DataSourceAdapter,
   Row,
-} from '../adapter.js';
-import { defineDatabaseAdapter } from '../adapterFactory.js';
-import { postgresAdapterProfile } from '../adapterProfile.js';
-import type { ChangeSet, EventsPage, Migration, Operation } 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 { adapterTableMigrations } from './migrations.js';
 import {
   assertSourceIdempotencyIntent,
   assertSourceIdempotencyRetention,
   SOURCE_IDEMPOTENCY_RETENTION,
   sourceChangeIntentHash,
-} from '../idempotency.js';
+} from './idempotency.js';
 import type { Schema, SchemaRecord } from '../../schema/schema.js';
 import { toSchemaJSON } from '../../schema/serialize.js';
 import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
@@ -66,7 +66,12 @@ import {
   sourceSyncGroups,
   sourceSubjectRule,
   sourceSubjectValues,
-} from '../subjectAuthorization.js';
+} from './subjectAuthorization.js';
+import {
+  decodeDatabaseOutboxEvent,
+  ENDPOINT_OUTBOX_PRUNE_BATCH_SIZE,
+  type EventsPage,
+} from '../outbox/index.js';
 
 /** The subset of a Drizzle database/transaction handle the adapter calls. */
 export interface DrizzleLike {
@@ -287,12 +292,12 @@ export function drizzleDataSource<S extends SchemaRecord>(
           )}]::text[]`;
           await tx.execute(sql`
             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 (
               ${`${change.correlationId}:${index}`}, ${op.model}, ${entityId}, ${op.type},
-              ${op.type === 'DELETE' ? null : JSON.stringify(row)}::jsonb,
+              ${op.type === 'DELETE' ? null : JSON.stringify(row)}::jsonb, 2,
               ${syncGroupsSql},
               ${change.correlationId}, ${op.transactionId ?? null}, ${Date.now()}
             )`);
@@ -313,30 +318,27 @@ export function drizzleDataSource<S extends SchemaRecord>(
       });
     },
 
+    async acknowledgeEvents(acknowledgedThrough: string): Promise<void> {
+      await db.transaction(async (tx) => {
+        await tx.execute(sql`
+          DELETE FROM ablo_outbox
+           WHERE cursor IN (
+             SELECT cursor FROM ablo_outbox
+              WHERE cursor <= ${acknowledgedThrough}
+              ORDER BY cursor ASC LIMIT ${ENDPOINT_OUTBOX_PRUNE_BATCH_SIZE}
+           )`);
+      });
+    },
+
     async events(cursor: string | null, limit: number): Promise<EventsPage> {
       const after = cursor ?? '0';
       const rows = rowsOf(
         await db.execute(sql`
-          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 > ${after} ORDER BY cursor ASC LIMIT ${limit}`),
       );
-      const events = 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),
-        }),
-      );
+      const events = rows.map(decodeDatabaseOutboxEvent);
       return { events, nextCursor: events.at(-1)?.cursor ?? null };
     },
   });

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

@@ -12,11 +12,11 @@
 
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../../errors.js';
 import {
   COMMIT_CORRELATION_ID_MAX_LENGTH,
   correlationIdSchema,
-} from '../wire/commit.js';
+} from '../../commit/contract.js';
 import type { ChangeSet, Operation } from './contract.js';
 
 const SOURCE_ECHO_TRANSACTION_ID_PREFIX = 'ablo_echo_tx_v1:';

package/src/source/adapters/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Customer-database adapter subsystem.
+ *
+ * Start here and descend through the behavioral adapter port, mutation
+ * contract, profiles, migrations, idempotency, authorization, conformance,
+ * and concrete ORM bindings.
+ */
+export * from './adapter.js';
+export * from './adapterFactory.js';
+export * from './adapterProfile.js';
+export * from './contract.js';
+export * from './migration.js';
+export * from './migrations.js';
+export * from './idempotency.js';
+export * from './subjectAuthorization.js';
+export * from './conformance.js';
+export * from './memory.js';
+export * from './prisma.js';
+export * from './drizzle.js';
+export * from './kysely.js';

package/src/source/adapters/kysely.ts

@@ -24,27 +24,27 @@ import type {
   DataSourceAdapter,
   MutationAdapter,
   Row,
-} from '../adapter.js';
-import { defineDatabaseAdapter } from '../adapterFactory.js';
-import { postgresAdapterProfile } from '../adapterProfile.js';
-import type { ChangeSet, EventsPage, Migration } from '../contract.js';
+} from './adapter.js';
+import { defineDatabaseAdapter } from './adapterFactory.js';
+import { postgresAdapterProfile } from './adapterProfile.js';
+import type { ChangeSet } from './contract.js';
+import type { Migration } from './migration.js';
 import {
   changeSetSchema,
-  outboxEventSchema,
   sourceCommitEchoMarkerSchema,
   sourceCommitEchoIntentSchema,
   type SourceCommitEchoIntent,
-} from '../contract.js';
+} from './contract.js';
 import {
   assertSourceIdempotencyIntent,
   assertSourceIdempotencyRetention,
   sourceChangeIntentHash,
   SOURCE_IDEMPOTENCY_RETENTION,
-} from '../idempotency.js';
+} from './idempotency.js';
 import {
   adapterTableMigrations,
   idempotencyLedgerMigrations,
-} from '../migrations.js';
+} from './migrations.js';
 import { ABLO_POSTGRES_COMMIT_ECHO_PREFIX } from '../types.js';
 import {
   authorizeSourceChange,
@@ -52,7 +52,12 @@ import {
   lockSourceSubjectCreates,
   rethrowStrictCreateConflict,
   sourceSyncGroups,
-} from '../subjectAuthorization.js';
+} from './subjectAuthorization.js';
+import {
+  decodeDatabaseOutboxEvent,
+  ENDPOINT_OUTBOX_PRUNE_BATCH_SIZE,
+  type EventsPage,
+} from '../outbox/index.js';
 import {
   createKyselyMutationCore,
   kyselyOperationRowId,
@@ -403,6 +408,7 @@ export function createKyselyMutationAdapter(
                 entity_id: entityId,
                 type: operation.type,
                 data: operation.type === 'DELETE' ? null : JSON.stringify(row),
+                event_version: 2,
                 sync_groups: options.schema
                   ? sourceSyncGroups(options.schema, operation.model, row)
                   : [],
@@ -449,6 +455,22 @@ export function kyselyDataSource<S extends SchemaRecord>(
     ...mutation,
     capabilities: { ...mutation.capabilities, outboxEvents: true },
 
+    async acknowledgeEvents(acknowledgedThrough: string): Promise<void> {
+      await db.transaction().execute(async (transaction) => {
+        await transaction.executeQuery(
+          rawQuery(
+            'ablo-outbox-prune-acknowledged',
+            `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 rows = await db
         .selectFrom('ablo_outbox')
@@ -457,22 +479,7 @@ export function kyselyDataSource<S extends SchemaRecord>(
         .orderBy('cursor', 'asc')
         .limit(limit)
         .execute();
-      const events = rows.map((row) =>
-        outboxEventSchema.parse({
-          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,
-          syncGroups: row.sync_groups ?? [],
-          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),
-        }),
-      );
+      const events = rows.map(decodeDatabaseOutboxEvent);
       return { events, nextCursor: events.at(-1)?.cursor ?? null };
     },
   });

package/src/source/adapters/kyselyMutationCore.ts

@@ -13,9 +13,9 @@ import type { Schema, SchemaRecord } from '../../schema/schema.js';
 import { toSchemaJSON } from '../../schema/serialize.js';
 import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
 import { tenancyColumn } from '../../schema/tenancy.js';
-import type { AdapterReadRequest, Row } from '../adapter.js';
-import type { Operation } from '../contract.js';
-import { sourceSubjectRule, sourceSubjectValues } from '../subjectAuthorization.js';
+import type { AdapterReadRequest, Row } from './adapter.js';
+import type { Operation } from './contract.js';
+import { sourceSubjectRule, sourceSubjectValues } from './subjectAuthorization.js';
 
 /** The subset of a Kysely instance, or transaction handle, used by the core. */
 export interface KyselyLike {

package/src/source/adapters/memory.ts

@@ -6,8 +6,8 @@
  * mapper is complete when it passes the same suite this one passes.
  *
  * It models the semantics minimally but faithfully: one row store per model, an
- * idempotency ledger keyed by scoped correlation, and an append-only outbox with a
- * monotonic cursor.
+ * idempotency ledger keyed by scoped correlation, and an acknowledgement-pruned
+ * outbox with a monotonic cursor.
  */
 
 import { AbloValidationError } from '../../errors.js';
@@ -16,14 +16,16 @@ import type {
   AdapterReadRequest,
   DataSourceAdapter,
   Row,
-} from '../adapter.js';
-import { defineDatabaseAdapter } from '../adapterFactory.js';
-import { memoryAdapterProfile } from '../adapterProfile.js';
-import type { ChangeSet, EventsPage, Migration, Operation, OutboxEvent } from '../contract.js';
+} from './adapter.js';
+import { defineDatabaseAdapter } from './adapterFactory.js';
+import { memoryAdapterProfile } 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 {
   assertSourceIdempotencyIntent,
   sourceChangeIntentHash,
-} from '../idempotency.js';
+} from './idempotency.js';
 
 function rowId(op: Operation): string {
   const id = op.id ?? (op.input?.id as string | undefined);
@@ -41,8 +43,9 @@ export function memoryDataSource(): DataSourceAdapter {
     string,
     { readonly requestHash: string; readonly rows: Row[] }
   >();
-  /** Append-only outbox; `cursor` is the 1-based index as a string. */
+  /** Acknowledgement-pruned outbox with a monotonic cursor. */
   const outbox: OutboxEvent[] = [];
+  let nextOutboxCursor = 1;
 
   const modelStore = (model: string): Map<string, Row> => {
     let m = store.get(model);
@@ -136,6 +139,7 @@ export function memoryDataSource(): DataSourceAdapter {
         rows.push(row);
         // Transactional outbox: one event per op, monotonic cursor.
         outbox.push({
+          version: 2,
           id: `${change.correlationId}:${index}`,
           model: op.model,
           entityId: String(row.id ?? rowId(op)),
@@ -144,13 +148,25 @@ export function memoryDataSource(): DataSourceAdapter {
           syncGroups: [],
           correlationId: change.correlationId,
           ...(op.transactionId ? { transactionId: op.transactionId } : {}),
-          cursor: String(outbox.length + 1),
+          cursor: String(nextOutboxCursor++),
         });
       }
       idempotency.set(change.correlationId, { requestHash, rows });
       return { rows };
     },
 
+    async acknowledgeEvents(acknowledgedThrough: string): Promise<void> {
+      const after = Number(acknowledgedThrough);
+      let acknowledgedCount = 0;
+      while (
+        acknowledgedCount < outbox.length &&
+        Number(outbox[acknowledgedCount]?.cursor) <= after
+      ) {
+        acknowledgedCount += 1;
+      }
+      if (acknowledgedCount > 0) outbox.splice(0, acknowledgedCount);
+    },
+
     async events(cursor: string | null, limit: number): Promise<EventsPage> {
       const after = cursor ? Number(cursor) : 0;
       const page = outbox.filter((e) => Number(e.cursor) > after).slice(0, limit);

package/src/source/adapters/migration.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+/** One forward-only infrastructure migration shipped by an adapter. */
+export const migrationSchema = z.object({
+  /** Stable name, used as the migration filename + applied-ledger key. */
+  name: z.string().min(1),
+  /** The forward SQL. */
+  up: z.string().min(1),
+});
+
+export type Migration = z.infer<typeof migrationSchema>;

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

@@ -10,7 +10,10 @@
  * it records changes in its own `sync_deltas` log instead.
  */
 
-import type { Migration } from './contract.js';
+import type { Migration } from './migration.js';
+import { endpointOutboxMigrations } from '../outbox/index.js';
+
+export { endpointOutboxMigrations } from '../outbox/index.js';
 
 /**
  * Add a column to `ablo_idempotency` only when it is genuinely missing.
@@ -87,58 +90,7 @@ export function idempotencyLedgerMigrations(schema = 'public'): readonly Migrati
   ];
 }
 
-/** Endpoint-only transactional outbox and its correlation columns. */
-export function endpointOutboxMigrations(): readonly Migration[] {
-  return [
-    {
-      name: 'ablo_outbox',
-      up: `CREATE TABLE IF NOT EXISTS ablo_outbox (
-  cursor          BIGSERIAL PRIMARY KEY,
-  id              TEXT NOT NULL UNIQUE,
-  model           TEXT NOT NULL,
-  entity_id       TEXT NOT NULL,
-  type            TEXT NOT NULL,
-  data            JSONB,
-  sync_groups      TEXT[] NOT NULL,
-  organization_id TEXT,
-  client_tx_id    TEXT,
-  correlation_id  TEXT,
-  transaction_id  TEXT,
-  occurred_at     BIGINT,
-  created_at      TIMESTAMPTZ NOT NULL DEFAULT now()
-);`,
-    },
-    {
-      name: 'ablo_outbox_correlation',
-      up: `ALTER TABLE ablo_outbox
-  ADD COLUMN IF NOT EXISTS correlation_id TEXT;
-ALTER TABLE ablo_outbox
-  ADD COLUMN IF NOT EXISTS transaction_id TEXT;`,
-    },
-    {
-      name: 'ablo_outbox_sync_groups',
-      up: `DO $$
-BEGIN
-  IF NOT EXISTS (
-    SELECT 1 FROM information_schema.columns
-     WHERE table_schema = current_schema()
-       AND table_name = 'ablo_outbox'
-       AND column_name = 'sync_groups'
-  ) AND EXISTS (SELECT 1 FROM ablo_outbox) THEN
-    RAISE EXCEPTION USING
-      ERRCODE = '55000',
-      MESSAGE = 'ablo_outbox contains legacy events; verify the previous release consumed them, then purge those rows before adding sync_groups';
-  END IF;
-END $$;
-ALTER TABLE ablo_outbox
-  ADD COLUMN IF NOT EXISTS sync_groups TEXT[];
-ALTER TABLE ablo_outbox
-  ALTER COLUMN sync_groups SET NOT NULL;`,
-    },
-  ];
-}
-
 /** Full endpoint adapter migrations (ledger + outbox). */
-export function adapterTableMigrations(): readonly Migration[] {
-  return [...idempotencyLedgerMigrations(), ...endpointOutboxMigrations()];
+export function adapterTableMigrations(schema = 'public'): readonly Migration[] {
+  return [...idempotencyLedgerMigrations(schema), ...endpointOutboxMigrations(schema)];
 }