@abloatai/humans 0.56.0 → 0.58.0

package/src/local/transactions/mutations/MutationQueue.ts

@@ -18,44 +18,39 @@ import type { LocalModel } from '../../localModelContract.js';
 import type { MutationPersistencePort } from '../../mutationPersistence.js';
 import { globalRuntime } from '../../context.js';
 import type { RuntimeContext } from '../../RuntimeContext.js';
-import type { MutationOperationType } from '@abloatai/transaction/types';
 import {
-  AbloError,
   AbloConnectionError,
   AbloIdempotencyError,
-  AbloNotFoundError,
-  AbloValidationError,
-  errorCodeSpec,
 } from '@abloatai/transaction/errors';
 import {
   LogPosition,
   type LogPositionPort,
 } from '../../logPosition.js';
 import type { WriteOptions } from '../../interfaces/index.js';
-import type { OnStaleMode, StaleNotification, ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
 import {
-  mutationCommitResultSchema,
+  type CommitOperationResult,
   type MutationCommitResult,
-} from '@abloatai/transaction/wire/commit';
+} from '@abloatai/transaction/commit';
 import {
-  projectCommitPayload,
   computePriorityScore,
   normalizeModelKey,
   // Includes stale guards as well as request identity/audit barriers.
-  hasCommitCoalescingBarrier,
-  applyWriteOptions,
-  asTransportError,
-  extractStatusCode,
-  TX_TYPE_TO_MUTATION_OP,
   type MutationInput,
   type QueuedMutation,
   type UserContext,
-  type WriteOperationFields,
 } from './commitPayload.js';
+import {
+  generateTransactionId,
+  mergeMutationData,
+  createDataFor,
+  changesToInput,
+  updateDataFor,
+  previousDataFor,
+} from './mutationInput.js';
 import { MutationStore } from './MutationStore.js';
 import {
   entityKey,
-  mergeUpdateData,
   takeUnsentCreateForModel,
   findCreateBarrierForDelete,
   deferDeleteUntilCreateSettles,
@@ -66,9 +61,6 @@ import {
   deserializePersistedTransaction,
   isNonReplayablePersistedRow,
   pendingMutationRecordId,
-  legacyPendingMutationRecordSchema,
-  pendingMutationRecordSchema,
-  persistedMutationSchema,
 } from './replayValidation.js';
 import {
   deserializeLegacyPendingMutation,
@@ -80,16 +72,10 @@ import {
 } from './mutationPersistence.js';
 import {
   createCommitEnvelopeMember,
-  createDurableCommitEnvelope,
-  commitEnvelopeRecordId,
-  durableCommitEnvelopeSchema,
   type DurableCommitEnvelope,
-  type DurableCommitOperation,
-  type DurableCommitOperationInput,
   type CommitOutboxScope,
-} from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+} from '@abloatai/transaction/commit';
 import type { DurableWriteStore } from './durableWriteStore.js';
-import { stableStringify } from '@abloatai/transaction/utils/json';
 import {
   createLocalMutationPort,
   type LocalMutationPort,
@@ -101,7 +87,6 @@ import {
   removeDurableCommit,
   sealDurableCommit,
   type CommitTransportContext,
-  type SealDurableCommitInput,
 } from './commitTransport.js';
 import {
   processCommitLane,
@@ -122,7 +107,7 @@ import {
 import { enqueueTransaction, type QueueCoalescingContext } from './queueCoalescing.js';
 import { processBatch, type BatchProcessingContext } from './batchProcessing.js';
 import { handleFailure, type FailureHandlingContext } from './failureHandling.js';
-import { handleConflict as resolveConflict, isPermanentError as classifyPermanentError, isDefinitiveRejection as classifyDefinitiveRejection, type ConflictPolicyContext } from './failurePolicy.js';
+import { handleConflict as resolveConflict, isPermanentError as classifyPermanentError, isDefinitiveRejection as classifyDefinitiveRejection, type ConflictResolutionContext } from './failurePolicy.js';
 import { takeNextExecutionBatch as selectExecutionBatch, takePendingDrainBatch as selectPendingDrainBatch } from './executionSelection.js';
 import { scheduleProcessing as scheduleProcessingExternal, type ProcessingSchedulerContext } from './processingScheduler.js';
 import {
@@ -245,18 +230,18 @@ export class MutationQueue extends EventEmitter {
   private readonly runtime: RuntimeContext;
   /** Durable transaction journal owned by this queue, before commit sealing. */
   private persistence: MutationPersistencePort | null = null;
-  private deferredMutations: Array<{
+  private deferredMutations: {
     type: 'create' | 'update' | 'delete' | 'archive';
     model: LocalModel;
     capturedChanges?: Record<string, unknown>;
     writeOptions?: WriteOptions;
-  }> = [];
-  private pendingPersistenceStages: Array<{
+  }[] = [];
+  private pendingPersistenceStages: {
     transaction: QueuedMutation;
     modelData: Record<string, unknown>;
     resolve: () => void;
     reject: (error: Error) => void;
-  }> = [];
+  }[] = [];
   private persistenceStageScheduled = false;
   private pendingDrainPromise: Promise<void> | null = null;
 
@@ -315,7 +300,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); },
     };
   }
 
@@ -328,26 +313,24 @@ 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) => {
@@ -357,14 +340,13 @@ export class MutationQueue extends EventEmitter {
           void this.processCommitLane();
         }, delayMs);
       },
-      emitCommitLifecycle: (event, payload) => this.emitCommitLifecycle(event, payload),
+      emitCommitLifecycle: (event, payload) => { this.emitCommitLifecycle(event, payload); },
     };
   }
 
   private get commitReceiptContext(): CommitReceiptContext {
     return {
       commitStore: this.commitStore,
-      commitNotifications: this.commitNotifications,
       commitMissingIds: this.commitMissingIds,
       replicationLagErrors: this.replicationLagErrors,
       on: (event, listener) => this.on(event, listener),
@@ -374,15 +356,15 @@ export class MutationQueue extends EventEmitter {
 
   private get commitApiContext(): 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); },
     };
   }
 
@@ -390,7 +372,7 @@ export class MutationQueue extends EventEmitter {
     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),
@@ -399,11 +381,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),
@@ -411,11 +393,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),
     };
   }
@@ -425,9 +407,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); },
     };
   }
 
@@ -440,7 +422,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; },
@@ -449,31 +431,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),
     };
@@ -486,20 +465,20 @@ 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),
     };
   }
 
-  private get conflictPolicyContext(): ConflictPolicyContext {
+  private get conflictResolutionContext(): 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); },
     };
   }
 
@@ -524,21 +503,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),
     };
@@ -564,7 +543,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),
     };
@@ -637,80 +616,7 @@ export class MutationQueue extends EventEmitter {
     return entityKey(modelName, modelId);
   }
 
-  /** Collision-safe receipt target identity across models sharing a row id. */
-  private receiptTargetKey(modelName: string, modelId: string): string {
-    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.
-   */
-  private classifyReceiptNotifications(
-    operations: readonly { model: string; id: string }[],
-    notifications: readonly StaleNotification[],
-  ): {
-    holdsEntireBatch: boolean;
-    heldTargets: Set<string>;
-    notificationsByTarget: Map<string, StaleNotification[]>;
-  } {
-    const targets = operations.map((operation) => ({
-      id: operation.id,
-      key: this.receiptTargetKey(operation.model, operation.id),
-    }));
-    const heldTargets = new Set<string>();
-    const notificationsByTarget = new Map<string, StaleNotification[]>();
-    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. */
 
   private resolveConfirmation(transaction: QueuedMutation): void {
     const resolver = this.confirmationResolvers.get(transaction.id);
@@ -821,11 +727,6 @@ export class MutationQueue extends EventEmitter {
 
   private readonly localMutationPort: 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.
-  private commitNotifications = new Map<string, StaleNotification[]>();
   /** Zero-row targets returned on a successful atomic commit receipt. */
   private commitMissingIds = new Map<string, string[]>();
 
@@ -1688,7 +1589,7 @@ export class MutationQueue extends EventEmitter {
   async enqueueCommit(
     clientTxId: string,
     operations: CommitTransaction['operations'],
-    options: { reads?: ReadDependency[] | null; track?: TrackDependency[] | null } = {},
+    options: { reads?: ReadDependency[] | null } = {},
   ): Promise<void> {
     return enqueueCommit(this.commitApiContext, clientTxId, operations, options);
   }
@@ -1701,8 +1602,8 @@ export class MutationQueue extends EventEmitter {
     clientTxId: string,
   ): Promise<{
     lastSyncId: number;
-    notifications?: StaleNotification[];
     missingIds?: string[];
+    operationResults?: CommitOperationResult[];
   }> {
     return waitForCommitReceipt(this.commitReceiptContext, clientTxId);
   }
@@ -1725,7 +1626,7 @@ export class MutationQueue extends EventEmitter {
   }
 
   async handleConflict(transaction: QueuedMutation, serverData: MutationInput): Promise<void> {
-    await resolveConflict(this.conflictPolicyContext, transaction, serverData);
+    await resolveConflict(this.conflictResolutionContext, transaction, serverData);
   }
 
   private applyOptimisticCreate(model: LocalModel, transaction: QueuedMutation): void {
@@ -1879,47 +1780,33 @@ 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.
   private generateId(): string {
-    return `tx_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    return generateTransactionId();
   }
 
   private mergeData(
     local: MutationInput | undefined,
     remote: MutationInput | undefined
   ): MutationInput {
-    return { ...(remote || {}), ...(local || {}) };
+    return mergeMutationData(local, remote);
   }
 
   private extractCreateData(model: LocalModel): MutationInput {
-    return projectCommitPayload(model.getModelName(), model.toJSON(), { dropUndefined: false }, this.runtime);
+    return createDataFor(model, this.runtime);
   }
 
   private mapChangesToInput(modelName: string, changes: Record<string, unknown>): MutationInput {
-    return projectCommitPayload(modelName, changes, { dropUndefined: true }, this.runtime);
+    return changesToInput(modelName, changes, this.runtime);
   }
 
   private extractUpdateData(model: LocalModel): MutationInput {
-    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.
   private extractPreviousData(model: LocalModel, updateInput?: MutationInput): MutationInput {
-    // 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. */
@@ -2040,7 +1927,6 @@ export class MutationQueue extends EventEmitter {
     this.recentDeltaCorrelations.clear();
     this.commitLane = [];
     this.commitStore.clear();
-    this.commitNotifications.clear();
     this.commitMissingIds.clear();
 
     // Clear event listeners

package/src/local/transactions/mutations/batchProcessing.ts

@@ -3,10 +3,9 @@ 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 { DeltaConfirmationTracker } from './deltaConfirmation.js';
-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';
 import { AbloError, AbloNotFoundError } from '@abloatai/transaction/errors';
 import { applyWriteOptions, normalizeModelKey, TX_TYPE_TO_MUTATION_OP, type WriteOperationFields } from './commitPayload.js';
 import type { MutationOperationType } from '@abloatai/transaction/types';
@@ -30,7 +29,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']>;
@@ -40,11 +38,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;
@@ -170,24 +163,6 @@ export async function processBatch(ctx: BatchProcessingContext): Promise<void> {
               );
               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: typeof batchOps = [];
               for (const entry of batchOps) {
@@ -202,17 +177,6 @@ export async function processBatch(ctx: BatchProcessingContext): Promise<void> {
                   );
                   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);
               }