@abloatai/humans 0.57.0 → 0.58.0

package/dist/local/sync/createClaimStream.js

@@ -24,10 +24,11 @@
 import { asyncIteratorFrom } from '@abloatai/transaction/utils/asyncIterator';
 import { toMs } from '@abloatai/transaction/utils/duration';
 import { claimDescription, descriptionFromMeta, participantKindFromWire, } from '@abloatai/transaction/coordination/schema';
-import { isTargetTuple, subTarget, streamTarget, wireTarget, } from '@abloatai/transaction/coordination/locator';
-import { declaredMeta } from '@abloatai/transaction/coordination/claimMeta';
+import { isTargetTuple, subTarget, streamTarget, wireTarget, } from '@abloatai/transaction/claims';
+import { bindClaimLifetime, createClaimLifetime, } 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 } from '@abloatai/transaction/logger';
 /** Readable target for the coordination trace: `documents:abc` / `documents:abc.title`. */
 function claimLabel(type, id, field) {
@@ -47,7 +48,7 @@ export function createClaimStream(config, transport = null) {
     // ── State: others' open claims, keyed by claimId ───────────────
     const activeByClaimId = new Map();
     let claimsSnapshot = Object.freeze([]);
-    // ── State: our own open claims (for re-announce on reconnect) ───
+    // ── State: our own open grants, keyed by the exact claim id ─────
     const ownClaims = new Map();
     // ── State: per-entity wait queues, from `claim_queue` frames ────
     // Keyed `type:id`; the value is the FIFO line of queued claims. Powers
@@ -157,15 +158,18 @@ export function createClaimStream(config, transport = null) {
         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;
                 logger.info(`claim: rejected ${tgt}${rejection.heldBy ? ` — held by ${rejection.heldBy}` : ''}`, { 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
@@ -193,12 +197,12 @@ export function createClaimStream(config, transport = null) {
         // 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);
-                logger.info(`claim: lost ${c ? claimLabel(c.entityType, c.entityId, c.field) : lost.claimId} (preempted or expired)`, { claimId: lost.claimId });
+            const own = ownClaims.get(lost.claimId);
+            if (own) {
+                const c = own.claim;
+                logger.info(`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 {
@@ -260,17 +264,27 @@ export function createClaimStream(config, transport = null) {
                     });
                     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.
-        unsubs.push(t.subscribe('connected', () => {
-            for (const [claimId, claim] of ownClaims) {
-                sendBegin(claimId, claim);
+        // (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('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));
             }
         }));
     }
@@ -308,14 +322,14 @@ export function createClaimStream(config, transport = null) {
     }
     /**
      * 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.
      */
     function sendHeartbeat(claimId, claim, options) {
         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.`));
+            return Promise.reject(new AbloConnectionError(`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.`));
         }
         return new Promise((resolve, reject) => {
             settleHeartbeat(claimId, ({ reject: rejectPrior }) => {
@@ -371,7 +385,8 @@ export function createClaimStream(config, transport = null) {
             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(`claim: requesting ${claimLabel(claim.entityType, claim.entityId, claim.field)} for "${claim.description}"` +
@@ -381,11 +396,12 @@ export function createClaimStream(config, transport = null) {
             if (revoked)
                 return;
             revoked = true;
+            lifetime.end();
             ownClaims.delete(claimId);
             sendAbandon(claimId, claim);
             logger.info(`claim: released ${claimLabel(claim.entityType, claim.entityId, claim.field)}`, { claimId });
         };
-        return {
+        return bindClaimLifetime({
             object: 'claim',
             id: claimId,
             status: 'active',
@@ -403,7 +419,7 @@ export function createClaimStream(config, transport = null) {
             [Symbol.asyncDispose]: async () => {
                 revoke();
             },
-        };
+        }, lifetime);
     }
     function resolveTarget(target) {
         if (isTargetTuple(target))
@@ -471,6 +487,9 @@ export function createClaimStream(config, transport = null) {
                     reject(new AbloConnectionError('The claim stream was disposed while this heartbeat was awaiting its reply.'));
                 });
             }
+            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/dist/local/sync/credentialLifecycle.d.ts

@@ -4,4 +4,4 @@
  * as much as a browser does. This path re-exports it so existing importers
  * stay unchanged.
  */
-export { DEFAULT_PREROLL_INTERVAL_MS, MIN_PREROLL_DELAY_MS, computePrerollDelayMs, CredentialLifecycle, type CredentialRefreshOutcome, type CredentialRecoveryOutcome, type CredentialRefreshResult, type CredentialRefresher, type CredentialLifecycleContext, } from '@abloatai/transaction/transport/credentialLifecycle';
+export { DEFAULT_PREROLL_INTERVAL_MS, MIN_PREROLL_DELAY_MS, computePrerollDelayMs, CredentialLifecycle, type CredentialRefreshOutcome, type CredentialRecoveryOutcome, type CredentialRefreshResult, type CredentialRefresher, type CredentialLifecycleContext, } from '@abloatai/transaction/transport/connection';

package/dist/local/sync/credentialLifecycle.js

@@ -4,4 +4,4 @@
  * as much as a browser does. This path re-exports it so existing importers
  * stay unchanged.
  */
-export { DEFAULT_PREROLL_INTERVAL_MS, MIN_PREROLL_DELAY_MS, computePrerollDelayMs, CredentialLifecycle, } from '@abloatai/transaction/transport/credentialLifecycle';
+export { DEFAULT_PREROLL_INTERVAL_MS, MIN_PREROLL_DELAY_MS, computePrerollDelayMs, CredentialLifecycle, } from '@abloatai/transaction/transport/connection';

package/dist/local/sync/participants.d.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 } from '@abloatai/transaction/schema/schema';
 import type { Claim, Activity, ClaimTarget, ClaimStream, Peer, PresenceStream, PresenceTarget } from '@abloatai/transaction/types/streams';

package/dist/local/sync/schemas.d.ts

@@ -20,10 +20,10 @@ export declare const ServerDeltaSchema: z.ZodObject<{
     id: z.ZodNumber;
     data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
     actionType: z.ZodEnum<{
+        A: "A";
         I: "I";
         U: "U";
         D: "D";
-        A: "A";
         V: "V";
         C: "C";
         G: "G";
@@ -44,10 +44,10 @@ export declare const BootstrapResponseSchema: z.ZodObject<{
         id: z.ZodNumber;
         data: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>>;
         actionType: z.ZodEnum<{
+            A: "A";
             I: "I";
             U: "U";
             D: "D";
-            A: "A";
             V: "V";
             C: "C";
             G: "G";

package/dist/local/sync/schemas.js

@@ -8,7 +8,7 @@
 import { z } from 'zod';
 import { globalRuntime } from "../context.js";
 import { AbloValidationError } from "@abloatai/transaction/errors";
-import { syncDeltaWireCoreSchema } from '@abloatai/transaction/wire/delta';
+import { syncDeltaWireCoreSchema } from '@abloatai/transaction/observation';
 // ─── Server Delta Schema ─────────────────────────────────────────────────────
 /**
  * A delta as it arrives in a bootstrap payload.

package/dist/local/sync/wsFrameHandlers.d.ts

@@ -5,4 +5,4 @@
  * the transport object. This path re-exports it so existing importers stay
  * unchanged.
  */
-export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, type PendingCommit, type PendingClaim, type PendingSubscription, type WsInboundFrame, type WsSession, type WsFrameHandler, } from '@abloatai/transaction/transport/wsFrameHandlers';
+export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, type PendingCommit, type PendingClaim, type PendingSubscription, type WsInboundFrame, type WsSession, type WsFrameHandler, } from '@abloatai/transaction/transport/websocket';

package/dist/local/sync/wsFrameHandlers.js

@@ -5,4 +5,4 @@
  * the transport object. This path re-exports it so existing importers stay
  * unchanged.
  */
-export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, } from '@abloatai/transaction/transport/wsFrameHandlers';
+export { isRecord, readWsInboundFrame, wsFrameHandlers, dispatchWsFrame, } from '@abloatai/transaction/transport/websocket';

package/dist/local/transactions/databaseCommitOutbox.d.ts

@@ -1,5 +1,5 @@
-import type { DurableWriteStore } from '@abloatai/transaction/durableWrites';
-import type { PendingWrite } from '@abloatai/transaction/transactions/confirmation/pendingWrite';
+import type { DurableWriteStore } from '@abloatai/transaction/commit';
+import type { PendingWrite } from '@abloatai/transaction/commit';
 export interface CommitOutboxDatabase {
     sealTransactionRecord(record: PendingWrite, consumedRecordIds: readonly string[]): Promise<unknown>;
     getPersistedTransactions(): Promise<readonly unknown[]>;

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

@@ -17,10 +17,10 @@ import type { MutationPersistencePort } from '../../mutationPersistence.js';
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import { type LogPositionPort } from '../../logPosition.js';
 import type { WriteOptions } from '../../interfaces/index.js';
-import type { StaleNotification, ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
-import { type CommitOperationResult } from '@abloatai/transaction/wire/commit';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
+import { type CommitOperationResult } from '@abloatai/transaction/commit';
 import { type MutationInput, type QueuedMutation, type UserContext } from './commitPayload.js';
-import { type CommitOutboxScope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import { type CommitOutboxScope } from '@abloatai/transaction/commit';
 import type { DurableWriteStore } from './durableWriteStore.js';
 import { type LocalMutationPort } from './localMutation.js';
 import { type CommitTransaction } from './commitLane.js';
@@ -151,7 +151,7 @@ export declare class MutationQueue extends EventEmitter {
     private get queueCoalescingContext();
     private get batchProcessingContext();
     private get failureHandlingContext();
-    private get conflictPolicyContext();
+    private get conflictResolutionContext();
     private get processingSchedulerContext();
     private get pendingDrainContext();
     private get durableCommitRestoreContext();
@@ -163,18 +163,6 @@ export declare class MutationQueue extends EventEmitter {
     private computePriorityScore;
     private ensureDerivedFields;
     private entityKey;
-    /** Collision-safe receipt target identity across models sharing a row id. */
-    private receiptTargetKey;
-    /**
-     * 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;
     private resolveConfirmation;
     private takeUnsentCreateForModel;
     private cancelUnsentCreateForDelete;
@@ -185,7 +173,6 @@ export declare class MutationQueue extends EventEmitter {
     private config;
     private executingCount;
     private readonly localMutationPort;
-    private commitNotifications;
     /** Zero-row targets returned on a successful atomic commit receipt. */
     private commitMissingIds;
     private readonly deltaConfirmation;
@@ -367,12 +354,10 @@ export declare class MutationQueue extends EventEmitter {
     /** Enqueues a pre-built atomic commit through the commit API coordinator. */
     enqueueCommit(clientTxId: string, operations: CommitTransaction['operations'], options?: {
         reads?: ReadDependency[] | null;
-        track?: TrackDependency[] | null;
     }): Promise<void>;
     private processCommitLane;
     waitForCommitReceipt(clientTxId: string): Promise<{
         lastSyncId: number;
-        notifications?: StaleNotification[];
         missingIds?: string[];
         operationResults?: CommitOperationResult[];
     }>;

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

@@ -16,7 +16,7 @@ import { v4 as uuid } from 'uuid';
 import { globalRuntime } from '../../context.js';
 import { AbloConnectionError, AbloIdempotencyError, } from '@abloatai/transaction/errors';
 import { LogPosition, } from '../../logPosition.js';
-import {} from '@abloatai/transaction/wire/commit';
+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';
@@ -24,8 +24,7 @@ import { entityKey, takeUnsentCreateForModel, findCreateBarrierForDelete, deferD
 import { DeltaConfirmationTracker } from './deltaConfirmation.js';
 import { deserializePersistedTransaction, isNonReplayablePersistedRow, pendingMutationRecordId, } from './replayValidation.js';
 import { deserializeLegacyPendingMutation, loadPersistedTransactions, persistQueuedTransaction, removePersistedTransaction, settlePersistedFailure, } from './mutationPersistence.js';
-import { createCommitEnvelopeMember, } 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';
@@ -131,7 +130,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; },
@@ -141,7 +139,6 @@ export class MutationQueue extends EventEmitter {
             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),
@@ -165,7 +162,6 @@ export class MutationQueue extends EventEmitter {
     get commitReceiptContext() {
         return {
             commitStore: this.commitStore,
-            commitNotifications: this.commitNotifications,
             commitMissingIds: this.commitMissingIds,
             replicationLagErrors: this.replicationLagErrors,
             on: (event, listener) => this.on(event, listener),
@@ -248,7 +244,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),
@@ -258,8 +253,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); },
@@ -288,7 +281,7 @@ export class MutationQueue extends EventEmitter {
             emit: (event, payload) => this.emit(event, payload),
         };
     }
-    get conflictPolicyContext() {
+    get conflictResolutionContext() {
         return {
             config: this.config,
             store: this.store,
@@ -409,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)
@@ -543,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
@@ -1266,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);
@@ -1518,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 { CommitOperationResult, 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,10 +13,8 @@ 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;
@@ -44,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;
@@ -65,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;
@@ -73,7 +69,6 @@ export interface CommitReceiptContext {
 }
 export declare function waitForCommitReceipt(ctx: CommitReceiptContext, clientTxId: string): Promise<{
     lastSyncId: number;
-    notifications?: StaleNotification[];
     missingIds?: string[];
     operationResults?: CommitOperationResult[];
 }>;