@abloatai/humans 0.60.0 → 0.62.0

package/dist/local/sync/createClaimStream.js

@@ -5,10 +5,8 @@
  * everyone else's, and watch the wait queue when a claim is contended.
  *
  * The stream is built directly on the sync WebSocket and shares that one
- * connection. It learns about other participants' claims from the same
- * `presence_update` frames the {@link createPresenceStream} presence stream
- * consumes — the server piggybacks each participant's `activeClaims` on every
- * presence frame — and sends its own claims as `claim_begin` and
+ * connection. It learns about other sessions' claims from the normalized
+ * presence projection and sends its own claims as `claim_begin` and
  * `claim_abandon` frames.
  *
  * Wire frames:
@@ -16,8 +14,7 @@
  *       entityId, description, field?, estimatedMs? }`.
  *   • Outbound `claim_abandon` — release it: `{ claimId, entityType?,
  *       entityId? }`.
- *   • Inbound, via presence — `event.activeClaims`, each stamped with
- *       `declaredAt` and `expiresAt`.
+ *   • Inbound, via presence — authoritative `claim` activities.
  *   • Inbound `claim_rejected` — the server refused the claim, with conflict
  *       metadata.
  */
@@ -40,10 +37,7 @@ function claimLabel(type, id, field) {
  * above a round trip, comfortably below the ttl/3 beat cadence.
  */
 const HEARTBEAT_ACK_TIMEOUT_MS = 10_000;
-export function createClaimStream(config, transport = null) {
-    // Mutable: the host seeds the resolved identity via `setParticipant` once
-    // it is known; the own-claim filter always reads the current value.
-    let participantId = config.participantId;
+export function createClaimStream(config, transport = null, presence = null) {
     const logger = config.logger ?? noopLogger;
     // ── State: others' open claims, keyed by claimId ───────────────
     const activeByClaimId = new Map();
@@ -113,48 +107,7 @@ export function createClaimStream(config, transport = null) {
         if (attached)
             return;
         attached = t;
-        // (1) Inbound presence frames carry every participant's full
-        //     active-claim set. Prune previous claims by holder, then
-        //     re-add from the frame — the frame is authoritative for that
-        //     participant's open claims at that moment.
-        unsubs.push(t.subscribe('presence_update', (event) => {
-            if (!event.userId)
-                return;
-            if (event.userId === participantId)
-                return;
-            let mutated = false;
-            if (event.kind === 'leave') {
-                for (const [id, claim] of activeByClaimId) {
-                    if (claim.heldBy === event.userId) {
-                        activeByClaimId.delete(id);
-                        mutated = true;
-                    }
-                }
-                if (mutated)
-                    notifyListeners();
-                return;
-            }
-            for (const [id, claim] of activeByClaimId) {
-                if (claim.heldBy === event.userId) {
-                    activeByClaimId.delete(id);
-                    mutated = true;
-                }
-            }
-            for (const claim of event.activeClaims ?? []) {
-                // Terminal-status entries (committed / expired / canceled) are
-                // one-shot "this claim ended" signals. The holder sweep above
-                // already removed the prior active entry; skipping the re-add
-                // drops it from `others`, which is what resolves a contender's
-                // `settled()`. Absent status means active (wire back-compat).
-                if (claim.status && claim.status !== 'active')
-                    continue;
-                observeForeignClaim(event.userId, claim, event.participantKind, event.isAgent);
-                mutated = true;
-            }
-            if (mutated)
-                notifyListeners();
-        }));
-        // (2) Server-side rejection frames.
+        // Server-side rejection frames.
         unsubs.push(t.subscribe('claim_rejected', (rejection) => {
             if (!rejection.claimId)
                 return;
@@ -284,12 +237,47 @@ export function createClaimStream(config, transport = null) {
             }
             ownClaims.clear();
             for (const claimId of [...pendingHeartbeats.keys()]) {
-                settleHeartbeat(claimId, ({ reject }) => reject(error));
+                settleHeartbeat(claimId, ({ reject }) => { reject(error); });
             }
         }));
     }
     if (transport)
         attach(transport);
+    const refreshPresenceClaims = () => {
+        if (presence === null)
+            return;
+        activeByClaimId.clear();
+        for (const session of presence.others) {
+            for (const activity of session.activities) {
+                if (activity.operation !== 'claim'
+                    || activity.source !== 'claim'
+                    || activity.target.id === undefined)
+                    continue;
+                const claimId = activity.id.startsWith('claim:')
+                    ? activity.id.slice('claim:'.length)
+                    : activity.id;
+                observeForeignClaim(session.participant.id, {
+                    claimId,
+                    entityType: activity.target.model,
+                    entityId: activity.target.id,
+                    ...(activity.target.field !== undefined
+                        ? { field: activity.target.field }
+                        : {}),
+                    ...(activity.target.fields !== undefined
+                        ? { fields: activity.target.fields }
+                        : {}),
+                    description: 'claim',
+                    declaredAt: Date.parse(activity.startedAt),
+                    expiresAt: Date.parse(activity.expiresAt),
+                }, session.participant.kind);
+            }
+        }
+        notifyListeners();
+    };
+    if (presence !== null) {
+        refreshPresenceClaims();
+        unsubs.push(presence.onChange(refreshPresenceClaims));
+    }
     // ── Outbound ────────────────────────────────────────────────────
     function sendBegin(claimId, claim) {
         if (!attached?.isConnected())
@@ -475,9 +463,6 @@ export function createClaimStream(config, transport = null) {
             }, () => claimsSnapshot);
         },
         attach,
-        setParticipant(participant) {
-            participantId = participant.id;
-        },
         dispose() {
             for (const off of unsubs)
                 off();

package/dist/local/sync/deltaPipeline.js

@@ -67,7 +67,9 @@ export function deduplicateDeltas(deltas) {
         return deltas;
     let strictlyOrdered = true;
     for (let index = 1; index < deltas.length; index += 1) {
-        if (deltas[index - 1].id >= deltas[index].id) {
+        const previous = deltas[index - 1];
+        const current = deltas[index];
+        if (!previous || !current || previous.id >= current.id) {
             strictlyOrdered = false;
             break;
         }
@@ -277,10 +279,13 @@ export function sliceApplyChanges(changes, maxDeltas) {
     while (index < changes.length) {
         // The indivisible unit starting here: one transaction's run, or a single
         // untransacted change.
-        const transactionId = changes[index].transactionId;
+        const change = changes[index];
+        if (!change)
+            break;
+        const transactionId = change.transactionId;
         let end = index + 1;
         if (transactionId !== undefined) {
-            while (end < changes.length && changes[end].transactionId === transactionId)
+            while (changes[end]?.transactionId === transactionId)
                 end += 1;
         }
         const groupSize = end - index;
@@ -327,9 +332,11 @@ async function flushDeltaBatchInner(ctx, queuedDeltas) {
     if (customDeltas.length > 0) {
         runInAction(() => {
             for (const delta of customDeltas) {
+                if (delta.data === null)
+                    continue;
                 const data = typeof delta.data === 'string'
                     ? JSON.parse(delta.data)
-                    : (delta.data);
+                    : delta.data;
                 // 'C' (Covering) is treated identically to 'I' here — the client
                 // gained permission to see the entity, so we insert it into the
                 // pool as if newly created.
@@ -395,7 +402,7 @@ async function flushDeltaBatchInner(ctx, queuedDeltas) {
         // slice. Slices stay the atomicity unit; the budget only decides where
         // the loop breathes.
         let sliceStartedAt = performance.now();
-        for (let index = 0; index < slices.length; index++) {
+        for (const [index, slice] of slices.entries()) {
             if (index > 0 && performance.now() - sliceStartedAt > APPLY_YIELD_BUDGET_MS) {
                 pipelineDebug.phase = `apply-yield-${index}`;
                 pipelineDebug.applyYields += 1;
@@ -404,7 +411,6 @@ async function flushDeltaBatchInner(ctx, queuedDeltas) {
             }
             pipelineDebug.phase = `apply-slice-${index}`;
             pipelineDebug.applySlices += 1;
-            const slice = slices[index];
             if (hasApplyPlugins) {
                 runStage(stagePlugins, 'apply', { changes: slice });
             }

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/socketEventWiring.d.ts

@@ -5,7 +5,7 @@ import type { InstanceCache } from '../InstanceCache.js';
 import type { ConnectionManager } from './ConnectionManager.js';
 import type { SubscriptionManager } from './SubscriptionManager.js';
 import type { SyncStatus } from '../storeContract.js';
-import type { BootstrapHint, BootstrapDataEvent, PresenceUpdate, SyncWebSocket, EventMap } from './SyncWebSocket.js';
+import type { BootstrapHint, BootstrapDataEvent, SyncWebSocket, EventMap } from './SyncWebSocket.js';
 import type { SyncDelta } from './SyncWebSocket.js';
 export interface SocketEventHost<TCollaboration extends EventMap<TCollaboration>> {
     syncWebSocket: SyncWebSocket<TCollaboration>;
@@ -23,7 +23,6 @@ export interface SocketEventHost<TCollaboration extends EventMap<TCollaboration>
     applyDeltaFrame(deltas: SyncDelta[]): void;
     handleBootstrapRequired(hint: BootstrapHint): void;
     handleBootstrapData(data: BootstrapDataEvent): void;
-    handlePresenceUpdate(data: PresenceUpdate): void;
     performCredentialRefresh(): Promise<'refreshed' | 'session_error' | 'network_error'>;
     handleTerminalSessionError(error: Error): void;
     nudgeReconnect(): void;

package/dist/local/sync/socketEventWiring.js

@@ -43,10 +43,6 @@ export function wireSocketEvents(deps) {
         const data = args[0];
         deps.handleBootstrapData(data);
     });
-    const onPresenceUpdate = deps.syncWebSocket.subscribe('presence_update', (...args) => {
-        const data = args[0];
-        deps.handlePresenceUpdate(data);
-    });
     // Error events
     const onError = deps.syncWebSocket.subscribe('error', (error) => {
         if (error.message === 'Network is offline' || error.message === 'WebSocket connection failed') {
@@ -126,5 +122,5 @@ export function wireSocketEvents(deps) {
         deps.runtime.logger.debug('[BaseSyncedStore] WebSocket reconnection gave up', { attempts });
         deps.updateSyncStatus({ state: 'reconnecting' });
     });
-    deps.disposers.push(onConnected, onDisconnected, onReconnecting, onDelta, onDeltaBatch, onBootstrapRequired, onBootstrapData, onPresenceUpdate, onError, onSessionError, onHandshakeFailed, onReconnectFailed, () => { deps.areaOfInterest.dispose(); });
+    deps.disposers.push(onConnected, onDisconnected, onReconnecting, onDelta, onDeltaBatch, onBootstrapRequired, onBootstrapData, onError, onSessionError, onHandshakeFailed, onReconnectFailed, () => { deps.areaOfInterest.dispose(); });
 }

package/dist/local/transactions/localMutation.js

@@ -16,9 +16,9 @@ export function createLocalMutationPort(emit) {
     };
     return {
         updates,
-        applyCreate: (model, transaction) => track('optimistic:create', model, transaction),
-        applyUpdate: (model, transaction) => track('optimistic:update', model, transaction),
-        applyDelete: (model, transaction) => track('optimistic:delete', model, transaction),
+        applyCreate: (model, transaction) => { track('optimistic:create', model, transaction); },
+        applyUpdate: (model, transaction) => { track('optimistic:update', model, transaction); },
+        applyDelete: (model, transaction) => { track('optimistic:delete', model, transaction); },
         rollback: (transaction, reason, error) => {
             const optimistic = updates.get(transaction.id);
             if (!optimistic)

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

@@ -111,6 +111,7 @@ export declare class MutationQueue extends EventEmitter {
     private pendingPersistenceStages;
     private persistenceStageScheduled;
     private pendingDrainPromise;
+    private modelProcessingPromise;
     private executionQueue;
     private isProcessing;
     private processTimer?;
@@ -153,7 +154,6 @@ export declare class MutationQueue extends EventEmitter {
     private get failureHandlingContext();
     private get conflictResolutionContext();
     private get processingSchedulerContext();
-    private get pendingDrainContext();
     private get durableCommitRestoreContext();
     private get persistenceContext();
     private nextCommitSequence;
@@ -225,7 +225,6 @@ export declare class MutationQueue extends EventEmitter {
      */
     private scheduleReplicationLagTimeout;
     private takeNextExecutionBatch;
-    private takePendingDrainBatch;
     /**
      * Resolvers for per-transaction `confirmation` promises. Populated in
      * `attachConfirmation` at staging time, consumed by the constructor-time
@@ -477,7 +476,7 @@ export declare class MutationQueue extends EventEmitter {
         awaitingDeltaCount: number;
         awaitingDeltaTransactions: {
             id: string;
-            type: "update" | "create" | "delete" | "archive" | "unarchive";
+            type: "create" | "update" | "delete" | "archive" | "unarchive";
             modelName: string;
             modelId: string;
             syncIdNeeded: number | undefined;
@@ -486,13 +485,13 @@ export declare class MutationQueue extends EventEmitter {
         }[];
         pendingTransactions: {
             id: string;
-            type: "update" | "create" | "delete" | "archive" | "unarchive";
+            type: "create" | "update" | "delete" | "archive" | "unarchive";
             modelName: string;
             modelId: string;
         }[];
         executingTransactions: {
             id: string;
-            type: "update" | "create" | "delete" | "archive" | "unarchive";
+            type: "create" | "update" | "delete" | "archive" | "unarchive";
             modelName: string;
             modelId: string;
         }[];

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

@@ -34,9 +34,8 @@ import { enqueueTransaction } from './queueCoalescing.js';
 import { processBatch } from './batchProcessing.js';
 import { handleFailure } from './failureHandling.js';
 import { handleConflict as resolveConflict, isPermanentError as classifyPermanentError, isDefinitiveRejection as classifyDefinitiveRejection } from './failurePolicy.js';
-import { takeNextExecutionBatch as selectExecutionBatch, takePendingDrainBatch as selectPendingDrainBatch } from './executionSelection.js';
+import { takeNextExecutionBatch as selectExecutionBatch } from './executionSelection.js';
 import { scheduleProcessing as scheduleProcessingExternal } from './processingScheduler.js';
-import { drainPendingConfirmations, } from './pendingDrain.js';
 import { restoreDurableCommits as restoreDurableCommitsExternal } from './durableCommitRestore.js';
 export class MutationQueue extends EventEmitter {
     // Keep one hour of clock/network margin inside the server's 24-hour ledger.
@@ -70,6 +69,7 @@ export class MutationQueue extends EventEmitter {
     pendingPersistenceStages = [];
     persistenceStageScheduled = false;
     pendingDrainPromise = null;
+    modelProcessingPromise = null;
     executionQueue = [];
     isProcessing = false;
     processTimer;
@@ -303,32 +303,6 @@ export class MutationQueue extends EventEmitter {
             logger: this.runtime.logger,
         };
     }
-    get pendingDrainContext() {
-        return {
-            runtime: this.runtime,
-            config: { deltaConfirmationTimeout: this.config.deltaConfirmationTimeout },
-            store: this.store,
-            executionQueue: this.executionQueue,
-            optimisticUpdates: this.localMutationPort.updates,
-            assertDurableReplayOpen: () => { this.assertDurableReplayOpen(); },
-            processCommitLane: () => this.processCommitLane(),
-            takePendingDrainBatch: (pending) => this.takePendingDrainBatch(pending),
-            ensureCommitEnvelope: (batch) => this.ensureCommitEnvelope(batch),
-            ensureDerivedFields: (transaction) => { this.ensureDerivedFields(transaction); },
-            sourceMutationIdsFor: (batch) => this.sourceMutationIdsFor(batch),
-            sealDurableCommit: (input) => this.sealDurableCommit(input),
-            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); },
-            recentDeltaCorrelations: this.recentDeltaCorrelations,
-            emit: (event, payload) => this.emit(event, payload),
-        };
-    }
     get durableCommitRestoreContext() {
         return {
             config: this.config,
@@ -738,9 +712,6 @@ export class MutationQueue extends EventEmitter {
         this.executionQueue = selected.remaining;
         return selected.batch;
     }
-    takePendingDrainBatch(pending) {
-        return selectPendingDrainBatch(pending, this.config.maxBatchSize);
-    }
     /**
      * Resolvers for per-transaction `confirmation` promises. Populated in
      * `attachConfirmation` at staging time, consumed by the constructor-time
@@ -1004,25 +975,15 @@ export class MutationQueue extends EventEmitter {
         return this.pendingDrainPromise;
     }
     async drainPendingInternal() {
-        // The normal batch scheduler and the explicit/reconnect drain are two
-        // ways to drive the same durable queue. They must never seal the same
-        // staged source records concurrently: the first seal consumes those
-        // records, so the second would correctly reject them as already claimed.
-        //
-        // `isProcessing` is acquired synchronously before either path awaits,
-        // making it the queue-wide execution lock. If the normal lane already
-        // owns it, that lane will finish the pending work; callers waiting on a
-        // specific confirmation remain attached to the exact transaction.
-        if (this.isProcessing)
-            return;
-        this.isProcessing = true;
-        try {
-            await drainPendingConfirmations(this.pendingDrainContext);
-        }
-        finally {
-            this.isProcessing = false;
-            if (this.executionQueue.length > 0)
-                this.scheduleProcessing(true);
+        // Explicit flushes and reconnects are merely another trigger for the one
+        // model-mutation execution lane. A second sealing implementation can race
+        // the scheduled lane, consume its journal sources, and later dispatch the
+        // same transaction again. Move every staged row to the owned queue, then
+        // drive the normal lane until the queue has handed off all current work.
+        this.commitCreatedTransactions();
+        await this.processCommitLane();
+        while (this.executionQueue.length > 0 || this.modelProcessingPromise) {
+            await this.processBatch();
         }
     }
     async create(model, context, writeOptions, sourceMutationId) {
@@ -1055,7 +1016,20 @@ export class MutationQueue extends EventEmitter {
         scheduleProcessingExternal(this.processingSchedulerContext, immediate);
     }
     async processBatch() {
-        await processBatch(this.batchProcessingContext);
+        if (this.modelProcessingPromise) {
+            await this.modelProcessingPromise;
+            if (this.executionQueue.length > 0)
+                await this.processBatch();
+            return;
+        }
+        const processing = processBatch(this.batchProcessingContext);
+        const tracked = processing.finally(() => {
+            if (this.modelProcessingPromise === tracked) {
+                this.modelProcessingPromise = null;
+            }
+        });
+        this.modelProcessingPromise = tracked;
+        await tracked;
     }
     rememberDeltaCorrelation(correlationId, syncId) {
         // Refresh insertion order when a replay repeats the same correlation id.

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

@@ -64,16 +64,29 @@ export async function processBatch(ctx) {
             if (batchOps.length > 0) {
                 let dispatchStarted = false;
                 try {
-                    const durableEnvelope = await ctx.sealDurableCommit({
-                        idempotencyKey: commitIdempotencyKey,
-                        origin: 'model_batch',
-                        operations: batchOps.map(({ op }) => op),
-                        sourceMutationIds: ctx.sourceMutationIdsFor(batch),
-                        commitOptions: { reads: collectQueuedReads(batch) },
-                        createdAt: Math.min(...batch.map((transaction) => transaction.createdAt)),
-                        sealedAt: batch[0]?.commitEnvelope?.sealedAt ?? Date.now(),
-                        sequence: batch[0]?.commitEnvelope?.sequence,
-                    });
+                    let durableEnvelope = batch[0]?.durableEnvelope;
+                    if (durableEnvelope) {
+                        const mismatched = batch.some((transaction) => transaction.durableEnvelope?.idempotencyKey !==
+                            durableEnvelope?.idempotencyKey);
+                        if (mismatched || durableEnvelope.idempotencyKey !== commitIdempotencyKey) {
+                            throw new Error('Cannot replay a model batch with inconsistent durable envelopes');
+                        }
+                    }
+                    else {
+                        durableEnvelope = await ctx.sealDurableCommit({
+                            idempotencyKey: commitIdempotencyKey,
+                            origin: 'model_batch',
+                            operations: batchOps.map(({ op }) => op),
+                            sourceMutationIds: ctx.sourceMutationIdsFor(batch),
+                            commitOptions: { reads: collectQueuedReads(batch) },
+                            createdAt: Math.min(...batch.map((transaction) => transaction.createdAt)),
+                            sealedAt: batch[0]?.commitEnvelope?.sealedAt ?? Date.now(),
+                            sequence: batch[0]?.commitEnvelope?.sequence,
+                        });
+                        for (const transaction of batch) {
+                            transaction.durableEnvelope = durableEnvelope;
+                        }
+                    }
                     const operations = durableEnvelope.operations;
                     // Capture lastSyncId from the server response for threshold-based
                     // confirmation.

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

@@ -11,7 +11,7 @@
 import type { RuntimeContext } from '../../RuntimeContext.js';
 import { MutationOperationType } from '@abloatai/transaction/types';
 import type { MutationOptions, WriteOptions } from '../../interfaces/index.js';
-import type { CommitEnvelopeMember } from '@abloatai/transaction/commit';
+import type { CommitEnvelopeMember, DurableCommitEnvelope } from '@abloatai/transaction/commit';
 export interface UserContext {
     userId: string;
     organizationId: string;
@@ -69,6 +69,13 @@ export interface QueuedMutation {
      * re-batching its operations under a fresh key.
      */
     commitEnvelope?: CommitEnvelopeMember;
+    /**
+     * The exact durable request produced by the first successful local seal.
+     * Runtime retries dispatch this object directly. Asking the outbox to seal
+     * again is both unnecessary and unsafe after a concurrent authoritative
+     * completion has begun cleaning up the stored envelope.
+     */
+    durableEnvelope?: DurableCommitEnvelope;
     /** Pending-mutation journal entries atomically consumed by this envelope. */
     sourceMutationIds?: string[];
     /** Completed locally without a server operation; no sync echo will arrive. */

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

@@ -95,7 +95,9 @@ export function dispatchCommitBounded(ctx, ...args) {
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
         return dispatched;
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new AbloConnectionError('The mutation transport did not acknowledge the commit in time; its outcome remains pending and is safe to retry.', { code: 'commit_no_result' })), timeoutMs);
+        const timer = setTimeout(() => {
+            reject(new AbloConnectionError('The mutation transport did not acknowledge the commit in time; its outcome remains pending and is safe to retry.', { code: 'commit_no_result' }));
+        }, timeoutMs);
         dispatched.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error instanceof Error ? error : new Error(String(error))); });
     });
 }

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

@@ -3,4 +3,3 @@ export declare function takeNextExecutionBatch(executionQueue: QueuedMutation[],
     batch: QueuedMutation[];
     remaining: QueuedMutation[];
 };
-export declare function takePendingDrainBatch(pending: QueuedMutation[], maxBatchSize: number): QueuedMutation[];

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

@@ -1,6 +1,10 @@
 export function takeNextExecutionBatch(executionQueue, maxBatchSize) {
+    // Cancellation, delta confirmation, and failure settlement can all make a
+    // queued reference terminal before its scheduler callback runs. Terminal or
+    // currently executing rows have no authority to cross the dispatch boundary.
+    const pendingQueue = executionQueue.filter((tx) => tx.status === 'pending');
     const retryGroups = new Map();
-    for (const tx of executionQueue) {
+    for (const tx of pendingQueue) {
         const envelope = tx.commitEnvelope;
         if (!envelope)
             continue;
@@ -13,30 +17,18 @@ export function takeNextExecutionBatch(executionQueue, maxBatchSize) {
         const expectedCount = members[0]?.commitEnvelope?.operationCount;
         if (expectedCount === undefined || members.length !== expectedCount)
             continue;
-        const remaining = executionQueue.filter((tx) => tx.commitEnvelope?.idempotencyKey !== idempotencyKey);
+        const remaining = pendingQueue.filter((tx) => tx.commitEnvelope?.idempotencyKey !== idempotencyKey);
         members.sort((a, b) => (a.commitEnvelope?.operationIndex ?? 0) - (b.commitEnvelope?.operationIndex ?? 0));
         return { batch: members, remaining };
     }
-    const fresh = executionQueue.filter((tx) => !tx.commitEnvelope);
+    const fresh = pendingQueue.filter((tx) => !tx.commitEnvelope);
     const firstFresh = fresh[0];
     if (!firstFresh)
-        return { batch: [], remaining: executionQueue };
+        return { batch: [], remaining: pendingQueue };
     const explicitIndex = fresh.findIndex((tx) => typeof tx.writeOptions?.idempotencyKey === 'string');
     const selected = explicitIndex === 0
         ? [firstFresh]
         : fresh.slice(0, Math.min(maxBatchSize, explicitIndex > 0 ? explicitIndex : fresh.length));
     const selectedIds = new Set(selected.map((tx) => tx.id));
-    return { batch: selected, remaining: executionQueue.filter((tx) => !selectedIds.has(tx.id)) };
-}
-export function takePendingDrainBatch(pending, maxBatchSize) {
-    const first = pending[0];
-    if (!first)
-        return [];
-    const envelope = first.commitEnvelope;
-    if (envelope)
-        return pending.filter((tx) => tx.commitEnvelope?.idempotencyKey === envelope.idempotencyKey);
-    if (typeof first.writeOptions?.idempotencyKey === 'string')
-        return [first];
-    const explicitIndex = pending.findIndex((tx) => typeof tx.writeOptions?.idempotencyKey === 'string');
-    return pending.slice(0, Math.min(maxBatchSize, explicitIndex > 0 ? explicitIndex : pending.length));
+    return { batch: selected, remaining: pendingQueue.filter((tx) => !selectedIds.has(tx.id)) };
 }

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

@@ -13,6 +13,15 @@ export function transientRetryDelayMs(error, attempt, retryBackoff) {
     return Math.floor(Math.random() * ceiling);
 }
 export async function handleFailure(ctx, transaction, error) {
+    // The dispatch owner may lose its acknowledgement while an authoritative
+    // delta concurrently completes the same transaction. Completion is
+    // terminal: a late catch path must not turn that row back into `pending`
+    // and schedule a second seal after its durable sources were cleaned up.
+    if (transaction.status === 'completed' ||
+        transaction.status === 'failed' ||
+        transaction.status === 'rolled_back' ||
+        transaction.status === 'awaiting_delta')
+        return;
     transaction.attempts++;
     // Check whether this is a permanent error that should not be retried.
     if (ctx.isPermanentError(error)) {

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

@@ -12,9 +12,9 @@ export function createLocalMutationPort(emitter) {
     const updates = new Map();
     return {
         updates,
-        applyCreate: (model, transaction) => applyOptimisticCreate(updates, emitter, model, transaction),
-        applyUpdate: (model, transaction) => applyOptimisticUpdate(updates, emitter, model, transaction),
-        applyDelete: (model, transaction) => applyOptimisticDelete(updates, emitter, model, transaction),
+        applyCreate: (model, transaction) => { applyOptimisticCreate(updates, emitter, model, transaction); },
+        applyUpdate: (model, transaction) => { applyOptimisticUpdate(updates, emitter, model, transaction); },
+        applyDelete: (model, transaction) => { applyOptimisticDelete(updates, emitter, model, transaction); },
         rollback: (transaction, reason, error) => rollbackOptimistic(updates, emitter, transaction, reason, error),
     };
 }

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

@@ -1,6 +1,14 @@
 import { mergeUpdateData } from './coalesceRules.js';
 import { hasCommitCoalescingBarrier } from './commitPayload.js';
 export function enqueueTransaction(ctx, transaction) {
+    // Only the pending state may cross into the execution owner. A late timer,
+    // reconnect callback, or stale staging callback must not resurrect a row
+    // that is already executing or terminal, and repeated triggers must not put
+    // the same source mutation into the queue twice.
+    if (transaction.status !== 'pending')
+        return;
+    if (ctx.executionQueue.some((candidate) => candidate.id === transaction.id))
+        return;
     ctx.ensureDerivedFields(transaction);
     const modelKey = `${transaction.modelName}:${transaction.modelId}`;
     if (transaction.type === 'update' && transaction.attempts === 0 && !transaction.commitEnvelope) {