@abloatai/humans 0.56.0 → 0.58.0

package/dist/local/transactions/mutations/MutationQueue.js

@@ -14,19 +14,17 @@
 import { EventEmitter } from 'events';
 import { v4 as uuid } from 'uuid';
 import { globalRuntime } from '../../context.js';
-import { AbloError, AbloConnectionError, AbloIdempotencyError, AbloNotFoundError, AbloValidationError, errorCodeSpec, } from '@abloatai/transaction/errors';
+import { AbloConnectionError, AbloIdempotencyError, } from '@abloatai/transaction/errors';
 import { LogPosition, } from '../../logPosition.js';
-import { mutationCommitResultSchema, } from '@abloatai/transaction/wire/commit';
-import { projectCommitPayload, computePriorityScore, normalizeModelKey, 
-// Includes stale guards as well as request identity/audit barriers.
-hasCommitCoalescingBarrier, applyWriteOptions, asTransportError, extractStatusCode, TX_TYPE_TO_MUTATION_OP, } from './commitPayload.js';
+import {} from '@abloatai/transaction/commit';
+import { computePriorityScore, normalizeModelKey, } from './commitPayload.js';
+import { generateTransactionId, mergeMutationData, createDataFor, changesToInput, updateDataFor, previousDataFor, } from './mutationInput.js';
 import { MutationStore } from './MutationStore.js';
-import { entityKey, mergeUpdateData, takeUnsentCreateForModel, findCreateBarrierForDelete, deferDeleteUntilCreateSettles, releaseDeferredDeletesForCreate, } from './coalesceRules.js';
+import { entityKey, takeUnsentCreateForModel, findCreateBarrierForDelete, deferDeleteUntilCreateSettles, releaseDeferredDeletesForCreate, } from './coalesceRules.js';
 import { DeltaConfirmationTracker } from './deltaConfirmation.js';
-import { deserializePersistedTransaction, isNonReplayablePersistedRow, pendingMutationRecordId, legacyPendingMutationRecordSchema, pendingMutationRecordSchema, persistedMutationSchema, } from './replayValidation.js';
+import { deserializePersistedTransaction, isNonReplayablePersistedRow, pendingMutationRecordId, } from './replayValidation.js';
 import { deserializeLegacyPendingMutation, loadPersistedTransactions, persistQueuedTransaction, removePersistedTransaction, settlePersistedFailure, } from './mutationPersistence.js';
-import { createCommitEnvelopeMember, createDurableCommitEnvelope, commitEnvelopeRecordId, durableCommitEnvelopeSchema, } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
-import { stableStringify } from '@abloatai/transaction/utils/json';
+import { createCommitEnvelopeMember, } from '@abloatai/transaction/commit';
 import { createLocalMutationPort, } from './localMutation.js';
 import { dispatchCommitBounded, parseMutationCommitResult, persistDurableCommitAcceptance, removeDurableCommit, sealDurableCommit, } from './commitTransport.js';
 import { processCommitLane, waitForCommitReceipt, } from './commitLane.js';
@@ -120,7 +118,7 @@ export class MutationQueue extends EventEmitter {
             commitOutbox: this.commitOutbox,
             commitOutboxScope: this.commitOutboxScope,
             mutationExecutor: this.mutationExecutor,
-            emitCommitLifecycle: (event, payload) => this.emitCommitLifecycle(event, payload),
+            emitCommitLifecycle: (event, payload) => { this.emitCommitLifecycle(event, payload); },
         };
     }
     get commitLaneContext() {
@@ -132,24 +130,22 @@ export class MutationQueue extends EventEmitter {
                 retryBackoff: this.config.retryBackoff,
             },
             commitLane: this.commitLane,
-            commitNotifications: this.commitNotifications,
             commitMissingIds: this.commitMissingIds,
             commitProcessing: this.commitProcessing,
             setCommitProcessing: (value) => { this.commitProcessing = value; },
             durableReplayBlock: this.durableReplayBlock,
             sealDurableCommit: (input) => this.sealDurableCommit(input),
-            assertEnvelopeInsideReplayWindow: (envelope) => this.assertEnvelopeInsideReplayWindow(envelope),
+            assertEnvelopeInsideReplayWindow: (envelope) => { this.assertEnvelopeInsideReplayWindow(envelope); },
             dispatchCommit: async (envelope) => this.parseMutationCommitResult(await this.dispatchCommitBounded(envelope.operations, {
                 idempotencyKey: envelope.idempotencyKey,
                 ...(envelope.commitOptions.reads ? { reads: envelope.commitOptions.reads } : {}),
-                ...(envelope.commitOptions.track ? { track: envelope.commitOptions.track } : {}),
             })),
             persistDurableCommitAcceptance: (envelope, result) => this.persistDurableCommitAcceptance(envelope, result),
             removeDurableCommit: (idempotencyKey) => this.removeDurableCommit(idempotencyKey),
             queuedCommitEchoSyncId: (transaction) => this.queuedCommitEchoSyncId(transaction),
-            completeQueuedCommit: (transaction, syncId) => this.completeQueuedCommit(transaction, syncId),
-            scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId),
-            noteAck: (syncId) => this.noteAck(syncId),
+            completeQueuedCommit: (transaction, syncId) => { this.completeQueuedCommit(transaction, syncId); },
+            scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => { this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId); },
+            noteAck: (syncId) => { this.noteAck(syncId); },
             isDefinitiveRejection: (error) => this.isDefinitiveRejection(error),
             isPermanentError: (error) => this.isPermanentError(error),
             scheduleRetry: (delayMs) => {
@@ -160,13 +156,12 @@ export class MutationQueue extends EventEmitter {
                     void this.processCommitLane();
                 }, delayMs);
             },
-            emitCommitLifecycle: (event, payload) => this.emitCommitLifecycle(event, payload),
+            emitCommitLifecycle: (event, payload) => { this.emitCommitLifecycle(event, payload); },
         };
     }
     get commitReceiptContext() {
         return {
             commitStore: this.commitStore,
-            commitNotifications: this.commitNotifications,
             commitMissingIds: this.commitMissingIds,
             replicationLagErrors: this.replicationLagErrors,
             on: (event, listener) => this.on(event, listener),
@@ -175,22 +170,22 @@ export class MutationQueue extends EventEmitter {
     }
     get commitApiContext() {
         return {
-            assertDurableReplayOpen: () => this.assertDurableReplayOpen(),
+            assertDurableReplayOpen: () => { this.assertDurableReplayOpen(); },
             commitStore: this.commitStore,
             commitLane: this.commitLane,
             replicationLagErrors: this.replicationLagErrors,
-            clearReplicationLagState: (transactionId) => this.clearReplicationLagState(transactionId),
+            clearReplicationLagState: (transactionId) => { this.clearReplicationLagState(transactionId); },
             nextCommitSequence: () => this.nextCommitSequence(),
             sealDurableCommit: (input) => this.sealDurableCommit(input),
             processCommitLane: () => this.processCommitLane(),
-            emitCommitLifecycle: (event, payload) => this.emitCommitLifecycle(event, payload),
+            emitCommitLifecycle: (event, payload) => { this.emitCommitLifecycle(event, payload); },
         };
     }
     get modelMutationContext() {
         return {
             enableOptimistic: this.config.enableOptimistic,
             persistenceReady: !!this.persistence && !!this.commitOutboxScope,
-            assertDurableReplayOpen: () => this.assertDurableReplayOpen(),
+            assertDurableReplayOpen: () => { this.assertDurableReplayOpen(); },
             generateId: () => this.generateId(),
             normalizeModelKey,
             computePriorityScore: (type, modelName) => this.computePriorityScore(type, modelName),
@@ -199,11 +194,11 @@ export class MutationQueue extends EventEmitter {
             extractPreviousData: (model, input) => this.extractPreviousData(model, input),
             mapChangesToInput: (modelName, changes) => this.mapChangesToInput(modelName, changes),
             isReorderPayload: (input) => this.isReorderPayload(input),
-            attachConfirmation: (transaction) => this.attachConfirmation(transaction),
-            add: (transaction) => this.store.add(transaction),
-            applyOptimisticCreate: (model, transaction) => this.applyOptimisticCreate(model, transaction),
-            applyOptimisticUpdate: (model, transaction) => this.applyOptimisticUpdate(model, transaction),
-            applyOptimisticDelete: (model, transaction) => this.applyOptimisticDelete(model, transaction),
+            attachConfirmation: (transaction) => { this.attachConfirmation(transaction); },
+            add: (transaction) => { this.store.add(transaction); },
+            applyOptimisticCreate: (model, transaction) => { this.applyOptimisticCreate(model, transaction); },
+            applyOptimisticUpdate: (model, transaction) => { this.applyOptimisticUpdate(model, transaction); },
+            applyOptimisticDelete: (model, transaction) => { this.applyOptimisticDelete(model, transaction); },
             takeUnsentCreateForModel: (modelName, modelId) => this.takeUnsentCreateForModel(modelName, modelId),
             cancelUnsentCreateForDelete: (transaction) => this.cancelUnsentCreateForDelete(transaction),
             completeLocalDelete: (model, context, writeOptions, sourceMutationIds) => this.completeLocalDelete(model, context, writeOptions, sourceMutationIds),
@@ -211,11 +206,11 @@ export class MutationQueue extends EventEmitter {
             pendingMergeByModel: this.pendingMergeByModel,
             inFlightByModel: this.inFlightByModel,
             findCreateBarrierForDelete: (modelName, modelId) => this.findCreateBarrierForDelete(modelName, modelId),
-            deferDeleteUntilCreateSettles: (create, transaction) => this.deferDeleteUntilCreateSettles(create, transaction),
+            deferDeleteUntilCreateSettles: (create, transaction) => { this.deferDeleteUntilCreateSettles(create, transaction); },
             logger: this.runtime.logger,
             persistAndStage: (transaction, modelData) => this.persistAndStage(transaction, modelData),
             persistQueuedTransaction: (transaction, modelData) => this.persistQueuedTransaction(transaction, modelData),
-            stageTransaction: (transaction) => this.stageTransaction(transaction),
+            stageTransaction: (transaction) => { this.stageTransaction(transaction); },
             emit: (event, payload) => this.emit(event, payload),
         };
     }
@@ -224,9 +219,9 @@ export class MutationQueue extends EventEmitter {
             executionQueue: this.executionQueue,
             inFlightByModel: this.inFlightByModel,
             pendingMergeByModel: this.pendingMergeByModel,
-            ensureDerivedFields: (transaction) => this.ensureDerivedFields(transaction),
-            scheduleProcessing: (immediate) => this.scheduleProcessing(immediate),
-            storeRemove: (transactionId) => this.store.remove(transactionId),
+            ensureDerivedFields: (transaction) => { this.ensureDerivedFields(transaction); },
+            scheduleProcessing: (immediate) => { this.scheduleProcessing(immediate); },
+            storeRemove: (transactionId) => { this.store.remove(transactionId); },
         };
     }
     get batchProcessingContext() {
@@ -238,7 +233,7 @@ export class MutationQueue extends EventEmitter {
             isProcessing: this.isProcessing,
             setIsProcessing: (value) => { this.isProcessing = value; },
             takeNextExecutionBatch: () => this.takeNextExecutionBatch(),
-            ensureDerivedFields: (transaction) => this.ensureDerivedFields(transaction),
+            ensureDerivedFields: (transaction) => { this.ensureDerivedFields(transaction); },
             ensureCommitEnvelope: (batch) => this.ensureCommitEnvelope([...batch]),
             executingCount: this.executingCount,
             setExecutingCount: (value) => { this.executingCount = value; },
@@ -247,31 +242,28 @@ export class MutationQueue extends EventEmitter {
             generateId: () => this.generateId(),
             computePriorityScore: (type, modelName) => this.computePriorityScore(type, modelName),
             store: this.store,
-            enqueue: (transaction) => this.enqueue(transaction),
+            enqueue: (transaction) => { this.enqueue(transaction); },
             optimisticUpdates: this.localMutationPort.updates,
-            commitNotifications: this.commitNotifications,
             commitMissingIds: this.commitMissingIds,
             sourceMutationIdsFor: (batch) => this.sourceMutationIdsFor(batch),
             dispatchCommitBounded: (...args) => this.dispatchCommitBounded(...args),
             parseMutationCommitResult: (value) => this.parseMutationCommitResult(value),
             persistDurableCommitAcceptance: (envelope, result) => this.persistDurableCommitAcceptance(envelope, result),
             removeDurableCommit: (idempotencyKey) => this.removeDurableCommit(idempotencyKey),
-            assertEnvelopeInsideReplayWindow: (envelope) => this.assertEnvelopeInsideReplayWindow(envelope),
+            assertEnvelopeInsideReplayWindow: (envelope) => { this.assertEnvelopeInsideReplayWindow(envelope); },
             sealDurableCommit: (input) => this.sealDurableCommit(input),
-            noteAck: (syncId) => this.noteAck(syncId),
-            classifyReceiptNotifications: (operations, notifications) => this.classifyReceiptNotifications(operations, notifications),
-            receiptTargetKey: (modelName, modelId) => this.receiptTargetKey(modelName, modelId),
-            scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId),
-            scheduleDeltaConfirmationTimeout: (transaction, timeoutMs) => this.scheduleDeltaConfirmationTimeout(transaction, timeoutMs),
-            clearReplicationLagState: (transactionId) => this.clearReplicationLagState(transactionId),
-            completeQueuedCommit: (transaction, syncId) => this.completeQueuedCommit(transaction, syncId),
+            noteAck: (syncId) => { this.noteAck(syncId); },
+            scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => { this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId); },
+            scheduleDeltaConfirmationTimeout: (transaction, timeoutMs) => { this.scheduleDeltaConfirmationTimeout(transaction, timeoutMs); },
+            clearReplicationLagState: (transactionId) => { this.clearReplicationLagState(transactionId); },
+            completeQueuedCommit: (transaction, syncId) => { this.completeQueuedCommit(transaction, syncId); },
             queuedCommitMatchesCorrelation: (transaction, correlationId) => this.queuedCommitMatchesCorrelation(transaction, correlationId),
             recentDeltaCorrelations: this.recentDeltaCorrelations,
             lastSeenSyncId: this.lastSeenSyncId,
-            scheduleProcessing: (immediate) => this.scheduleProcessing(immediate),
+            scheduleProcessing: (immediate) => { this.scheduleProcessing(immediate); },
             handleFailure: (transaction, error) => this.handleFailure(transaction, error),
             isDefinitiveRejection: (error) => this.isDefinitiveRejection(error),
-            emitCommitLifecycle: (event, payload) => this.emitCommitLifecycle(event, payload),
+            emitCommitLifecycle: (event, payload) => { this.emitCommitLifecycle(event, payload); },
             emit: (event, payload) => this.emit(event, payload),
             rollbackOptimistic: (transaction, reason, error) => this.rollbackOptimistic(transaction, reason, error),
         };
@@ -283,19 +275,19 @@ export class MutationQueue extends EventEmitter {
             store: this.store,
             isPermanentError: (error) => this.isPermanentError(error),
             rollbackOptimistic: (transaction, reason, error) => this.rollbackOptimistic(transaction, reason, error),
-            enqueue: (transaction) => this.enqueue(transaction),
+            enqueue: (transaction) => { this.enqueue(transaction); },
             getLastPermanentErrorSignature: () => this.lastPermanentErrorSig,
             setLastPermanentErrorSignature: (signature) => { this.lastPermanentErrorSig = signature; },
             emit: (event, payload) => this.emit(event, payload),
         };
     }
-    get conflictPolicyContext() {
+    get conflictResolutionContext() {
         return {
             config: this.config,
             store: this.store,
             rollbackOptimistic: (transaction, reason) => this.rollbackOptimistic(transaction, reason),
             mergeData: (local, remote) => this.mergeData(local, remote),
-            enqueue: (transaction) => this.enqueue(transaction),
+            enqueue: (transaction) => { this.enqueue(transaction); },
         };
     }
     get processingSchedulerContext() {
@@ -318,21 +310,21 @@ export class MutationQueue extends EventEmitter {
             store: this.store,
             executionQueue: this.executionQueue,
             optimisticUpdates: this.localMutationPort.updates,
-            assertDurableReplayOpen: () => this.assertDurableReplayOpen(),
+            assertDurableReplayOpen: () => { this.assertDurableReplayOpen(); },
             processCommitLane: () => this.processCommitLane(),
             takePendingDrainBatch: (pending) => this.takePendingDrainBatch(pending),
             ensureCommitEnvelope: (batch) => this.ensureCommitEnvelope(batch),
-            ensureDerivedFields: (transaction) => this.ensureDerivedFields(transaction),
+            ensureDerivedFields: (transaction) => { this.ensureDerivedFields(transaction); },
             sourceMutationIdsFor: (batch) => this.sourceMutationIdsFor(batch),
             sealDurableCommit: (input) => this.sealDurableCommit(input),
-            assertEnvelopeInsideReplayWindow: (envelope) => this.assertEnvelopeInsideReplayWindow(envelope),
+            assertEnvelopeInsideReplayWindow: (envelope) => { this.assertEnvelopeInsideReplayWindow(envelope); },
             parseMutationCommitResult: (value) => this.parseMutationCommitResult(value),
             dispatchCommitBounded: (...args) => this.dispatchCommitBounded(...args),
             persistDurableCommitAcceptance: (envelope, result) => this.persistDurableCommitAcceptance(envelope, result),
             removeDurableCommit: (idempotencyKey) => this.removeDurableCommit(idempotencyKey),
-            scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId),
-            scheduleDeltaConfirmationTimeout: (transaction, timeoutMs) => this.scheduleDeltaConfirmationTimeout(transaction, timeoutMs),
-            enqueue: (transaction) => this.enqueue(transaction),
+            scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => { this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId); },
+            scheduleDeltaConfirmationTimeout: (transaction, timeoutMs) => { this.scheduleDeltaConfirmationTimeout(transaction, timeoutMs); },
+            enqueue: (transaction) => { this.enqueue(transaction); },
             recentDeltaCorrelations: this.recentDeltaCorrelations,
             emit: (event, payload) => this.emit(event, payload),
         };
@@ -356,7 +348,7 @@ export class MutationQueue extends EventEmitter {
             commitOutboxScope: this.commitOutboxScope,
             config: this.config,
             store: this.store,
-            enqueue: (transaction) => this.enqueue(transaction),
+            enqueue: (transaction) => { this.enqueue(transaction); },
             computePriorityScore: (type, modelName) => this.computePriorityScore(type, modelName),
             deserializeTransaction: (data) => this.deserializeTransaction(data),
         };
@@ -410,59 +402,7 @@ export class MutationQueue extends EventEmitter {
     entityKey(modelName, modelId) {
         return entityKey(modelName, modelId);
     }
-    /** Collision-safe receipt target identity across models sharing a row id. */
-    receiptTargetKey(modelName, modelId) {
-        return stableStringify([normalizeModelKey(modelName), modelId]);
-    }
-    /**
-     * Relates stale notifications back to write targets without assuming the
-     * server's canonical model name uses the same spelling as the public schema
-     * key (`Item` versus `items`). Exact `(model,id)` wins; a globally unique id
-     * is the compatibility fallback. An ambiguous same-id cross-model mismatch
-     * is deliberately left unclassified, so it cannot falsely settle a queued
-     * write. A notification with no write-target id (or an explicit group) is a
-     * declared-read conflict and holds the whole batch.
-     */
-    classifyReceiptNotifications(operations, notifications) {
-        const targets = operations.map((operation) => ({
-            id: operation.id,
-            key: this.receiptTargetKey(operation.model, operation.id),
-        }));
-        const heldTargets = new Set();
-        const notificationsByTarget = new Map();
-        let holdsEntireBatch = false;
-        for (const notification of notifications) {
-            // Scope is decided before any target matching. A group premise fires over
-            // the WHOLE batch by convention, and its `target` now names the row that
-            // actually moved — which may well be a row this batch is writing, so
-            // matching first would misread a batch-wide hold as a per-row one.
-            if (notification.scope === 'group') {
-                holdsEntireBatch = true;
-                continue;
-            }
-            const candidates = targets.filter((target) => target.id === notification.target.id);
-            const notificationKey = this.receiptTargetKey(notification.target.model, notification.target.id);
-            const exactTargets = candidates.filter((target) => target.key === notificationKey);
-            const candidateKeys = new Set((exactTargets.length > 0 ? exactTargets : candidates).map((target) => target.key));
-            if (candidates.length === 0) {
-                holdsEntireBatch = true;
-                continue;
-            }
-            if (candidateKeys.size !== 1) {
-                // Same id across multiple differently named models with no exact match:
-                // the id-only compatibility fallback is ambiguous. Await the echo.
-                continue;
-            }
-            const [targetKey] = candidateKeys;
-            if (!targetKey)
-                continue;
-            heldTargets.add(targetKey);
-            const targetNotifications = notificationsByTarget.get(targetKey) ?? [];
-            targetNotifications.push(notification);
-            notificationsByTarget.set(targetKey, targetNotifications);
-        }
-        return { holdsEntireBatch, heldTargets, notificationsByTarget };
-    }
+    /* Stale receipt classification was removed; stale premises now reject. */
     resolveConfirmation(transaction) {
         const resolver = this.confirmationResolvers.get(transaction.id);
         if (!resolver)
@@ -544,11 +484,6 @@ export class MutationQueue extends EventEmitter {
     // Track executing transactions for backpressure
     executingCount = 0;
     localMutationPort;
-    // Stale-context notifications, keyed by transaction id. When the server
-    // accepts a commit but reports that an operation's premise had moved,
-    // the notification lands here from the commit acknowledgement and is drained
-    // by `waitForCommitReceipt`, so the receipt can carry it back to the caller.
-    commitNotifications = new Map();
     /** Zero-row targets returned on a successful atomic commit receipt. */
     commitMissingIds = new Map();
     // Delta-confirmation tracking (ack watermark advance + the awaiting_delta
@@ -1267,7 +1202,7 @@ export class MutationQueue extends EventEmitter {
         await handleFailure(this.failureHandlingContext, transaction, error);
     }
     async handleConflict(transaction, serverData) {
-        await resolveConflict(this.conflictPolicyContext, transaction, serverData);
+        await resolveConflict(this.conflictResolutionContext, transaction, serverData);
     }
     applyOptimisticCreate(model, transaction) {
         this.localMutationPort.applyCreate(model, transaction);
@@ -1390,39 +1325,25 @@ export class MutationQueue extends EventEmitter {
         ];
     }
     /** Generates a unique local transaction id. */
+    // The payload rules live in `mutationInput`; these keep the call sites here
+    // reading as the queue's own vocabulary.
     generateId() {
-        return `tx_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+        return generateTransactionId();
     }
     mergeData(local, remote) {
-        return { ...(remote || {}), ...(local || {}) };
+        return mergeMutationData(local, remote);
     }
     extractCreateData(model) {
-        return projectCommitPayload(model.getModelName(), model.toJSON(), { dropUndefined: false }, this.runtime);
+        return createDataFor(model, this.runtime);
     }
     mapChangesToInput(modelName, changes) {
-        return projectCommitPayload(modelName, changes, { dropUndefined: true }, this.runtime);
+        return changesToInput(modelName, changes, this.runtime);
     }
     extractUpdateData(model) {
-        return projectCommitPayload(model.getModelName(), model.getChanges(), { dropUndefined: true }, this.runtime);
+        return updateDataFor(model, this.runtime);
     }
-    // Derive previous values for changed fields to support accurate rollback.
-    // Model-specific special cases do not belong here; a model that needs to
-    // surface previous state beyond `modifiedProperties` should expose a typed
-    // `getPreviousData()` accessor for this method to call.
     extractPreviousData(model, updateInput) {
-        // When the update's written keys are known, capture a before-image for
-        // exactly those keys, so the recorded undo inverse reverts them and nothing
-        // else — a full-row inverse would clobber concurrent edits to unrelated
-        // fields. `fallbackToLive: false` makes `Model.capturePreviousValues` omit
-        // any key it cannot resolve, and `buildUndoOps` then drops an un-revertible
-        // inverse rather than inventing one. With no `updateInput` (a full extract)
-        // it falls back to every tracked field. `Model.capturePreviousValues` is the
-        // single before-image source, shared with
-        // `RecordingMutation.snapshotFields`.
-        const keys = updateInput
-            ? Object.keys(updateInput)
-            : [...(model.modifiedProperties instanceof Map ? model.modifiedProperties.keys() : [])];
-        return { id: model.id, ...model.capturePreviousValues(keys, { fallbackToLive: false }) };
+        return previousDataFor(model, updateInput);
     }
     /** Returns a snapshot of queue counts and the current configuration. */
     getStats() {
@@ -1533,7 +1454,6 @@ export class MutationQueue extends EventEmitter {
         this.recentDeltaCorrelations.clear();
         this.commitLane = [];
         this.commitStore.clear();
-        this.commitNotifications.clear();
         this.commitMissingIds.clear();
         // Clear event listeners
         this.removeAllListeners();

package/dist/local/transactions/mutations/batchProcessing.d.ts

@@ -3,9 +3,8 @@ import type { MutationQueueConfig } from './MutationQueue.js';
 import type { MutationInput, QueuedMutation } from './commitPayload.js';
 import type { MutationStore } from './MutationStore.js';
 import type { OptimisticUpdateEntry } from './localMutation.js';
-import type { StaleNotification } from '@abloatai/transaction/coordination/schema';
-import type { MutationCommitResult } from '@abloatai/transaction/wire/commit';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { MutationCommitResult } from '@abloatai/transaction/commit';
+import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
 export interface BatchProcessingContext {
     readonly runtime: RuntimeContext;
     readonly config: MutationQueueConfig;
@@ -28,7 +27,6 @@ export interface BatchProcessingContext {
     readonly store: MutationStore;
     readonly enqueue: (transaction: QueuedMutation) => void;
     readonly optimisticUpdates: Map<string, OptimisticUpdateEntry>;
-    readonly commitNotifications: Map<string, StaleNotification[]>;
     readonly commitMissingIds: Map<string, string[]>;
     readonly sourceMutationIdsFor: (batch: readonly QueuedMutation[]) => string[];
     readonly dispatchCommitBounded: (...args: Parameters<import('../../interfaces/index.js').MutationExecutor['commit']>) => ReturnType<import('../../interfaces/index.js').MutationExecutor['commit']>;
@@ -38,15 +36,6 @@ export interface BatchProcessingContext {
     readonly assertEnvelopeInsideReplayWindow: (envelope: DurableCommitEnvelope) => void;
     readonly sealDurableCommit: (input: Parameters<typeof import('./commitTransport.js').sealDurableCommit>[1]) => Promise<DurableCommitEnvelope>;
     readonly noteAck: (syncId: number | undefined) => void;
-    readonly classifyReceiptNotifications: (operations: readonly {
-        model: string;
-        id: string;
-    }[], notifications: readonly StaleNotification[]) => {
-        holdsEntireBatch: boolean;
-        heldTargets: Set<string>;
-        notificationsByTarget: Map<string, StaleNotification[]>;
-    };
-    readonly receiptTargetKey: (modelName: string, modelId: string) => string;
     readonly scheduleReplicationLagTimeout: (transactionId: string, clientTxId?: string, correlationId?: string) => void;
     readonly scheduleDeltaConfirmationTimeout: (transaction: QueuedMutation, timeoutMs: number) => void;
     readonly clearReplicationLagState: (transactionId: string) => void;

package/dist/local/transactions/mutations/batchProcessing.js

@@ -87,17 +87,6 @@ export async function processBatch(ctx) {
                     }));
                     await ctx.persistDurableCommitAcceptance(durableEnvelope, result);
                     const lastSyncId = result.lastSyncId;
-                    const notifications = result.notifications;
-                    const { holdsEntireBatch, heldTargets, notificationsByTarget, } = ctx.classifyReceiptNotifications(batchOps.map(({ op }) => ({ model: op.model, id: op.id })), notifications ?? []);
-                    for (const { tx } of batchOps) {
-                        const txTarget = ctx.receiptTargetKey(tx.modelKey, tx.modelId);
-                        const txNotifs = holdsEntireBatch
-                            ? notifications
-                            : notificationsByTarget.get(txTarget);
-                        if (txNotifs && txNotifs.length > 0) {
-                            ctx.commitNotifications.set(tx.id, txNotifs);
-                        }
-                    }
                     const missingIds = new Set(result.missingIds ?? []);
                     const settlingBatchOps = [];
                     for (const entry of batchOps) {
@@ -106,15 +95,6 @@ export async function processBatch(ctx) {
                             await ctx.handleFailure(tx, new AbloNotFoundError(`${tx.modelName}/${tx.modelId} was not found or is outside this credential's scope.`, [tx.modelId]));
                             continue;
                         }
-                        if (holdsEntireBatch ||
-                            heldTargets.has(ctx.receiptTargetKey(tx.modelKey, tx.modelId))) {
-                            await ctx.rollbackOptimistic(tx, 'conflict_server_wins');
-                            ctx.store.updateStatus(tx.id, 'completed');
-                            ctx.emit('transaction:completed', tx);
-                            ctx.emit(`transaction:completed:${tx.id}`, tx);
-                            ctx.optimisticUpdates.delete(tx.id);
-                            continue;
-                        }
                         settlingBatchOps.push(entry);
                     }
                     // A forwarded write has been accepted, but the source database

package/dist/local/transactions/mutations/commitApi.d.ts

@@ -1,5 +1,5 @@
-import type { ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
+import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
 import type { CommitTransaction } from './commitLane.js';
 import type { SealDurableCommitInput } from './commitTransport.js';
 export interface CommitApiContext {
@@ -15,5 +15,4 @@ export interface CommitApiContext {
 }
 export declare function enqueueCommit(ctx: CommitApiContext, clientTxId: string, operations: CommitTransaction['operations'], options?: {
     reads?: ReadDependency[] | null;
-    track?: TrackDependency[] | null;
 }): Promise<void>;

package/dist/local/transactions/mutations/commitApi.js

@@ -8,12 +8,10 @@ export async function enqueueCommit(ctx, clientTxId, operations, options = {}) {
         const existingIntent = stableStringify({
             operations: existing.operations,
             reads: existing.reads ?? null,
-            track: existing.track ?? null,
         });
         const incomingIntent = stableStringify({
             operations,
             reads: options.reads ?? null,
-            track: options.track ?? null,
         });
         if (existingIntent !== incomingIntent) {
             throw new AbloIdempotencyError('Idempotency key reused with a different atomic commit request', { code: 'idempotency_conflict' });
@@ -34,7 +32,6 @@ export async function enqueueCommit(ctx, clientTxId, operations, options = {}) {
         kind: 'commit',
         operations: [...operations],
         ...(options.reads ? { reads: options.reads } : {}),
-        ...(options.track ? { track: options.track } : {}),
         status: 'pending',
         createdAt: now,
         attempts: 0,
@@ -48,7 +45,6 @@ export async function enqueueCommit(ctx, clientTxId, operations, options = {}) {
         operations: tx.operations,
         commitOptions: {
             ...(tx.reads ? { reads: tx.reads } : {}),
-            ...(tx.track ? { track: tx.track } : {}),
         },
         createdAt: tx.createdAt,
         sealedAt: tx.sealedAt,

package/dist/local/transactions/mutations/commitLane.d.ts

@@ -1,7 +1,7 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
-import type { ReadDependency, TrackDependency, OnStaleMode, StaleNotification } from '@abloatai/transaction/coordination/schema';
-import type { MutationCommitResult } from '@abloatai/transaction/wire/commit';
-import type { DurableCommitEnvelope, DurableCommitOperation } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
+import type { CommitOperationResult, MutationCommitResult } from '@abloatai/transaction/commit';
+import type { DurableCommitEnvelope, DurableCommitOperation } from '@abloatai/transaction/commit';
 import type { SealDurableCommitInput } from './commitTransport.js';
 export interface CommitTransaction {
     id: string;
@@ -13,16 +13,16 @@ export interface CommitTransaction {
         input?: Record<string, unknown>;
         transactionId?: string;
         readAt?: number | null;
-        onStale?: OnStaleMode | null;
     }[];
     reads?: ReadDependency[] | null;
-    track?: TrackDependency[] | null;
     status: 'pending' | 'executing' | 'awaiting_delta' | 'completed' | 'failed';
     createdAt: number;
     attempts: number;
     transientAttempts?: number;
     firstTransientFailureAt?: number;
     lastSyncId?: number;
+    /** Fresh transport rows. Deliberately transient: durable server replays redact row data. */
+    operationResults?: CommitOperationResult[];
     correlationId?: string;
     error?: Error;
     sealedAt: number;
@@ -42,7 +42,6 @@ export interface CommitLaneContext {
         };
     };
     readonly commitLane: CommitTransaction[];
-    readonly commitNotifications: Map<string, StaleNotification[]>;
     readonly commitMissingIds: Map<string, string[]>;
     readonly commitProcessing: boolean;
     readonly setCommitProcessing: (value: boolean) => void;
@@ -63,7 +62,6 @@ export interface CommitLaneContext {
 }
 export interface CommitReceiptContext {
     readonly commitStore: Map<string, CommitTransaction>;
-    readonly commitNotifications: Map<string, StaleNotification[]>;
     readonly commitMissingIds: Map<string, string[]>;
     readonly replicationLagErrors: Map<string, Error>;
     readonly on: (event: string, listener: (payload: object) => void) => void;
@@ -71,7 +69,7 @@ export interface CommitReceiptContext {
 }
 export declare function waitForCommitReceipt(ctx: CommitReceiptContext, clientTxId: string): Promise<{
     lastSyncId: number;
-    notifications?: StaleNotification[];
     missingIds?: string[];
+    operationResults?: CommitOperationResult[];
 }>;
 export declare function processCommitLane(ctx: CommitLaneContext): Promise<void>;

package/dist/local/transactions/mutations/commitLane.js

@@ -1,12 +1,5 @@
 import { transientRetryDelayMs } from './failureHandling.js';
 export function waitForCommitReceipt(ctx, clientTxId) {
-    const drainNotifications = () => {
-        const notifications = ctx.commitNotifications.get(clientTxId);
-        if (!notifications)
-            return undefined;
-        ctx.commitNotifications.delete(clientTxId);
-        return notifications.length > 0 ? notifications : undefined;
-    };
     const drainMissingIds = () => {
         const ids = ctx.commitMissingIds.get(clientTxId);
         if (!ids)
@@ -14,18 +7,20 @@ export function waitForCommitReceipt(ctx, clientTxId) {
         ctx.commitMissingIds.delete(clientTxId);
         return ids.length > 0 ? ids : undefined;
     };
-    const receipt = (lastSyncId) => {
+    const receipt = (transaction, lastSyncId) => {
         const missingIds = drainMissingIds();
         return {
             lastSyncId,
-            notifications: drainNotifications(),
+            ...(transaction.operationResults
+                ? { operationResults: transaction.operationResults }
+                : {}),
             ...(missingIds ? { missingIds } : {}),
         };
     };
     return new Promise((resolve, reject) => {
         const existing = ctx.commitStore.get(clientTxId);
         if (existing?.status === 'completed') {
-            resolve(receipt(existing.lastSyncId ?? 0));
+            resolve(receipt(existing, existing.lastSyncId ?? 0));
             return;
         }
         if (existing?.status === 'failed' && existing.error) {
@@ -37,7 +32,11 @@ export function waitForCommitReceipt(ctx, clientTxId) {
             reject(lagError);
             return;
         }
-        const onCompleted = (tx) => { cleanup(); resolve(receipt(tx.lastSyncId ?? 0)); };
+        const onCompleted = (tx) => {
+            cleanup();
+            const completed = tx;
+            resolve(receipt(completed, completed.lastSyncId ?? 0));
+        };
         const onFailed = (payload) => { cleanup(); reject(payload.error); };
         const onLagged = (payload) => { cleanup(); reject(payload.error); };
         const cleanup = () => {
@@ -74,7 +73,6 @@ export async function processCommitLane(ctx) {
                     sourceMutationIds: tx.sourceMutationIds,
                     commitOptions: {
                         ...(tx.reads ? { reads: tx.reads } : {}),
-                        ...(tx.track ? { track: tx.track } : {}),
                     },
                     createdAt: tx.createdAt,
                     sealedAt: tx.sealedAt,
@@ -86,8 +84,8 @@ export async function processCommitLane(ctx) {
                 const result = await ctx.dispatchCommit(durableEnvelope);
                 tx.durableEnvelope = await ctx.persistDurableCommitAcceptance(durableEnvelope, result);
                 tx.lastSyncId = result.lastSyncId;
-                if (result.notifications?.length)
-                    ctx.commitNotifications.set(tx.id, result.notifications);
+                if (result.operationResults?.length)
+                    tx.operationResults = [...result.operationResults];
                 if (result.missingIds?.length)
                     ctx.commitMissingIds.set(tx.id, result.missingIds);
                 ctx.commitLane.shift();