@abloatai/ablo 0.29.3 → 0.30.0

package/dist/source/adapters/kysely.js

@@ -1,212 +1,205 @@
 /**
- * The Kysely adapter for the data-source interface. It implements the same
- * {@link DataSourceAdapter} contract as {@link prismaDataSource} and
- * {@link drizzleDataSource} and passes the same conformance suite, built against
- * Kysely's query builder:
- *   - `db.transaction().execute(async (trx) => …)` runs an interactive transaction.
- *   - `insertInto` / `updateTable` / `deleteFrom` / `selectFrom` with
- *     `returningAll()` form the fluent query. Table and column names are plain
- *     strings, so the adapter needs no raw-SQL tag and imports nothing from
- *     `kysely`; it depends only on the structural {@link KyselyLike} shape, the
- *     same approach the Prisma adapter takes with {@link PrismaLike}.
+ * Kysely wrappers for Ablo's two customer-database write transports.
  *
- * Table and column names come from your schema. Kysely passes the column names you
- * give it straight through to SQL, so, like the Drizzle adapter, this one derives
- * every name from the same rule the table provisioner uses:
- *   table  = `model.tableName ?? key`
- *   column = `fieldMeta.column ?? camelToSnake(field)`  (plus the tenancy column)
- * This keeps the tables `ablo migrate` creates (for example `operator_id`) and the
- * columns this adapter uses in agreement. The adapter is the translation boundary:
- * the rows it accepts and returns are keyed by field name, while the physical
- * columns are snake_case.
+ * Both wrappers compose the same exported {@link createKyselyMutationCore}:
  *
- * A note on JSON columns: the outbox `data` and idempotency `response` values are
- * passed as JSON strings. Postgres infers the parameter type from the target
- * `jsonb` column, so the conversion happens on the server and works across drivers,
- * without the `::jsonb` cast that only raw SQL allows.
+ * - {@link kyselyDataSource} is the endpoint adapter. Its transaction contains
+ *   row DML, the permanent idempotency ledger, and correlated outbox events. A
+ *   Postgres logical marker remains optional for compatibility.
+ * - {@link kyselyDirectMutation} is the engine-side direct wrapper. Its
+ *   transaction contains row DML, the same ledger, and a required logical
+ *   marker. It never creates, writes, or serves `ablo_outbox`.
+ *
+ * The ledger reservation happens before DML via `INSERT ... ON CONFLICT DO
+ * NOTHING`. Postgres waits on a concurrent uncommitted owner of the same key;
+ * after that owner commits, the loser reads and hash-checks its durable response.
+ * If the owner rolls back, the waiter acquires the reservation and performs the
+ * mutation. This gives same-key concurrency one database arbiter and one effect.
  */
 import { AbloValidationError } from '../../errors.js';
-import { outboxEventSchema } from '../contract.js';
-import { adapterTableMigrations } from '../migrations.js';
-import { toSchemaJSON } from '../../schema/serialize.js';
-import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
-import { tenancyColumn } from '../../schema/tenancy.js';
-function rowId(op) {
-    const id = op.id ?? op.input?.id;
-    if (typeof id !== 'string' || id.length === 0) {
-        throw new AbloValidationError(`operation on "${op.model}" requires an id`, {
-            code: 'source_operation_id_required',
-        });
-    }
-    return id;
+import { changeSetSchema, outboxEventSchema, sourceCommitEchoMarkerSchema, } from '../contract.js';
+import { assertSourceIdempotencyIntent, assertSourceIdempotencyRetention, sourceChangeIntentHash, } from '../idempotency.js';
+import { adapterTableMigrations, idempotencyLedgerMigrations, } from '../migrations.js';
+import { ABLO_POSTGRES_COMMIT_ECHO_PREFIX } from '../types.js';
+import { createKyselyMutationCore, kyselyOperationRowId, } from './kyselyMutationCore.js';
+export { createKyselyMutationCore, kyselyOperationRowId, } from './kyselyMutationCore.js';
+function rawQuery(queryId, sql, parameters) {
+    return {
+        query: { kind: 'RawNode', sqlFragments: [sql], parameters: [] },
+        queryId: { queryId },
+        sql,
+        parameters,
+    };
 }
-function buildColumnMaps(schema) {
-    const json = toSchemaJSON(schema);
-    const out = new Map();
-    for (const [key, model] of Object.entries(json.models)) {
-        const fieldToColumn = new Map();
-        const columnToField = new Map();
-        const register = (field, column) => {
-            if (column === camelToSnake(field))
-                return;
-            fieldToColumn.set(field, column);
-            columnToField.set(column, field);
-        };
-        for (const [field, meta] of Object.entries(model.fields)) {
-            if (meta.column)
-                register(field, meta.column);
-        }
-        const orgColumn = tenancyColumn(model.tenancy);
-        if (orgColumn)
-            register('organizationId', orgColumn);
-        out.set(key, { table: model.tableName ?? key, fieldToColumn, columnToField });
+function reserveLedgerQuery(correlationId, requestHash) {
+    return rawQuery('ablo-idempotency-reserve', `INSERT INTO ablo_idempotency (client_tx_id, response, request_hash)
+     VALUES ($1, $2::jsonb, $3)
+     ON CONFLICT (client_tx_id) DO NOTHING
+     RETURNING client_tx_id`, [correlationId, '[]', requestHash]);
+}
+function completeLedgerQuery(correlationId, rows) {
+    return rawQuery('ablo-idempotency-complete', `UPDATE ablo_idempotency
+        SET response = $2::jsonb
+      WHERE client_tx_id = $1`, [correlationId, JSON.stringify(rows)]);
+}
+function postgresLogicalMarkerQuery(payload) {
+    return rawQuery('ablo-postgres-logical-marker', 'SELECT pg_logical_emit_message(true, $1::text, $2::text)', [ABLO_POSTGRES_COMMIT_ECHO_PREFIX, payload]);
+}
+function parseCachedRows(response) {
+    const parsed = typeof response === 'string' ? JSON.parse(response) : response;
+    if (!Array.isArray(parsed)) {
+        throw new AbloValidationError('The source idempotency response is corrupt and cannot be replayed safely', { code: 'idempotency_conflict' });
     }
-    return out;
+    return parsed;
 }
-export function kyselyDataSource(db, schema) {
-    const maps = buildColumnMaps(schema);
-    const modelColumns = (model) => {
-        const mc = maps.get(model);
-        if (!mc) {
-            throw new AbloValidationError(`kyselyDataSource: no model "${model}" in schema`, {
-                code: 'source_adapter_misconfigured',
-            });
+function markerAction(type) {
+    if (type === 'CREATE')
+        return 'I';
+    if (type === 'DELETE')
+        return 'D';
+    return 'U';
+}
+function assertDirectLogicalMarker(change, markerModelFor) {
+    const payload = change.echo?.payload;
+    if (!payload) {
+        throw new AbloValidationError('A direct Kysely mutation requires a transactional Postgres logical marker', { code: 'source_adapter_misconfigured' });
+    }
+    try {
+        const marker = sourceCommitEchoMarkerSchema.parse(JSON.parse(payload));
+        if (marker.correlationId !== change.correlationId) {
+            throw new Error('marker correlation does not match the ledger key');
         }
-        return mc;
-    };
-    const columnFor = (mc, field) => mc.fieldToColumn.get(field) ?? camelToSnake(field);
-    const fieldFor = (mc, column) => mc.columnToField.get(column) ?? snakeToCamel(column);
-    /** Field-keyed row to column-keyed row, for INSERT and UPDATE values. */
-    const toColumns = (mc, row) => {
-        const out = {};
-        for (const k of Object.keys(row))
-            out[columnFor(mc, k)] = row[k];
-        return out;
-    };
-    /** Column-keyed row (from `RETURNING *` or `SELECT *`) back to a field-keyed row. */
-    const toFields = (mc, row) => {
-        const out = {};
-        for (const k of Object.keys(row))
-            out[fieldFor(mc, k)] = row[k];
-        return out;
-    };
-    const applyOperation = async (trx, op) => {
-        const mc = modelColumns(op.model);
-        const id = rowId(op);
-        const input = op.input ?? {};
-        if (op.type === 'DELETE') {
-            const deleted = await trx
-                .deleteFrom(mc.table)
-                .where('id', '=', id)
-                .returningAll()
-                .execute();
-            return deleted[0] ? toFields(mc, deleted[0]) : { id };
+        if (marker.operations.length !== change.operations.length) {
+            throw new Error('marker operation count does not match the mutation');
         }
-        if (op.type === 'CREATE') {
-            const inserted = await trx
-                .insertInto(mc.table)
-                .values(toColumns(mc, { id, ...input }))
-                .returningAll()
-                .execute();
-            return inserted[0] ? toFields(mc, inserted[0]) : { id, ...input };
+        for (const [index, operation] of change.operations.entries()) {
+            const markerOperation = marker.operations[index];
+            // The marker speaks the canonical schema TYPENAME (the vocabulary the
+            // WAL consumer validates deltas against), while the mutation operation
+            // carries the authoring wire key. `markerModelFor` translates the wire
+            // key through the schema so the two vocabularies compare correctly.
+            if (!markerOperation ||
+                markerOperation.model !== markerModelFor(operation.model) ||
+                markerOperation.id !== kyselyOperationRowId(operation) ||
+                markerOperation.action !== markerAction(operation.type) ||
+                markerOperation.transactionId !== operation.transactionId) {
+                throw new Error(`marker operation ${index} does not match the mutation`);
+            }
         }
-        // UPDATE / ARCHIVE / UNARCHIVE — the lifecycle field is `archivedAt`
-        // (camelCase) and goes through `toColumns` like any other, so it lands in
-        // `archived_at` — the same column the provisioner emits.
-        const patch = toColumns(mc, {
-            ...input,
-            ...(op.type === 'ARCHIVE' ? { archivedAt: new Date() } : {}),
-            ...(op.type === 'UNARCHIVE' ? { archivedAt: null } : {}),
-        });
-        const updated = await trx
-            .updateTable(mc.table)
-            .set(patch)
-            .where('id', '=', id)
-            .returningAll()
-            .execute();
-        return updated[0] ? toFields(mc, updated[0]) : { id, ...input };
-    };
+    }
+    catch (error) {
+        if (error instanceof AbloValidationError)
+            throw error;
+        throw new AbloValidationError(`The direct Postgres logical marker is invalid: ${error instanceof Error ? error.message : 'unknown marker error'}`, { code: 'source_adapter_misconfigured' });
+    }
+}
+export function createKyselyMutationAdapter(db, core, mode, options = {}) {
+    const markerModelFor = options.markerModelFor ?? ((model) => model);
     return {
-        capabilities: { transactions: true, propose: false, schemaIntrospection: true },
+        capabilities: {
+            transactions: true,
+            propose: false,
+            schemaIntrospection: true,
+            postgresWalEcho: true,
+            outboxEvents: mode === 'endpoint',
+        },
         migrations() {
-            return adapterTableMigrations();
+            return mode === 'endpoint'
+                ? adapterTableMigrations()
+                : idempotencyLedgerMigrations();
         },
-        async read(req) {
-            const mc = modelColumns(req.model);
-            if (req.kind === 'load') {
-                const rows = await db
-                    .selectFrom(mc.table)
-                    .selectAll()
-                    .where('id', '=', req.id)
-                    .limit(1)
-                    .execute();
-                return rows.map((r) => toFields(mc, r));
-            }
-            const limit = req.query?.limit ?? 1000;
-            const rows = await db.selectFrom(mc.table).selectAll().limit(limit).execute();
-            return rows.map((r) => toFields(mc, r));
+        read(request) {
+            return core.read(request);
         },
         async commit(change) {
-            return db.transaction().execute(async (trx) => {
-                const cached = await trx
-                    .selectFrom('ablo_idempotency')
-                    .selectAll()
-                    .where('client_tx_id', '=', change.clientTxId)
-                    .limit(1)
-                    .execute();
-                const cachedRow = cached[0];
-                if (cachedRow) {
-                    const response = cachedRow.response;
-                    return {
-                        rows: (typeof response === 'string' ? JSON.parse(response) : response),
-                    };
+            const request = changeSetSchema.parse(change);
+            if (mode === 'direct')
+                assertDirectLogicalMarker(request, markerModelFor);
+            const requestHash = sourceChangeIntentHash(request);
+            return db.transaction().execute(async (transaction) => {
+                const reservation = await transaction.executeQuery(reserveLedgerQuery(request.correlationId, requestHash));
+                if (reservation.rows.length === 0) {
+                    const cached = await transaction
+                        .selectFrom('ablo_idempotency')
+                        .selectAll()
+                        .where('client_tx_id', '=', request.correlationId)
+                        .limit(1)
+                        .execute();
+                    const cachedRow = cached[0];
+                    if (!cachedRow) {
+                        throw new AbloValidationError('The source idempotency reservation disappeared during replay', { code: 'idempotency_conflict' });
+                    }
+                    assertSourceIdempotencyIntent(cachedRow.request_hash, requestHash);
+                    assertSourceIdempotencyRetention(cachedRow.expires_at);
+                    return { rows: parseCachedRows(cachedRow.response) };
                 }
                 const rows = [];
-                for (const [index, op] of change.operations.entries()) {
-                    const row = await applyOperation(trx, op);
+                for (const [index, operation] of request.operations.entries()) {
+                    const row = await core.applyOperation(transaction, operation);
                     rows.push(row);
-                    const entityId = String(row.id ?? rowId(op));
-                    await trx
-                        .insertInto('ablo_outbox')
-                        .values({
-                        id: `${change.clientTxId}:${index}`,
-                        model: op.model,
-                        entity_id: entityId,
-                        type: op.type,
-                        data: op.type === 'DELETE' ? null : JSON.stringify(row),
-                        client_tx_id: change.clientTxId,
-                        occurred_at: Date.now(),
-                    })
-                        .execute();
+                    if (mode === 'endpoint') {
+                        const entityId = String(row.id ?? kyselyOperationRowId(operation));
+                        await transaction
+                            .insertInto('ablo_outbox')
+                            .values({
+                            id: `${request.correlationId}:${index}`,
+                            model: operation.model,
+                            entity_id: entityId,
+                            type: operation.type,
+                            data: operation.type === 'DELETE' ? null : JSON.stringify(row),
+                            correlation_id: request.correlationId,
+                            transaction_id: operation.transactionId ?? null,
+                            occurred_at: Date.now(),
+                        })
+                            .execute();
+                    }
+                }
+                await transaction.executeQuery(completeLedgerQuery(request.correlationId, rows));
+                if (request.echo?.kind === 'postgres-wal') {
+                    await transaction.executeQuery(postgresLogicalMarkerQuery(request.echo.payload));
                 }
-                await trx
-                    .insertInto('ablo_idempotency')
-                    .values({ client_tx_id: change.clientTxId, response: JSON.stringify(rows) })
-                    .execute();
                 return { rows };
             });
         },
+    };
+}
+/** Endpoint wrapper: mutation + ledger + outbox, with an optional marker. */
+export function kyselyDataSource(db, schema) {
+    const mutation = createKyselyMutationAdapter(db, createKyselyMutationCore(db, schema), 'endpoint');
+    return {
+        ...mutation,
+        capabilities: { ...mutation.capabilities, outboxEvents: true },
         async events(cursor, limit) {
-            const after = cursor ?? '0';
             const rows = await db
                 .selectFrom('ablo_outbox')
                 .selectAll()
-                .where('cursor', '>', after)
+                .where('cursor', '>', cursor ?? '0')
                 .orderBy('cursor', 'asc')
                 .limit(limit)
                 .execute();
-            const events = rows.map((r) => outboxEventSchema.parse({
-                id: r.id,
-                model: r.model,
-                entityId: r.entity_id,
-                type: r.type,
-                data: typeof r.data === 'string' ? JSON.parse(r.data) : r.data ?? null,
-                organizationId: r.organization_id ?? null,
-                clientTxId: r.client_tx_id ?? null,
-                occurredAt: r.occurred_at != null ? Number(r.occurred_at) : null,
-                cursor: String(r.cursor),
+            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,
+                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),
             }));
             return { events, nextCursor: events.at(-1)?.cursor ?? null };
         },
     };
 }
+/** Direct wrapper: mutation + ledger + required logical marker, never outbox. */
+export function kyselyDirectMutation(db, schema) {
+    return createKyselyMutationAdapter(db, createKyselyMutationCore(db, schema), 'direct', {
+        markerModelFor: (operationModel) => {
+            const typename = schema.models[operationModel]?.typename;
+            return typename && typename.length > 0 ? typename : operationModel;
+        },
+    });
+}

package/dist/source/adapters/kyselyMutationCore.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Reusable Kysely row-mutation core.
+ *
+ * This is the single schema-field ↔ physical-column translation used by both
+ * Kysely transports. It deliberately knows nothing about outboxes, logical
+ * markers, or idempotency: wrappers compose those transaction policies around
+ * the same `applyOperation` implementation, so direct and endpoint DML cannot
+ * drift into separate hand-written mappers.
+ */
+import type { Schema, SchemaRecord } from '../../schema/schema.js';
+import type { AdapterReadRequest, Row } from '../adapter.js';
+import type { Operation } from '../contract.js';
+/** The subset of a Kysely instance, or transaction handle, used by the core. */
+export interface KyselyLike {
+    selectFrom(table: string): KyselySelectBuilder;
+    insertInto(table: string): KyselyInsertBuilder;
+    updateTable(table: string): KyselyUpdateBuilder;
+    deleteFrom(table: string): KyselyDeleteBuilder;
+    /** Execute a precompiled raw query on this exact transaction handle. */
+    executeQuery(query: KyselyCompiledQuery): Promise<{
+        readonly rows: readonly Row[];
+    }>;
+    transaction(): KyselyTransactionBuilder;
+}
+/** Structural slice of Kysely's public `CompiledQuery` shape. */
+export interface KyselyCompiledQuery {
+    readonly query: {
+        readonly kind: 'RawNode';
+        readonly sqlFragments: readonly string[];
+        readonly parameters: readonly [];
+    };
+    readonly queryId: {
+        readonly queryId: string;
+    };
+    readonly sql: string;
+    readonly parameters: readonly unknown[];
+}
+export interface KyselyTransactionBuilder {
+    execute<T>(fn: (trx: KyselyLike) => Promise<T>): Promise<T>;
+}
+export interface KyselySelectBuilder {
+    selectAll(): KyselySelectBuilder;
+    where(column: string, operator: string, value: unknown): KyselySelectBuilder;
+    orderBy(column: string, direction: 'asc' | 'desc'): KyselySelectBuilder;
+    limit(limit: number): KyselySelectBuilder;
+    execute(): Promise<readonly Row[]>;
+}
+export interface KyselyReturningExecutable {
+    execute(): Promise<readonly Row[]>;
+}
+export interface KyselyInsertBuilder {
+    values(row: Row): KyselyInsertValuesBuilder;
+}
+export interface KyselyInsertValuesBuilder {
+    returningAll(): KyselyReturningExecutable;
+    execute(): Promise<unknown>;
+}
+export interface KyselyUpdateBuilder {
+    set(patch: Row): KyselyUpdateSetBuilder;
+}
+export interface KyselyUpdateSetBuilder {
+    where(column: string, operator: string, value: unknown): KyselyUpdateSetBuilder;
+    returningAll(): KyselyReturningExecutable;
+}
+export interface KyselyDeleteBuilder {
+    where(column: string, operator: string, value: unknown): KyselyDeleteBuilder;
+    returningAll(): KyselyReturningExecutable;
+}
+/** Resolve the stable row id required by every source operation. */
+export declare function kyselyOperationRowId(operation: Operation): string;
+/** The transport-independent Kysely field/column mutation boundary. */
+export interface KyselyMutationCore {
+    read(request: AdapterReadRequest): Promise<readonly Row[]>;
+    applyOperation(transaction: KyselyLike, operation: Operation): Promise<Row>;
+}
+export declare function createKyselyMutationCore<S extends SchemaRecord>(db: KyselyLike, schema: Schema<S>): KyselyMutationCore;

package/dist/source/adapters/kyselyMutationCore.js

@@ -0,0 +1,125 @@
+/**
+ * Reusable Kysely row-mutation core.
+ *
+ * This is the single schema-field ↔ physical-column translation used by both
+ * Kysely transports. It deliberately knows nothing about outboxes, logical
+ * markers, or idempotency: wrappers compose those transaction policies around
+ * the same `applyOperation` implementation, so direct and endpoint DML cannot
+ * drift into separate hand-written mappers.
+ */
+import { AbloValidationError } from '../../errors.js';
+import { toSchemaJSON } from '../../schema/serialize.js';
+import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
+import { tenancyColumn } from '../../schema/tenancy.js';
+function buildColumnMaps(schema) {
+    const json = toSchemaJSON(schema);
+    const out = new Map();
+    for (const [key, model] of Object.entries(json.models)) {
+        const fieldToColumn = new Map();
+        const columnToField = new Map();
+        const register = (field, column) => {
+            if (column === camelToSnake(field))
+                return;
+            fieldToColumn.set(field, column);
+            columnToField.set(column, field);
+        };
+        for (const [field, meta] of Object.entries(model.fields)) {
+            if (meta.column)
+                register(field, meta.column);
+        }
+        const orgColumn = tenancyColumn(model.tenancy);
+        if (orgColumn)
+            register('organizationId', orgColumn);
+        out.set(key, {
+            table: model.tableName ?? key,
+            fieldToColumn,
+            columnToField,
+        });
+    }
+    return out;
+}
+/** Resolve the stable row id required by every source operation. */
+export function kyselyOperationRowId(operation) {
+    const id = operation.id ?? operation.input?.id;
+    if (typeof id !== 'string' || id.length === 0) {
+        throw new AbloValidationError(`operation on "${operation.model}" requires an id`, { code: 'source_operation_id_required' });
+    }
+    return id;
+}
+export function createKyselyMutationCore(db, schema) {
+    const maps = buildColumnMaps(schema);
+    const modelColumns = (model) => {
+        const columns = maps.get(model);
+        if (!columns) {
+            throw new AbloValidationError(`kysely mutation core: no model "${model}" in schema`, { code: 'source_adapter_misconfigured' });
+        }
+        return columns;
+    };
+    const columnFor = (columns, field) => columns.fieldToColumn.get(field) ?? camelToSnake(field);
+    const fieldFor = (columns, column) => columns.columnToField.get(column) ?? snakeToCamel(column);
+    const toColumns = (columns, row) => {
+        const out = {};
+        for (const key of Object.keys(row))
+            out[columnFor(columns, key)] = row[key];
+        return out;
+    };
+    const toFields = (columns, row) => {
+        const out = {};
+        for (const key of Object.keys(row))
+            out[fieldFor(columns, key)] = row[key];
+        return out;
+    };
+    return {
+        async read(request) {
+            const columns = modelColumns(request.model);
+            if (request.kind === 'load') {
+                const rows = await db
+                    .selectFrom(columns.table)
+                    .selectAll()
+                    .where('id', '=', request.id)
+                    .limit(1)
+                    .execute();
+                return rows.map((row) => toFields(columns, row));
+            }
+            const rows = await db
+                .selectFrom(columns.table)
+                .selectAll()
+                .limit(request.query?.limit ?? 1000)
+                .execute();
+            return rows.map((row) => toFields(columns, row));
+        },
+        async applyOperation(transaction, operation) {
+            const columns = modelColumns(operation.model);
+            const id = kyselyOperationRowId(operation);
+            const input = operation.input ?? {};
+            if (operation.type === 'DELETE') {
+                const deleted = await transaction
+                    .deleteFrom(columns.table)
+                    .where('id', '=', id)
+                    .returningAll()
+                    .execute();
+                return deleted[0] ? toFields(columns, deleted[0]) : { id };
+            }
+            if (operation.type === 'CREATE') {
+                const inserted = await transaction
+                    .insertInto(columns.table)
+                    .values(toColumns(columns, { id, ...input }))
+                    .returningAll()
+                    .execute();
+                return inserted[0] ? toFields(columns, inserted[0]) : { id, ...input };
+            }
+            const patch = toColumns(columns, {
+                ...input,
+                ...(operation.type === 'ARCHIVE' ? { archivedAt: new Date() } : {}),
+                ...(operation.type === 'UNARCHIVE' ? { archivedAt: null } : {}),
+            });
+            const updated = await transaction
+                .updateTable(columns.table)
+                .set(patch)
+                .where('id', '=', id)
+                .returningAll()
+                .execute();
+            return updated[0] ? toFields(columns, updated[0]) : { id, ...input };
+        },
+    };
+}

package/dist/source/adapters/memory.d.ts

@@ -6,7 +6,7 @@
  * 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 `clientTxId`, and an append-only outbox with a
+ * idempotency ledger keyed by scoped correlation, and an append-only outbox with a
  * monotonic cursor.
  */
 import type { DataSourceAdapter } from '../adapter.js';