@abloatai/humans 0.57.0 → 0.58.0

package/src/local/sync/createClaimStream.ts

@@ -25,7 +25,7 @@
 import type {
   WsTransport,
   PresenceUpdate,
-} from '@abloatai/transaction/transport/wsTransport';
+} from '@abloatai/transaction/transport/websocket';
 import type {
   ClaimOptions,
   ClaimTarget,
@@ -52,10 +52,15 @@ import {
   streamTarget,
   wireTarget,
   type ClaimTargetDetails,
-} from '@abloatai/transaction/coordination/locator';
-import { declaredMeta } from '@abloatai/transaction/coordination/claimMeta';
+} from '@abloatai/transaction/claims';
+import {
+  bindClaimLifetime,
+  createClaimLifetime,
+  type ClaimLifetime,
+} from '@abloatai/transaction/claims/lifetime';
+import { declaredMeta } from '@abloatai/transaction/claims';
 import { AbloClaimedError, AbloConnectionError } from '@abloatai/transaction/errors';
-import { resolveHeartbeatOptions } from '@abloatai/transaction/coordination/claimHeartbeatLoop';
+import { resolveHeartbeatOptions } from '@abloatai/transaction/claims';
 import { noopLogger, type Logger } from '@abloatai/transaction/logger';
 
 /**
@@ -114,13 +119,11 @@ export interface AttachableClaimStream extends ClaimStream {
 }
 
 /**
- * What this participant needs to remember about a claim it holds, so it can
- * re-announce it after a reconnect.
+ * What this participant needs to remember about one open grant.
  *
  * The sub-entity locator is taken from {@link ClaimTargetDetails} rather than
- * listed again: a member this record forgot would be a member the re-announced
- * claim silently lost, which is a narrower claim than the one the holder
- * believes it has.
+ * listed again: a member this record forgot would be a member release or loss
+ * bookkeeping silently narrowed relative to the handle the caller holds.
  */
 type OwnClaim = ClaimTargetDetails & {
   readonly entityType: string;
@@ -133,6 +136,11 @@ type OwnClaim = ClaimTargetDetails & {
   readonly queue?: boolean;
 };
 
+interface OwnGrant {
+  readonly claim: OwnClaim;
+  readonly lifetime: ClaimLifetime;
+}
+
 export function createClaimStream(
   config: ClaimStreamConfig,
   transport: ClaimTransport | null = null,
@@ -146,8 +154,8 @@ export function createClaimStream(
   const activeByClaimId = new Map<string, Claim>();
   let claimsSnapshot: readonly Claim[] = Object.freeze([]);
 
-  // ── State: our own open claims (for re-announce on reconnect) ───
-  const ownClaims = new Map<string, OwnClaim>();
+  // ── State: our own open grants, keyed by the exact claim id ─────
+  const ownClaims = new Map<string, OwnGrant>();
 
   // ── State: per-entity wait queues, from `claim_queue` frames ────
   // Keyed `type:id`; the value is the FIFO line of queued claims. Powers
@@ -290,7 +298,8 @@ export function createClaimStream(
     unsubs.push(
       t.subscribe('claim_rejected', (rejection) => {
         if (!rejection.claimId) return;
-        if (ownClaims.has(rejection.claimId)) {
+        const own = ownClaims.get(rejection.claimId);
+        if (own) {
           const tgt = rejection.target
             ? claimLabel(rejection.target.entityType, rejection.target.entityId, rejection.target.field)
             : rejection.claimId;
@@ -299,9 +308,17 @@ export function createClaimStream(
             { claimId: rejection.claimId, reason: rejection.reason },
           );
         }
-        // Drop the rejected own-claim so reconnect doesn't re-announce
-        // a claim the server already rejected (would just spam both
-        // sides with conflicts).
+        own?.lifetime.end(
+          new AbloClaimedError(
+            rejection.message ?? `Claim ${rejection.claimId} was rejected.`,
+            {
+              code:
+                rejection.reason === 'conflict'
+                  ? 'claim_conflict'
+                  : 'claim_lease_unavailable',
+            },
+          ),
+        );
         ownClaims.delete(rejection.claimId);
         // A holder on another server may have claimed before this client joined
         // the row group, so its one-shot presence frame was missed. A conflict
@@ -336,15 +353,20 @@ export function createClaimStream(
       // The frame is validated by the transport's dispatcher against the same
       // schema this parameter's type comes from, so it arrives proven.
       t.subscribe('claim_lost', (lost) => {
-        if (ownClaims.has(lost.claimId)) {
-          const c = ownClaims.get(lost.claimId);
+        const own = ownClaims.get(lost.claimId);
+        if (own) {
+          const c = own.claim;
           logger.info(
-            `claim: lost ${c ? claimLabel(c.entityType, c.entityId, c.field) : lost.claimId} (preempted or expired)`,
+            `claim: lost ${claimLabel(c.entityType, c.entityId, c.field)} (preempted or expired)`,
             { claimId: lost.claimId },
           );
         }
-        // Drop the lost own-claim so reconnect doesn't re-announce a lease we
-        // no longer hold.
+        own?.lifetime.end(
+          new AbloClaimedError(
+            `Claim ${lost.claimId} was lost because it ${lost.reason === 'expired' ? 'expired' : 'was preempted'}. Re-acquire it before continuing.`,
+            { code: 'claim_lost' },
+          ),
+        );
         ownClaims.delete(lost.claimId);
         for (const l of lostListeners) {
           try {
@@ -418,25 +440,35 @@ export function createClaimStream(
             });
             return;
           }
-          const c = ownClaims.get(ack.claimId);
-          reject(
-            new AbloClaimedError(
-              `The lease behind ${c ? claimLabel(c.entityType, c.entityId, c.field) : `claim ${ack.claimId}`} is no longer held — it expired or was granted onward while this participant was working. Re-acquire the claim and retry; a write attempted under the old lease is rejected by its \`readAt\` guard.`,
-              { code: 'claim_lost' },
-            ),
+          const own = ownClaims.get(ack.claimId);
+          const c = own?.claim;
+          const error = new AbloClaimedError(
+            `The lease behind ${c ? claimLabel(c.entityType, c.entityId, c.field) : `claim ${ack.claimId}`} is no longer held — it expired or was granted onward while this participant was working. Re-acquire the claim and retry; a write attempted under the old lease is rejected by its \`readAt\` guard.`,
+            { code: 'claim_lost' },
           );
+          own?.lifetime.end(error);
+          ownClaims.delete(ack.claimId);
+          reject(error);
         });
       }),
     );
 
-    // (3) On reconnect, re-announce every open self-claim — the
-    //     server's claim state is in-memory and is lost across
-    //     restarts. Without this, peers would see our claims vanish
-    //     whenever the connection blipped.
+    // (3) A granted handle belongs to this connection's exact grant. The server
+    //     releases the participant's claims when its last socket leaves; trying
+    //     to recreate them on `connected` silently swapped the lease beneath an
+    //     old `data` / `readAt` / fenceToken tuple. End them instead. A caller
+    //     reconnects, re-reads, and takes a fresh handle.
     unsubs.push(
-      t.subscribe('connected', () => {
-        for (const [claimId, claim] of ownClaims) {
-          sendBegin(claimId, claim);
+      t.subscribe('disconnected', () => {
+        const error = new AbloConnectionError(
+          'The connection holding this claim ended. Reconnect and acquire a fresh claim before continuing.',
+        );
+        for (const { lifetime } of ownClaims.values()) {
+          lifetime.end(error);
+        }
+        ownClaims.clear();
+        for (const claimId of [...pendingHeartbeats.keys()]) {
+          settleHeartbeat(claimId, ({ reject }) => reject(error));
         }
       }),
     );
@@ -480,8 +512,8 @@ export function createClaimStream(
 
   /**
    * Send one heartbeat and await its ack. Rejects with
-   * {@link AbloConnectionError} (transient — the auto-heartbeat loop retries
-   * on its next tick) when the socket is down or the ack times out, and with
+   * {@link AbloConnectionError} when the socket is down or the ack times out,
+   * and with
    * {@link AbloClaimedError} (definitive) when the server answers that the
    * lease is no longer ours.
    */
@@ -493,7 +525,7 @@ export function createClaimStream(
     if (!attached?.isConnected()) {
       return Promise.reject(
         new AbloConnectionError(
-          `The heartbeat for ${claimLabel(claim.entityType, claim.entityId, claim.field)} was skipped because the connection is down. The keepalive renews held leases automatically on reconnect; the next beat retries.`,
+          `The heartbeat for ${claimLabel(claim.entityType, claim.entityId, claim.field)} was skipped because the connection is down. This connection's grant has ended; reconnect and acquire a fresh claim.`,
         ),
       );
     }
@@ -567,7 +599,8 @@ export function createClaimStream(
       estimatedMs,
       queue: args.queue,
     };
-    ownClaims.set(claimId, claim);
+    const lifetime = createClaimLifetime();
+    ownClaims.set(claimId, { claim, lifetime });
     sendBegin(claimId, claim);
     // Coordination trace (info): the creator can see their human/agent claims.
     logger.info(
@@ -580,6 +613,7 @@ export function createClaimStream(
     const revoke = () => {
       if (revoked) return;
       revoked = true;
+      lifetime.end();
       ownClaims.delete(claimId);
       sendAbandon(claimId, claim);
       logger.info(
@@ -588,7 +622,7 @@ export function createClaimStream(
       );
     };
 
-    return {
+    return bindClaimLifetime({
       object: 'claim',
       id: claimId,
       status: 'active',
@@ -607,7 +641,7 @@ export function createClaimStream(
       [Symbol.asyncDispose]: async () => {
         revoke();
       },
-    };
+    }, lifetime);
   }
 
   function resolveTarget(target: PresenceTarget): ClaimTarget {
@@ -686,6 +720,10 @@ export function createClaimStream(
           );
         });
       }
+      const error = new AbloConnectionError(
+        'The claim stream was disposed. Acquire a fresh claim before continuing.',
+      );
+      for (const { lifetime } of ownClaims.values()) lifetime.end(error);
       listeners.clear();
       rejectionListeners.clear();
       lostListeners.clear();

package/src/local/sync/credentialLifecycle.ts

@@ -15,4 +15,4 @@ export {
   type CredentialRefreshResult,
   type CredentialRefresher,
   type CredentialLifecycleContext,
-} from '@abloatai/transaction/transport/credentialLifecycle';
+} from '@abloatai/transaction/transport/connection';

package/src/local/sync/participants.ts

@@ -1,4 +1,4 @@
-import type { JoinOptions } from '@abloatai/transaction/resources/modelOperations';
+import type { JoinOptions } from '@abloatai/transaction/client/resources/modelOperations';
 import type { SyncWebSocket } from './SyncWebSocket.js';
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
 import { scopeKindOf, type ModelDef } from '@abloatai/transaction/schema/model';

package/src/local/sync/schemas.ts

@@ -10,7 +10,7 @@ import { z } from 'zod';
 import { globalRuntime } from "../context.js";
 import type { RuntimeContext } from "../RuntimeContext.js";
 import { AbloValidationError } from "@abloatai/transaction/errors";
-import { syncDeltaWireCoreSchema } from '@abloatai/transaction/wire/delta';
+import { syncDeltaWireCoreSchema } from '@abloatai/transaction/observation';
 
 // ─── Server Delta Schema ─────────────────────────────────────────────────────
 

package/src/local/sync/wsFrameHandlers.ts

@@ -17,4 +17,4 @@ export {
   type WsInboundFrame,
   type WsSession,
   type WsFrameHandler,
-} from '@abloatai/transaction/transport/wsFrameHandlers';
+} from '@abloatai/transaction/transport/websocket';

package/src/local/transactions/databaseCommitOutbox.ts

@@ -1,7 +1,7 @@
 import type {
   DurableWriteStore,
-} from '@abloatai/transaction/durableWrites';
-import type { PendingWrite } from '@abloatai/transaction/transactions/confirmation/pendingWrite';
+} from '@abloatai/transaction/commit';
+import type { PendingWrite } from '@abloatai/transaction/commit';
 
 export interface CommitOutboxDatabase {
   sealTransactionRecord(

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

@@ -27,11 +27,11 @@ import {
   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 {
   type CommitOperationResult,
   type MutationCommitResult,
-} from '@abloatai/transaction/wire/commit';
+} from '@abloatai/transaction/commit';
 import {
   computePriorityScore,
   normalizeModelKey,
@@ -74,9 +74,8 @@ import {
   createCommitEnvelopeMember,
   type DurableCommitEnvelope,
   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,
@@ -108,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 {
@@ -314,7 +313,6 @@ 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; },
@@ -325,7 +323,6 @@ export class MutationQueue extends EventEmitter {
         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),
@@ -350,7 +347,6 @@ export class MutationQueue extends EventEmitter {
   private get commitReceiptContext(): CommitReceiptContext {
     return {
       commitStore: this.commitStore,
-      commitNotifications: this.commitNotifications,
       commitMissingIds: this.commitMissingIds,
       replicationLagErrors: this.replicationLagErrors,
       on: (event, listener) => this.on(event, listener),
@@ -437,7 +433,6 @@ export class MutationQueue extends EventEmitter {
       store: this.store,
       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),
@@ -447,8 +442,6 @@ export class MutationQueue extends EventEmitter {
       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); },
@@ -479,7 +472,7 @@ export class MutationQueue extends EventEmitter {
     };
   }
 
-  private get conflictPolicyContext(): ConflictPolicyContext {
+  private get conflictResolutionContext(): ConflictResolutionContext {
     return {
       config: this.config,
       store: this.store,
@@ -623,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);
@@ -807,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[]>();
 
@@ -1674,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);
   }
@@ -1687,7 +1602,6 @@ export class MutationQueue extends EventEmitter {
     clientTxId: string,
   ): Promise<{
     lastSyncId: number;
-    notifications?: StaleNotification[];
     missingIds?: string[];
     operationResults?: CommitOperationResult[];
   }> {
@@ -1712,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 {
@@ -2013,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);
               }
 

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

@@ -1,7 +1,7 @@
 import { AbloIdempotencyError } from '@abloatai/transaction/errors';
-import type { ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
 import { stableStringify } from '@abloatai/transaction/utils/json';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
 import type { CommitTransaction } from './commitLane.js';
 import type { SealDurableCommitInput } from './commitTransport.js';
 
@@ -21,7 +21,7 @@ export async function enqueueCommit(
   ctx: CommitApiContext,
   clientTxId: string,
   operations: CommitTransaction['operations'],
-  options: { reads?: ReadDependency[] | null; track?: TrackDependency[] | null } = {},
+  options: { reads?: ReadDependency[] | null } = {},
 ): Promise<void> {
   ctx.assertDurableReplayOpen();
   const existing = ctx.commitStore.get(clientTxId);
@@ -30,12 +30,10 @@ export async function enqueueCommit(
     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(
@@ -59,7 +57,6 @@ export async function enqueueCommit(
     kind: 'commit',
     operations: [...operations],
     ...(options.reads ? { reads: options.reads } : {}),
-    ...(options.track ? { track: options.track } : {}),
     status: 'pending',
     createdAt: now,
     attempts: 0,
@@ -73,7 +70,6 @@ export async function enqueueCommit(
     operations: tx.operations,
     commitOptions: {
       ...(tx.reads ? { reads: tx.reads } : {}),
-      ...(tx.track ? { track: tx.track } : {}),
     },
     createdAt: tx.createdAt,
     sealedAt: tx.sealedAt,