@abloatai/transaction 0.57.0 → 0.59.0

package/src/schema/openapi.ts

@@ -25,6 +25,7 @@ import type { FieldMeta } from './field.js';
 // Pulled from the endpoints module to keep this schema file free of the client's
 // error-handling and credential dependencies.
 import { ABLO_HOSTED_HTTP_BASE_URL } from '../auth/hostedEndpoints.js';
+import { docUrlForCode } from '../errors.js';
 // The commit body is DERIVED from the schema the server validates against —
 // one definition site, so the documented surface cannot drift from the
 // enforced one.
@@ -35,7 +36,7 @@ import {
   commitRecordSchema,
   commitRecordListSchema,
   commitRecordWhereSchema,
-} from '../wire/commit.js';
+} from '../commit/contract.js';
 import { CURSOR_PARAM, CURSOR_PARAM_ALIAS } from '../wire/listEnvelope.js';
 import {
   claimRequestSchema,
@@ -51,7 +52,7 @@ import {
   claimReorderRequestSchema,
   claimReorderReplySchema,
   claimReleaseReplySchema,
-} from '../wire/claims.js';
+} from '../claims/contract.js';
 import { errorEnvelopeSchema } from '../wire/errorEnvelope.js';
 // The lifecycle promise and the rate-limit fields are contract, not prose about
 // contract: the document renders the same constants the server emits, so the
@@ -69,8 +70,8 @@ import {
 } from '../wire/rateLimit.js';
 import { modelReadResponseSchema, modelListResponseSchema } from '../wire/modelResponses.js';
 import { modelMutationRequestSchema } from '../wire/modelMutations.js';
-import { logListResponseSchema, logQuerySchema } from '../wire/feedEvent.js';
-import { logDeliveryResponseSchema } from '../wire/deltaDelivery.js';
+import { logListResponseSchema, logQuerySchema } from '../observation/feedContract.js';
+import { logDeliveryResponseSchema } from '../observation/deliveryContract.js';
 import { schemaReadResponseSchema } from '../wire/accountResponses.js';
 import {
   ephemeralKeyRequestSchema,
@@ -530,6 +531,11 @@ function envelope(options: SchemaToOpenApiOptions, description: string, paths: J
         name: 'Apache License 2.0',
         identifier: 'Apache-2.0',
       },
+      contact: {
+        name: 'Ablo Support',
+        url: 'https://github.com/Abloatai/ablo/issues',
+        email: 'support@abloatai.com',
+      },
     },
     servers: [{ url: options.serverUrl ?? `${ABLO_HOSTED_HTTP_BASE_URL}/api` }],
     security: [{ bearerAuth: [] }],
@@ -555,6 +561,41 @@ const ERROR_RESPONSES: Readonly<Record<string, string>> = {
   '503': 'A required service is temporarily unavailable.',
 };
 
+/**
+ * One real instance of the error shape every operation shares.
+ *
+ * This lives beside the canonical error responses rather than on the schema:
+ * OpenAPI consumers select examples from an operation's media type, and an
+ * example buried on a component does not tell them which response carries it.
+ * Stamping the same representative validation failure on every operation also
+ * means a newly added route cannot regress the published example coverage.
+ */
+const ERROR_RESPONSE_EXAMPLE: Readonly<Json> = {
+  type: 'AbloValidationError',
+  code: 'invalid_request',
+  param: 'body',
+  message: 'The request did not satisfy the published contract.',
+  doc_url: docUrlForCode('invalid_request'),
+  request_id: 'req_52bb7f46-17bc-4f2d-9988-89d1398d2990',
+};
+
+function canonicalErrorResp(description: string): Json {
+  return {
+    description,
+    content: {
+      'application/json': {
+        schema: schemaRef('ErrorEnvelope'),
+        examples: {
+          validation: {
+            summary: 'Typed validation failure',
+            value: ERROR_RESPONSE_EXAMPLE,
+          },
+        },
+      },
+    },
+  };
+}
+
 /**
  * Every route passes failures through the same server error funnel. Publish
  * that fact on every operation so generated transports decode all HTTP errors
@@ -569,11 +610,10 @@ function attachCanonicalErrors(paths: Json): void {
       const operation = rawOperation as Json;
       const responses = { ...(operation.responses as Json | undefined) };
       for (const [status, description] of Object.entries(ERROR_RESPONSES)) {
-        responses[status] = namedResp(description, 'ErrorEnvelope');
+        responses[status] = canonicalErrorResp(description);
       }
-      responses.default = namedResp(
+      responses.default = canonicalErrorResp(
         'An HTTP error not otherwise listed; decoded through the canonical envelope.',
-        'ErrorEnvelope',
       );
       operation.responses = responses;
     }

package/src/schema/schema.ts

@@ -13,11 +13,11 @@
  *       status: z.enum(['todo', 'doing', 'done']).default('todo'),
  *       workspaceId: z.string().optional(),
  *     }, {
- *       workspace: relation.belongsTo('workspaces', 'workspaceId'),
+ *       relations: { workspace: relation.belongsTo('workspaces', 'workspaceId') },
  *     }),
  *   });
  *
- *   type Item = InferModel<typeof schema, 'items'>;
+ *   type Item = Model<typeof schema, 'items'>;
  */
 
 import { z } from 'zod';
@@ -231,6 +231,13 @@ export const baseFieldsSchema = z.object({
 /**
  * The universal model field names. Audit and application metadata is declared
  * by the application or carried by the commit record, never injected here.
+ *
+ * This is the runtime spelling of {@link baseFieldsSchema}, and the one every
+ * consumer outside this package derives from: the CLI's adopt rule, the MCP
+ * schema linter, and the docs that tell an author which names not to declare.
+ * It is exported from `@abloatai/transaction/schema` for exactly that reason —
+ * when this list last moved (0.52.0, five names down to one) three hand-written
+ * copies stayed behind and went on rejecting correct schemas for five releases.
  */
 export const BASE_FIELDS = [
   'id',
@@ -239,6 +246,18 @@ export const BASE_FIELDS = [
 /** The base fields type — pure data columns. */
 export type BaseModelFields = z.infer<typeof baseFieldsSchema>;
 
+// Invariant equality (no runtime, no casts): true only when both are mutually
+// assignable. `ExpectTrue`'s constraint is what turns a mismatch into an error
+// at THIS declaration, so the tuple and the schema cannot move apart — in
+// either direction, a name in one and not the other fails to compile.
+type BaseFieldsEqual<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+type ExpectTrue<T extends true> = T;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _BaseFieldsExact = ExpectTrue<
+  BaseFieldsEqual<(typeof BASE_FIELDS)[number], keyof BaseModelFields & string>
+>;
+
 /**
  * Methods every model instance carries. These are intersected into
  * {@link InferModel}, the read-side type, but not into the create or update
@@ -332,7 +351,8 @@ export interface Schema<S extends SchemaRecord = SchemaRecord> {
 
 /**
  * Infer the full model type from a schema.
- * Includes base fields (id, createdAt, updatedAt, etc.)
+ * Includes the base fields, which today means `id` alone: audit timestamps are
+ * ordinary declared fields and appear here only when the model declares them.
  *
  * ```ts
  * type Item = InferModel<typeof schema, 'items'>;

package/src/schema/serialize.ts

@@ -41,7 +41,6 @@ import type {
   LoadStrategy,
   PersistOptions,
   AutoFillRule,
-  ConflictAxis,
 } from './model.js';
 import {
   relation,
@@ -90,9 +89,6 @@ export interface ModelJSON {
   readonly grants?: GrantsRef;
   readonly entityRoles?: readonly EntityRole[];
   readonly routingOnly?: true;
-  /** The declared write-conflict disposition per committer kind. When absent,
-   *  the engine falls back to its default. */
-  readonly conflict?: ConflictAxis;
   readonly bootstrapLimit?: number;
   readonly bootstrapOrderBy?: string;
   readonly mutable?: boolean;
@@ -145,7 +141,6 @@ function modelToJSON(def: ModelDef): ModelJSON {
     grants: def.grants,
     entityRoles: def.entityRoles,
     routingOnly: def.routingOnly,
-    conflict: def.conflict,
     bootstrapLimit: def.bootstrapLimit,
     bootstrapOrderBy: def.bootstrapOrderBy,
     mutable: def.mutable,
@@ -285,9 +280,6 @@ function modelFromJSON(json: ModelJSON): ModelDef {
     grants: json.grants,
     entityRoles: json.entityRoles,
     routingOnly: json.routingOnly,
-    // Absent in older artifacts → undefined, so the commit path falls through to
-    // the function registry or the engine default.
-    conflict: json.conflict,
     mutable: json.mutable,
     lazyObservable: json.lazyObservable,
     // computed getters are closures and intentionally not serialized; a

package/src/server/adapter.ts

@@ -21,7 +21,7 @@ import type {
   SourceOperation,
   SourceRequestContext,
 } from '../source/index.js';
-import type { ServerSyncDelta } from '../wire/delta.js';
+import type { ServerSyncDelta } from '../observation/contract.js';
 import type { BootstrapModel } from './readConfig.js';
 import type { CommitContext, CommitExecutionResult } from './commit.js';
 import type { StorageMode } from './storageMode.js';

package/src/server/commit.ts

@@ -13,11 +13,11 @@
  * commit time and the shape of a stored or broadcast delta share one definition
  * rather than being kept in step by hand.
  */
-import type { ParticipantKind, ConfirmationState } from '../log/syncDeltaRow.js';
-import type { ParticipantRef } from '../wire/delta.js';
-import type { CommitExecutionResultInput } from '../wire/commit.js';
-import type { CommitOperationResult } from '../wire/commit.js';
-import type { ReadDependency, TrackDependency } from '../coordination/schema.js';
+import type { ParticipantKind, ConfirmationState } from '../observation/persistence/syncDeltaRow.js';
+import type { ParticipantRef } from '../observation/contract.js';
+import type { CommitExecutionResultInput } from '../commit/contract.js';
+import type { CommitOperationResult } from '../commit/contract.js';
+import type { ReadDependency } from '../coordination/schema.js';
 import type { EffectiveAuthority } from '../auth/capability.js';
 
 export interface CommitContext {
@@ -81,18 +81,10 @@ export interface CommitContext {
   /**
    * The premise for the whole batch. The committer declares the rows or groups
    * it read to form this batch; the engine checks that none of them changed since
-   * each entry's `readAt` timestamp and applies that entry's `onStale` disposition
-   * across the batch. This differs from the per-operation `readAt` guard, which
+   * each entry's `readAt` timestamp and rejects the batch if one moved. This differs from the per-operation `readAt` guard, which
    * validates only the rows being written. Omit it to check the write targets alone.
    */
   reads?: ReadDependency[] | null;
-  /**
-   * Durable premises to persist for this commit's participant. Each entry is
-   * kept in `track_dependencies` and re-checked against every future delta; a
-   * later match opens a `StaleNotification` delivered out of band. Distinct
-   * from `reads`, which is checked once here and discarded.
-   */
-  track?: TrackDependency[] | null;
 }
 
 /**

package/src/server/index.ts

@@ -26,7 +26,7 @@ export {
   commitExecutionResultSchema,
   commitRecordSchema,
   type CommitRecord,
-} from '../wire/commit.js';
+} from '../commit/contract.js';
 export { storageModeSchema, type StorageMode } from './storageMode.js';
 export type {
   ColumnOverride,

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';