@abloatai/humans 0.61.0 → 0.63.0

package/dist/local/sync/BootstrapFetcher.js

@@ -172,7 +172,7 @@ export class BootstrapFetcher {
         try {
             const res = await fetch(`${this.options.baseUrl}/schema`, {
                 method: 'GET',
-                headers: withAuthHeaders(this.options.getAuthToken, {}, this.options.authToken),
+                headers: withAuthHeaders(this.options.getAuthToken, {}, this.options.authToken, this.options.presenceSession),
             });
             if (!res.ok)
                 throw new Error(`schema read-back ${res.status}`);
@@ -570,7 +570,7 @@ export class BootstrapFetcher {
         // conditional revalidation (If-None-Match) implement it at their own
         // level where they own the cache-key namespace. The 304 branch below
         // remains defensively in place for when a caller enables revalidation.
-        const headers = withAuthHeaders(this.options.getAuthToken, { 'Content-Type': 'application/json' }, this.options.authToken);
+        const headers = withAuthHeaders(this.options.getAuthToken, { 'Content-Type': 'application/json' }, this.options.authToken, this.options.presenceSession);
         const controller = new AbortController();
         this.activeControllers.set(controller, 'bootstrap');
         try {
@@ -738,7 +738,7 @@ export class BootstrapFetcher {
                     'Content-Type': 'application/json',
                     'Cache-Control': 'no-cache, no-store, must-revalidate',
                     Pragma: 'no-cache',
-                }, this.options.authToken),
+                }, this.options.authToken, this.options.presenceSession),
                 signal: controller.signal,
                 cache: 'no-store', // Force browser to not cache
             });
@@ -797,7 +797,7 @@ export class BootstrapFetcher {
                 method: 'GET',
                 headers: withAuthHeaders(this.options.getAuthToken, {
                     'Content-Type': 'application/json',
-                }, this.options.authToken),
+                }, this.options.authToken, this.options.presenceSession),
                 signal: controller.signal,
             });
         }

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

@@ -37,6 +37,7 @@ import type { LoadWhere, WhereClause } from '../query/types.js';
 import { normalizeWhere } from '@abloatai/transaction/client/resources/where';
 import type { Schema } from '@abloatai/transaction/schema/schema';
 import type { LogPositionPort } from '../logPosition.js';
+import type { PresenceSessionSource } from '@abloatai/transaction/presence';
 export interface OnDemandLoaderOptions {
     readonly objectPool: InstanceCache;
     /**
@@ -53,6 +54,7 @@ export interface OnDemandLoaderOptions {
      * propagate without re-instantiating the coordinator.
      */
     readonly getAuthToken?: () => string | null;
+    readonly presenceSession?: PresenceSessionSource;
     /** @deprecated Use `getAuthToken`. */
     readonly getCapabilityToken?: () => string | null;
     /** The owning client's runtime. Defaults to the module-global bridge. */

package/dist/local/sync/OnDemandLoader.js

@@ -452,6 +452,7 @@ export class OnDemandLoader {
             getAuthToken: this.authTokenProvider ?? undefined,
             recoverCredential: this.credentialRecovery ?? undefined,
             runtime: this.opts.runtime,
+            presenceSession: this.opts.presenceSession,
         }, { queries: [query] });
         const rows = Array.isArray(result.results[0]) ? result.results[0] : [];
         const evidence = result.evidence?.[0] ?? [];

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

@@ -12,7 +12,7 @@
 import { type ClientSyncDelta } from '@abloatai/transaction/observation';
 import { WsTransport, type WsTransportOptions, type EventMap, type DefaultCollaborationEvents } from '@abloatai/transaction/transport/websocket';
 export type { CommitAck } from './commitFrames.js';
-export type { SyncCapabilities, BootstrapHint, BootstrapDataEvent, PresenceUpdate, CoreSyncEventMap, DefaultCollaborationEvents, EventMap, SyncWebSocketEventMap, } from '@abloatai/transaction/transport/websocket';
+export type { SyncCapabilities, BootstrapHint, BootstrapDataEvent, CoreSyncEventMap, DefaultCollaborationEvents, EventMap, SyncWebSocketEventMap, } from '@abloatai/transaction/transport/websocket';
 /**
  * The wire delta the client receives. It is inferred from the canonical
  * `clientSyncDeltaSchema` so the client and server share one contract rather
@@ -67,7 +67,7 @@ export declare class SyncWebSocket<TCollaboration extends EventMap<TCollaboratio
     protected resumeCursor(): string;
     /**
      * The open ritual, run by the transport between its `connected` emit and the
-     * heartbeat start: announce presence, tell the server where we left off,
+     * heartbeat start: tell the server where we left off,
      * request the deltas we missed, and start the catch-up poll.
      */
     protected onOpened(): void;
@@ -121,19 +121,6 @@ export declare class SyncWebSocket<TCollaboration extends EventMap<TCollaboratio
      * Public wrapper for sending ack from outside the class
      */
     acknowledge(syncId: number): void;
-    /**
-     * Send presence update to server.
-     * Use this for:
-     * - Updating timezone (improves localTime accuracy shown to other users)
-     * - Manual status changes (away, custom status)
-     *
-     * Note: "online" status is automatically set by server on WebSocket connect,
-     * and "offline" is set on disconnect. You don't need to call this for basic online/offline.
-     *
-     * @param status - "online", "away", or custom status string
-     * @param customStatus - Optional custom status message
-     */
-    sendPresenceUpdate(status?: 'online' | 'away' | 'offline', customStatus?: string): void;
     /**
      * Stop the periodic catchup interval
      */

package/dist/local/sync/SyncWebSocket.js

@@ -53,13 +53,10 @@ export class SyncWebSocket extends WsTransport {
     }
     /**
      * The open ritual, run by the transport between its `connected` emit and the
-     * heartbeat start: announce presence, tell the server where we left off,
+     * heartbeat start: tell the server where we left off,
      * request the deltas we missed, and start the catch-up poll.
      */
     onOpened() {
-        // Send presence update with timezone (server sets presence to "online" on connect,
-        // this improves localTime accuracy by providing the user's actual timezone)
-        this.sendPresenceUpdate('online');
         // Immediately request incremental sync based on our stored cursor.
         // `requestIncrementalSync` is async — a bare call inside try/catch is a
         // rejection hole (the catch never sees it); route failures through
@@ -224,38 +221,6 @@ export class SyncWebSocket extends WsTransport {
     acknowledge(syncId) {
         this.sendAck(syncId);
     }
-    /**
-     * Send presence update to server.
-     * Use this for:
-     * - Updating timezone (improves localTime accuracy shown to other users)
-     * - Manual status changes (away, custom status)
-     *
-     * Note: "online" status is automatically set by server on WebSocket connect,
-     * and "offline" is set on disconnect. You don't need to call this for basic online/offline.
-     *
-     * @param status - "online", "away", or custom status string
-     * @param customStatus - Optional custom status message
-     */
-    sendPresenceUpdate(status = 'online', customStatus) {
-        if (!this.isConnected())
-            return;
-        const timezone = (() => {
-            try {
-                return Intl.DateTimeFormat().resolvedOptions().timeZone;
-            }
-            catch {
-                return 'UTC';
-            }
-        })();
-        this.send({
-            type: 'presence_update',
-            payload: {
-                status,
-                timezone,
-                ...(customStatus ? { customStatus } : {}),
-            },
-        });
-    }
     /**
      * Stop the periodic catchup interval
      */

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

@@ -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,12 +14,12 @@
  *       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.
  */
 import type { WsTransport } from '@abloatai/transaction/transport/websocket';
+import type { PresenceSession } from '@abloatai/transaction/presence';
 import type { ClaimOptions, Claim, ClaimStream, PresenceTarget } from '@abloatai/transaction/types/streams';
 import { type Logger } from '@abloatai/transaction/logger';
 /**
@@ -34,11 +32,13 @@ import { type Logger } from '@abloatai/transaction/logger';
  */
 export type ClaimTransport = Pick<WsTransport, 'subscribe' | 'isConnected' | 'send'>;
 export interface ClaimStreamConfig {
-    /** Identity used to filter our own active claims out of `others`. */
-    participantId: string;
     /** Where the coordination trace is logged. Defaults to silent. */
     logger?: Logger;
 }
+export interface ClaimPresenceSource {
+    readonly others: readonly PresenceSession[];
+    onChange(listener: () => void): () => void;
+}
 export interface AttachableClaimStream extends ClaimStream {
     /**
      * Mints the local handle and sends its `claim_begin` frame. The handle is a
@@ -54,16 +54,6 @@ export interface AttachableClaimStream extends ClaimStream {
      */
     claim(target: PresenceTarget, opts?: ClaimOptions, claimId?: string): Claim;
     attach(transport: ClaimTransport): void;
-    /**
-     * Seeds the participant identity once the host resolves it. The stream can
-     * be built before identity is known — a hosted client learns who it is
-     * from its credential's scope during connect — and until then the
-     * construction-time id (possibly empty) would let the participant's own
-     * claims into `others`. Idempotent; later frames filter on the new id.
-     */
-    setParticipant(participant: {
-        id: string;
-    }): void;
     dispose(): void;
 }
-export declare function createClaimStream(config: ClaimStreamConfig, transport?: ClaimTransport | null): AttachableClaimStream;
+export declare function createClaimStream(config: ClaimStreamConfig, transport?: ClaimTransport | null, presence?: ClaimPresenceSource | null): AttachableClaimStream;

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;
@@ -290,6 +243,41 @@ export function createClaimStream(config, transport = null) {
     }
     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/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/mutations/MutationQueue.d.ts

@@ -116,6 +116,8 @@ export declare class MutationQueue extends EventEmitter {
     private isProcessing;
     private processTimer?;
     private processScheduled;
+    private disposed;
+    private retryTimers;
     private createdTransactions;
     private commitScheduled;
     private inFlightByModel;
@@ -343,6 +345,7 @@ export declare class MutationQueue extends EventEmitter {
      */
     onDeltaReceived(syncId: number, _transactionId?: string, correlationId?: string): void;
     private scheduleDeltaConfirmationTimeout;
+    private scheduleRetry;
     /**
      * Resolves once the given transaction is confirmed and rejects if it fails.
      * The confirming delta's timeout is handled by
@@ -476,7 +479,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;
@@ -485,13 +488,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

@@ -74,6 +74,8 @@ export class MutationQueue extends EventEmitter {
     isProcessing = false;
     processTimer;
     processScheduled = false;
+    disposed = false;
+    retryTimers = new Set();
     // Staging area for transactions created in the same event-loop tick. Each one
     // lands here first, then a microtask commits them together.
     createdTransactions = [];
@@ -149,11 +151,14 @@ export class MutationQueue extends EventEmitter {
             isDefinitiveRejection: (error) => this.isDefinitiveRejection(error),
             isPermanentError: (error) => this.isPermanentError(error),
             scheduleRetry: (delayMs) => {
+                if (this.disposed)
+                    return;
                 if (this.commitRetryTimer !== null)
                     clearTimeout(this.commitRetryTimer);
                 this.commitRetryTimer = setTimeout(() => {
                     this.commitRetryTimer = null;
-                    void this.processCommitLane();
+                    if (!this.disposed)
+                        void this.processCommitLane();
                 }, delayMs);
             },
             emitCommitLifecycle: (event, payload) => { this.emitCommitLifecycle(event, payload); },
@@ -276,6 +281,7 @@ export class MutationQueue extends EventEmitter {
             isPermanentError: (error) => this.isPermanentError(error),
             rollbackOptimistic: (transaction, reason, error) => this.rollbackOptimistic(transaction, reason, error),
             enqueue: (transaction) => { this.enqueue(transaction); },
+            scheduleRetry: (callback, delayMs) => { this.scheduleRetry(callback, delayMs); },
             getLastPermanentErrorSignature: () => this.lastPermanentErrorSig,
             setLastPermanentErrorSignature: (signature) => { this.lastPermanentErrorSig = signature; },
             emit: (event, payload) => this.emit(event, payload),
@@ -655,6 +661,8 @@ export class MutationQueue extends EventEmitter {
      * optimistic state, or remove the durable replay envelope.
      */
     scheduleReplicationLagTimeout(transactionId, clientTxId = transactionId, correlationId) {
+        if (this.disposed)
+            return;
         const previous = this.replicationLagTimeouts.get(transactionId);
         if (previous)
             clearTimeout(previous);
@@ -846,6 +854,8 @@ export class MutationQueue extends EventEmitter {
      * {@link drainPending} resumes the work when the owner decides to drain.
      */
     setConnectionState(state) {
+        if (this.disposed)
+            return;
         if (state === 'connected') {
             if (this.commitOfflineGraceTimer !== null) {
                 clearTimeout(this.commitOfflineGraceTimer);
@@ -1013,12 +1023,16 @@ export class MutationQueue extends EventEmitter {
         enqueueTransaction(this.queueCoalescingContext, transaction);
     }
     scheduleProcessing(immediate = false) {
+        if (this.disposed)
+            return;
         scheduleProcessingExternal(this.processingSchedulerContext, immediate);
     }
     async processBatch() {
+        if (this.disposed)
+            return;
         if (this.modelProcessingPromise) {
             await this.modelProcessingPromise;
-            if (this.executionQueue.length > 0)
+            if (!this.disposed && this.executionQueue.length > 0)
                 await this.processBatch();
             return;
         }
@@ -1103,8 +1117,20 @@ export class MutationQueue extends EventEmitter {
     // Schedule the retry-and-reconciliation wait for a transaction's confirming
     // delta; see {@link DeltaConfirmationTracker} in `./deltaConfirmation.js`.
     scheduleDeltaConfirmationTimeout(tx, timeoutMs) {
+        if (this.disposed)
+            return;
         this.deltaConfirmation.scheduleDeltaConfirmationTimeout(tx, timeoutMs);
     }
+    scheduleRetry(callback, delayMs) {
+        if (this.disposed)
+            return;
+        const timer = setTimeout(() => {
+            this.retryTimers.delete(timer);
+            if (!this.disposed)
+                callback();
+        }, delayMs);
+        this.retryTimers.add(timer);
+    }
     /**
      * Resolves once the given transaction is confirmed and rejects if it fails.
      * The confirming delta's timeout is handled by
@@ -1156,6 +1182,8 @@ export class MutationQueue extends EventEmitter {
         return enqueueCommit(this.commitApiContext, clientTxId, operations, options);
     }
     async processCommitLane() {
+        if (this.disposed)
+            return;
         await processCommitLane(this.commitLaneContext);
     }
     waitForCommitReceipt(clientTxId) {
@@ -1388,6 +1416,9 @@ export class MutationQueue extends EventEmitter {
      * clears all timers and stored transactions, and removes event listeners.
      */
     dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
         // Cancel all active optimistic updates
         for (const [, optimistic] of this.localMutationPort.updates) {
             this.emit('optimistic:rollback', {
@@ -1419,6 +1450,9 @@ export class MutationQueue extends EventEmitter {
             clearTimeout(this.commitRetryTimer);
             this.commitRetryTimer = null;
         }
+        for (const timer of this.retryTimers)
+            clearTimeout(timer);
+        this.retryTimers.clear();
         // Clear store
         this.store.clear();
         this.localMutationPort.updates.clear();

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

@@ -40,6 +40,7 @@ export declare class DeltaConfirmationTracker {
     private static readonly DELTA_MAX_TIMEOUT_MS;
     private deltaConfirmationTimeouts;
     private deltaConfirmationRetries;
+    private disposed;
     private readonly runtime;
     constructor(ctx: DeltaConfirmationContext);
     /** Applied-cursor alias, kept so the read sites below stay legible. */

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

@@ -20,6 +20,7 @@ export class DeltaConfirmationTracker {
     deltaConfirmationTimeouts = new Map();
     // Track retry attempts per transaction for exponential backoff
     deltaConfirmationRetries = new Map();
+    disposed = false;
     runtime;
     constructor(ctx) {
         this.ctx = ctx;
@@ -113,6 +114,8 @@ export class DeltaConfirmationTracker {
     // server has already confirmed. A rollback happens only on an explicit server
     // rejection, never on a timeout.
     scheduleDeltaConfirmationTimeout(tx, timeoutMs) {
+        if (this.disposed)
+            return;
         // Cancel any existing timeout for this transaction
         this.cancelDeltaConfirmationTimeout(tx.id);
         // Deliberately not an async callback: the body is fully synchronous, and
@@ -226,6 +229,7 @@ export class DeltaConfirmationTracker {
      * would keep the process alive and fire callbacks against a cleared store.
      */
     dispose() {
+        this.disposed = true;
         for (const timeoutHandle of this.deltaConfirmationTimeouts.values()) {
             clearTimeout(timeoutHandle);
         }

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

@@ -9,6 +9,7 @@ export interface FailureHandlingContext {
     readonly isPermanentError: (error: Error) => boolean;
     readonly rollbackOptimistic: (transaction: QueuedMutation, reason: string, error?: Error) => Promise<void>;
     readonly enqueue: (transaction: QueuedMutation) => void;
+    readonly scheduleRetry: (callback: () => void, delayMs: number) => void;
     readonly getLastPermanentErrorSignature: () => string | undefined;
     readonly setLastPermanentErrorSignature: (signature: string) => void;
     readonly emit: (event: string, payload: object) => boolean;

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

@@ -54,7 +54,7 @@ export async function handleFailure(ctx, transaction, error) {
         // stall unrelated commits.
         const delay = transientRetryDelayMs(error, transaction.attempts, ctx.config.retryBackoff);
         ctx.store.updateStatus(transaction.id, 'pending');
-        setTimeout(() => {
+        ctx.scheduleRetry(() => {
             // The queue may have shut down or the tx may have been settled
             // (e.g. delta-confirmed) while we backed off.
             if (ctx.store.get(transaction.id)?.status !== 'pending')

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

@@ -27,8 +27,8 @@ import type { RuntimeContext } from '../../RuntimeContext.js';
 export declare const persistedTransactionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodEnum<{
-        update: "update";
         create: "create";
+        update: "update";
         delete: "delete";
         archive: "archive";
         unarchive: "unarchive";
@@ -95,8 +95,8 @@ export declare function deserializePersistedTransaction(row: unknown, runtime?:
 export declare const persistedMutationSchema: z.ZodObject<{
     mutationId: z.ZodOptional<z.ZodString>;
     type: z.ZodEnum<{
-        update: "update";
         create: "create";
+        update: "update";
         delete: "delete";
         archive: "archive";
     }>;
@@ -138,8 +138,8 @@ export declare const legacyPendingMutationRecordSchema: z.ZodObject<{
     type: z.ZodLiteral<"pending_mutation">;
     mutation: z.ZodObject<{
         type: z.ZodEnum<{
-            update: "update";
             create: "create";
+            update: "update";
             delete: "delete";
             archive: "archive";
         }>;
@@ -180,8 +180,8 @@ export declare const pendingMutationRecordSchema: z.ZodObject<{
     type: z.ZodLiteral<"pending_mutation">;
     mutation: z.ZodObject<{
         type: z.ZodEnum<{
-            update: "update";
             create: "create";
+            update: "update";
             delete: "delete";
             archive: "archive";
         }>;