@agentunion/fastaun-browser 0.4.13 → 0.5.1

package/dist/client/delivery.js

@@ -1,9 +1,13 @@
 import { slotIsolationKey } from '../config.js';
 import { normalizeGroupId } from '../group-id.js';
-import { isJsonObject } from '../types.js';
+import { ConnectionState, isJsonObject } from '../types.js';
 const PUSHED_SEQS_LIMIT = 50_000;
 const PENDING_ORDERED_LIMIT = 50_000;
 const GROUP_RECALL_SEEN_LIMIT = 10_000;
+const SEQ_TRACKER_PERSIST_FLUSH_DELAY_MS = 200;
+const P2P_GAP_FILL_RETRY_LIMIT = 12;
+const P2P_GAP_FILL_RETRY_BASE_MS = 1000;
+const P2P_GAP_FILL_RETRY_MAX_MS = 5000;
 const APP_MESSAGE_ENVELOPE_KEYS = [
     'module_id', 'message_type', 'type', 'kind', 'version',
     'from', 'from_aid', 'sender_aid', 'to', 'to_aid', 'group_id',
@@ -24,6 +28,33 @@ const APP_GROUP_EVENT_ENVELOPE_KEYS = [
 function formatDeliveryError(error) {
     return error instanceof Error ? error : String(error);
 }
+function isTransientGapFillError(error) {
+    const text = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    return text.includes('no_service')
+        || text.includes('service plane unavailable')
+        || text.includes('transport not connected')
+        || text.includes('transport closed')
+        || text.includes('websocket closed')
+        || text.includes('websocket is not open')
+        || text.includes('connection closed')
+        || text.includes('socket closed');
+}
+function p2pAppEventFromPlainPullMessage(message) {
+    const payload = message.payload;
+    const payloadType = isJsonObject(payload)
+        ? String(payload.type ?? '').trim()
+        : '';
+    if (payloadType === 'message.recalled' || payloadType === 'message.recall' || message.type === 'message.recalled') {
+        return {
+            event: 'message.recalled',
+            payload: {
+                ...message,
+                ...(isJsonObject(payload) ? payload : {}),
+            },
+        };
+    }
+    return { event: 'message.received', payload: message };
+}
 export class MessageDeliveryEngine {
     runtime;
     constructor(runtime) {
@@ -52,6 +83,34 @@ export class MessageDeliveryEngine {
             client._pushedSeqs.set(ns, new Set(keep));
         }
     }
+    fireGroupEventAck(groupId, ns, eventSeq, label) {
+        const client = this.runtime.client;
+        const ackSeq = this.clampAckSeq('group.ack_events', 'event_seq', ns, eventSeq);
+        if (ackSeq <= 0)
+            return;
+        void client.call('group.ack_events', {
+            group_id: groupId,
+            event_seq: ackSeq,
+            device_id: client._deviceId,
+            slot_id: client._slotId,
+            _rpc_background: true,
+        }).catch((e) => {
+            client._clientLog.warn(`${label} failed: group=${groupId}`, e);
+        });
+    }
+    fireGroupV2Ack(groupId, ns, seq, label) {
+        const client = this.runtime.client;
+        const ackSeq = this.clampAckSeq('group.v2.ack', 'up_to_seq', ns, seq);
+        if (ackSeq <= 0)
+            return;
+        void client._callRawV2Rpc('group.v2.ack', {
+            group_id: groupId,
+            up_to_seq: ackSeq,
+            _rpc_background: true,
+        }).catch((e) => {
+            client._clientLog.debug(`${label} failed: group=${groupId} seq=${ackSeq} err=${String(e)}`);
+        });
+    }
     enqueueOrderedMessage(ns, event, seq, payload) {
         const client = this.runtime.client;
         let queue = client._pendingOrderedMsgs.get(ns);
@@ -83,7 +142,8 @@ export class MessageDeliveryEngine {
             const eventPayload = payload;
             client._groupState?.handleGroupChangedV2Membership?.(eventPayload);
             if (eventPayload.action === 'dissolved') {
-                const groupId = normalizeGroupId(String(eventPayload.group_id ?? '')) || String(eventPayload.group_id ?? '').trim();
+                const rawGroupId = eventPayload.group_aid ?? eventPayload.group_id ?? '';
+                const groupId = normalizeGroupId(String(rawGroupId)) || String(rawGroupId).trim();
                 if (groupId)
                     client._cleanupDissolvedGroup?.(groupId);
             }
@@ -478,10 +538,11 @@ export class MessageDeliveryEngine {
                 msg_seq: ackSeq,
                 device_id: client._deviceId,
                 slot_id: client._slotId,
+                _rpc_background: true,
             }).catch((e) => { client._clientLog.warn('group recall auto-ack failed: group=' + groupId, e); });
         }
         if (contig !== contigBefore)
-            this.saveSeqTrackerState();
+            this.persistSeq(ns);
     }
     async publishAppEvent(event, payload) {
         const client = this.runtime.client;
@@ -564,10 +625,11 @@ export class MessageDeliveryEngine {
                         seq: ackSeq,
                         device_id: client._deviceId,
                         slot_id: client._slotId,
+                        _rpc_background: true,
                     }).catch((e) => { client._clientLog.warn(`P2P auto-ack failed:${String(e)}`); });
                 }
                 if (contigAfter !== contigBefore)
-                    this.saveSeqTrackerState();
+                    this.persistSeq(ns);
                 if (encryptedPush)
                     return;
             }
@@ -641,10 +703,11 @@ export class MessageDeliveryEngine {
                             msg_seq: ackSeq,
                             device_id: client._deviceId,
                             slot_id: client._slotId,
+                            _rpc_background: true,
                         }).catch((e) => { client._clientLog.warn('group recall auto-ack failed: group=' + groupId, e); });
                     }
                     if (contigAfter !== contigBefore)
-                        this.saveSeqTrackerState();
+                        this.persistSeq(ns);
                     return;
                 }
                 const published = encryptedPush
@@ -663,10 +726,11 @@ export class MessageDeliveryEngine {
                         msg_seq: ackSeq,
                         device_id: client._deviceId,
                         slot_id: client._slotId,
+                        _rpc_background: true,
                     }).catch((e) => { client._clientLog.warn('group message auto-ack failed: group=' + groupId, e); });
                 }
                 if (contigAfter !== contigBefore)
-                    this.saveSeqTrackerState();
+                    this.persistSeq(ns);
                 if (encryptedPush)
                     return;
             }
@@ -706,7 +770,7 @@ export class MessageDeliveryEngine {
         const afterSeq = client._seqTracker.getContiguousSeq(ns);
         try {
             if (client._v2Session) {
-                await client._pullGroupV2Internal({ group_id: groupId, after_seq: afterSeq, limit: 50 });
+                await client._withBackgroundRpc(() => client._pullGroupV2Internal({ group_id: groupId, after_seq: afterSeq, limit: 50 }));
                 return;
             }
             const result = await client.call('group.pull', {
@@ -714,6 +778,7 @@ export class MessageDeliveryEngine {
                 after_message_seq: afterSeq,
                 device_id: client._deviceId,
                 limit: 50,
+                _rpc_background: true,
             });
             if (isJsonObject(result)) {
                 const messages = result.messages;
@@ -752,9 +817,26 @@ export class MessageDeliveryEngine {
         }
         await client._publishAppEvent('group.message_created', notification);
     }
-    async fillP2pGap() {
+    scheduleP2pGapRetry(ns, retryAttempt) {
+        const client = this.runtime.client;
+        if (retryAttempt > P2P_GAP_FILL_RETRY_LIMIT)
+            return;
+        const retryKey = `p2p_pull_retry:${ns}`;
+        if (client._gapFillDone.has(retryKey))
+            return;
+        const delayMs = Math.min(P2P_GAP_FILL_RETRY_BASE_MS * retryAttempt, P2P_GAP_FILL_RETRY_MAX_MS);
+        client._gapFillDone.add(retryKey);
+        client._clientLog.debug(`P2P message gap-fill retry scheduled: ns=${ns} attempt=${retryAttempt} delay_ms=${delayMs}`);
+        globalThis.setTimeout(() => {
+            client._gapFillDone.delete(retryKey);
+            if (client.state !== ConnectionState.READY || client._closing)
+                return;
+            client._safeAsync(this.fillP2pGap(retryAttempt));
+        }, delayMs);
+    }
+    async fillP2pGap(retryAttempt = 0) {
         const client = this.runtime.client;
-        if (client._state !== 'connected' || client._closing)
+        if (client.state !== ConnectionState.READY || client._closing)
             return;
         if (!client._aid)
             return;
@@ -767,24 +849,64 @@ export class MessageDeliveryEngine {
         this.runtime.delivery.setGapFillActive(true);
         let filled = 0;
         try {
-            const messages = await client._pullV2(afterSeq, 50);
+            const messages = await client._withBackgroundRpc(() => client._pullV2(afterSeq, 50));
             filled = messages.length;
             this.prunePushedSeqs(ns);
         }
         catch (exc) {
-            client._clientLog.warn(`P2P message gap-fill failed:${String(formatDeliveryError(exc))}`);
+            const transient = isTransientGapFillError(exc);
+            if (transient) {
+                try {
+                    filled = await this.fillP2pGapWithPlainPull(ns, afterSeq);
+                    this.prunePushedSeqs(ns);
+                    client._clientLog.warn(`P2P message gap-fill V2 unavailable, used plain pull fallback:${String(formatDeliveryError(exc))}`);
+                }
+                catch (fallbackExc) {
+                    client._clientLog.warn(`P2P message gap-fill plain fallback failed:${String(formatDeliveryError(fallbackExc))}`);
+                    this.scheduleP2pGapRetry(ns, retryAttempt + 1);
+                }
+            }
+            else {
+                client._clientLog.warn(`P2P message gap-fill failed:${String(formatDeliveryError(exc))}`);
+            }
         }
         finally {
             client._gapFillDone.delete(dedupKey);
             this.runtime.delivery.setGapFillActive(false);
-            if (filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
-                client._safeAsync(this.fillP2pGap());
+        }
+    }
+    async fillP2pGapWithPlainPull(ns, afterSeq) {
+        const client = this.runtime.client;
+        const params = {
+            after_seq: afterSeq,
+            limit: 50,
+            device_id: client._deviceId,
+            slot_id: client._slotId,
+            _rpc_background: true,
+        };
+        const raw = await client._transport.call('message.pull', params, undefined, undefined, true);
+        const result = typeof client._rpcPipeline?.postprocessResult === 'function'
+            ? await client._rpcPipeline.postprocessResult('message.pull', params, raw)
+            : raw;
+        const messages = (isJsonObject(result) && Array.isArray(result.messages))
+            ? result.messages
+            : [];
+        let published = 0;
+        for (const item of messages) {
+            if (!isJsonObject(item))
+                continue;
+            const msg = item;
+            const seq = Number(msg.seq ?? 0);
+            const appEvent = p2pAppEventFromPlainPullMessage(msg);
+            if (await this.publishPulledMessage(appEvent.event, ns, seq, appEvent.payload)) {
+                published += 1;
             }
         }
+        return published;
     }
     async fillGroupGap(groupId) {
         const client = this.runtime.client;
-        if (client._state !== 'connected' || client._closing)
+        if (client.state !== ConnectionState.READY || client._closing)
             return;
         groupId = normalizeGroupId(groupId) || String(groupId ?? '').trim();
         if (!groupId)
@@ -798,7 +920,7 @@ export class MessageDeliveryEngine {
         this.runtime.delivery.setGapFillActive(true);
         let filled = 0;
         try {
-            const messages = await client._pullGroupV2(groupId, afterSeq, 50);
+            const messages = await client._withBackgroundRpc(() => client._pullGroupV2(groupId, afterSeq, 50));
             filled = messages.length;
             this.prunePushedSeqs(ns);
         }
@@ -815,7 +937,10 @@ export class MessageDeliveryEngine {
     }
     async fillGroupEventGap(groupId) {
         const client = this.runtime.client;
-        if (client._state !== 'connected' || client._closing)
+        if (client.state !== ConnectionState.READY || client._closing)
+            return;
+        groupId = normalizeGroupId(groupId) || String(groupId ?? '').trim();
+        if (!groupId)
             return;
         const ns = `group_event:${groupId}`;
         const afterSeq = client._seqTracker.getContiguousSeq(ns);
@@ -835,6 +960,7 @@ export class MessageDeliveryEngine {
                     after_event_seq: nextAfterSeq,
                     device_id: client._deviceId,
                     limit: 50,
+                    _rpc_background: true,
                 });
                 if (!isJsonObject(result))
                     return;
@@ -884,7 +1010,7 @@ export class MessageDeliveryEngine {
                 const ackContig = client._seqTracker.getContiguousSeq(ns);
                 await this.drainOrderedMessages(ns);
                 if (ackContig !== pageContigBefore && !hasDissolvedEvent) {
-                    this.saveSeqTrackerState();
+                    this.persistSeq(ns);
                 }
                 if (eventObjects.length > 0 && ackContig > 0 && ackContig !== pageContigBefore) {
                     const ackSeq = this.clampAckSeq('group.ack_events', 'event_seq', ns, ackContig);
@@ -893,6 +1019,7 @@ export class MessageDeliveryEngine {
                         event_seq: ackSeq,
                         device_id: client._deviceId,
                         slot_id: client._slotId,
+                        _rpc_background: true,
                     }).catch((e) => { client._clientLog.warn('group event auto-ack failed: group=' + groupId, e); });
                 }
                 const nextAfter = Math.max(eventSeqs.length > 0 ? Math.max(...eventSeqs) : nextAfterSeq, nextAfterSeq);
@@ -914,6 +1041,7 @@ export class MessageDeliveryEngine {
     }
     async handleGroupChangedEventSeq(data, groupId) {
         const client = this.runtime.client;
+        groupId = normalizeGroupId(groupId) || String(groupId ?? '').trim();
         let needPull = false;
         const rawEventSeq = data.event_seq;
         const eventSeq = Number(rawEventSeq);
@@ -931,8 +1059,15 @@ export class MessageDeliveryEngine {
             }
         }
         const contigBefore = client._seqTracker.getContiguousSeq(ns);
-        if (eventSeq <= contigBefore || client._pushedSeqs.get(ns)?.has(eventSeq)) {
+        const publishedDuplicate = client._pushedSeqs.get(ns)?.has(eventSeq) === true;
+        if (eventSeq <= contigBefore || publishedDuplicate) {
             client._clientLog.debug(`group.changed skipped duplicate/stale: group=${groupId}, event_seq=${eventSeq}, contiguous=${contigBefore}`);
+            if (eventSeq <= contigBefore) {
+                this.fireGroupEventAck(groupId, ns, eventSeq, 'group event covered push ack');
+            }
+            else if (contigBefore > 0) {
+                this.fireGroupEventAck(groupId, ns, contigBefore, 'group event covered push ack');
+            }
             return;
         }
         this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, data);
@@ -941,13 +1076,14 @@ export class MessageDeliveryEngine {
         await this.drainOrderedMessages(ns);
         if (ackContig > 0 && ackContig !== contigBefore) {
             if (data.action !== 'dissolved')
-                this.saveSeqTrackerState();
+                this.persistSeq(ns);
             const ackSeq = this.clampAckSeq('group.ack_events', 'event_seq', ns, ackContig);
             client._transport.call('group.ack_events', {
                 group_id: groupId,
                 event_seq: ackSeq,
                 device_id: client._deviceId,
                 slot_id: client._slotId,
+                _rpc_background: true,
             }).catch((e) => {
                 client._clientLog.warn('group event push auto-ack failed: group=' + groupId, e);
             });
@@ -990,7 +1126,7 @@ export class MessageDeliveryEngine {
         this.runtime.delivery.setOnlineUnreadHintDrainActive(true);
         try {
             while (client._onlineUnreadHintQueue.size > 0) {
-                if (client.state !== 'ready')
+                if (client.state !== ConnectionState.READY)
                     return;
                 if (client._sessionOptions?.background_sync === false)
                     return;
@@ -1048,8 +1184,9 @@ export class MessageDeliveryEngine {
             const ns = `group:${groupId}`;
             client._seqTracker.updateMaxSeen(ns, seq);
             const contigBefore = client._seqTracker.getContiguousSeq(ns);
-            if (contigBefore === seq) {
+            if (contigBefore === seq || (eventKind === 'group.online_unread_hint' && contigBefore > seq)) {
                 client._clientLog.debug(`_onRawGroupV2MessageCreated duplicate push already covered: group=${groupId} seq=${seq}`);
+                this.fireGroupV2Ack(groupId, ns, seq, 'group v2 covered push ack');
                 return;
             }
             const afterSeq = client._repairPushContiguousBound(ns, seq, false, '_raw.group.v2.message_created');
@@ -1061,7 +1198,7 @@ export class MessageDeliveryEngine {
             client._gapFillDone.add(dedupKey);
             try {
                 client._clientLog.debug(`_onRawGroupV2MessageCreated -> group.v2.pull group=${groupId} after_seq=${afterSeq}`);
-                const messages = await client._pullGroupV2(groupId, afterSeq, 50);
+                const messages = await client._withBackgroundRpc(() => client._pullGroupV2(groupId, afterSeq, 50));
                 client._clientLog.debug(`_onRawGroupV2MessageCreated pulled ${messages.length} msgs for group=${groupId}`);
             }
             finally {
@@ -1103,12 +1240,12 @@ export class MessageDeliveryEngine {
                     const published = await client._publishOrderedMessage('message.received', ns, pushSeq, decrypted);
                     const newContig = client._seqTracker.getContiguousSeq(ns);
                     if (newContig !== contigBefore) {
-                        client._saveSeqTrackerState();
+                        this.persistSeq(ns);
                     }
                     if (newContig > 0 && newContig !== contigBefore) {
                         const ackSeq = this.clampAckSeq('message.v2.ack', 'up_to_seq', ns, newContig);
                         try {
-                            await client._callRawV2Rpc('message.v2.ack', { up_to_seq: ackSeq });
+                            await client._callRawV2Rpc('message.v2.ack', { up_to_seq: ackSeq, _rpc_background: true });
                         }
                         catch (e) {
                             client._clientLog.debug(`V2 P2P push-ack failed: ${e}`);
@@ -1138,7 +1275,7 @@ export class MessageDeliveryEngine {
         try {
             do {
                 this.runtime.delivery.setV2PullPending(false);
-                await client._pullV2();
+                await client._withBackgroundRpc(() => client._pullV2());
                 const newContig = ns ? client._seqTracker.getContiguousSeq(ns) : -1;
                 client._clientLog.debug(`_onV2PushNotification pull done: contiguous_seq=${contigBefore}->${newContig} (push_seq=${pushSeq || 'null'})`);
             } while (client._v2PullPending);
@@ -1265,50 +1402,141 @@ export class MessageDeliveryEngine {
         }
         return newState;
     }
-    saveSeqTrackerState() {
+    async saveSeqTrackerState() {
         const client = this.runtime.client;
-        if (!client._aid)
+        const context = this.currentSeqTrackerContext();
+        if (!context) {
+            await this.flushSeqTrackerPending();
             return;
+        }
         const state = client._seqTracker.exportState();
-        if (Object.keys(state).length === 0)
+        const pending = this.seqTrackerPending();
+        if (pending.size > 0 && client._seqTrackerPendingPersistContext === context) {
+            const liveNamespaces = new Set(Object.keys(state));
+            for (const ns of [...pending.keys()]) {
+                if (!liveNamespaces.has(ns))
+                    pending.delete(ns);
+            }
+            if (pending.size === 0)
+                client._seqTrackerPendingPersistContext = null;
+        }
+        if (Object.keys(state).length > 0)
+            this.mergeSeqTrackerPending(context, state);
+        await this.flushSeqTrackerPending();
+    }
+    persistSeq(ns, forceSeq) {
+        const client = this.runtime.client;
+        const context = this.currentSeqTrackerContext();
+        if (!context) {
+            void this.flushSeqTrackerPending();
+            return;
+        }
+        const seq = forceSeq ?? client._seqTracker.getContiguousSeq(ns);
+        if (!ns || !Number.isFinite(seq) || seq <= 0)
+            return;
+        if (forceSeq !== undefined) {
+            client._seqTracker.forceContiguousSeq(ns, seq);
+        }
+        this.mergeSeqTrackerPending(context, { [ns]: seq });
+        this.scheduleSeqTrackerFlush();
+    }
+    async flushSeqTrackerPending() {
+        const client = this.runtime.client;
+        this.cancelSeqTrackerFlushTimer();
+        const context = client._seqTrackerPendingPersistContext;
+        const pending = this.seqTrackerPending();
+        if (!context || pending.size === 0) {
+            client._seqTrackerPendingPersistContext = null;
+            return;
+        }
+        const [aid, deviceId, slotId] = JSON.parse(context);
+        const state = Object.fromEntries(pending.entries());
+        pending.clear();
+        client._seqTrackerPendingPersistContext = null;
+        await this.writeSeqTrackerState(aid, deviceId, slotId, state);
+    }
+    dropSeqTrackerPending(ns) {
+        const client = this.runtime.client;
+        const pending = this.seqTrackerPending();
+        pending.delete(ns);
+        if (pending.size === 0) {
+            client._seqTrackerPendingPersistContext = null;
+            this.cancelSeqTrackerFlushTimer();
+        }
+    }
+    currentSeqTrackerContext() {
+        const client = this.runtime.client;
+        if (!client._aid)
+            return null;
+        return JSON.stringify([client._aid, client._deviceId, client._slotId]);
+    }
+    seqTrackerPending() {
+        const client = this.runtime.client;
+        if (!(client._seqTrackerPendingPersist instanceof Map)) {
+            client._seqTrackerPendingPersist = new Map();
+        }
+        return client._seqTrackerPendingPersist;
+    }
+    mergeSeqTrackerPending(context, state) {
+        const client = this.runtime.client;
+        const pending = this.seqTrackerPending();
+        const pendingContext = client._seqTrackerPendingPersistContext;
+        if (pendingContext && pendingContext !== context && pending.size > 0) {
+            void this.flushSeqTrackerPending();
+        }
+        client._seqTrackerPendingPersistContext = context;
+        for (const [ns, seq] of Object.entries(state)) {
+            const seqNum = Number(seq);
+            if (ns && Number.isFinite(seqNum) && seqNum > 0) {
+                pending.set(ns, seqNum);
+            }
+        }
+    }
+    scheduleSeqTrackerFlush() {
+        const client = this.runtime.client;
+        const pending = this.seqTrackerPending();
+        if (pending.size === 0)
+            return;
+        if (client._seqTrackerFlushTimer)
+            return;
+        client._seqTrackerFlushTimer = setTimeout(() => {
+            client._seqTrackerFlushTimer = null;
+            void this.flushSeqTrackerPending();
+        }, SEQ_TRACKER_PERSIST_FLUSH_DELAY_MS);
+    }
+    cancelSeqTrackerFlushTimer() {
+        const client = this.runtime.client;
+        if (client._seqTrackerFlushTimer) {
+            clearTimeout(client._seqTrackerFlushTimer);
+            client._seqTrackerFlushTimer = null;
+        }
+    }
+    async writeSeqTrackerState(aid, deviceId, slotId, state) {
+        const client = this.runtime.client;
+        if (!aid || Object.keys(state).length === 0)
             return;
         try {
             const saveFn = client._tokenStore.saveSeq?.bind(client._tokenStore);
             if (typeof saveFn === 'function') {
-                for (const [ns, seq] of Object.entries(state)) {
-                    saveFn(client._aid, client._deviceId, client._slotId, ns, seq).catch((exc) => {
-                        client._dispatcher.publish('seq_tracker.persist_error', {
-                            phase: 'save',
-                            aid: client._aid,
-                            device_id: client._deviceId,
-                            slot_id: client._slotId,
-                            error: String(exc),
-                        }).catch(() => { });
-                    });
-                }
+                await Promise.all(Object.entries(state).map(([ns, seq]) => saveFn(aid, deviceId, slotId, ns, seq)));
                 return;
             }
             if (typeof client._tokenStore.updateInstanceState === 'function') {
-                client._tokenStore.updateInstanceState(client._aid, client._deviceId, client._slotId, (current) => {
-                    current.seq_tracker_state = state;
+                await client._tokenStore.updateInstanceState(aid, deviceId, slotId, (current) => {
+                    const existing = isJsonObject(current.seq_tracker_state)
+                        ? { ...current.seq_tracker_state }
+                        : {};
+                    current.seq_tracker_state = { ...existing, ...state };
                     return current;
-                }).catch((exc) => {
-                    client._dispatcher.publish('seq_tracker.persist_error', {
-                        phase: 'save',
-                        aid: client._aid,
-                        device_id: client._deviceId,
-                        slot_id: client._slotId,
-                        error: String(exc),
-                    }).catch(() => { });
                 });
             }
         }
         catch (exc) {
             client._dispatcher.publish('seq_tracker.persist_error', {
                 phase: 'save',
-                aid: client._aid,
-                device_id: client._deviceId,
-                slot_id: client._slotId,
+                aid,
+                device_id: deviceId,
+                slot_id: slotId,
                 error: String(exc),
             }).catch(() => { });
         }
@@ -1318,6 +1546,7 @@ export class MessageDeliveryEngine {
         if (!client._aid || !ns)
             return;
         const seq = client._seqTracker.getContiguousSeq(ns);
+        this.dropSeqTrackerPending(ns);
         try {
             if (seq > 0 && typeof client._tokenStore.saveSeq === 'function') {
                 client._tokenStore.saveSeq(client._aid, client._deviceId, client._slotId, ns, seq).catch((exc) => {
@@ -1332,8 +1561,21 @@ export class MessageDeliveryEngine {
                 });
                 return;
             }
+            if (seq <= 0 && typeof client._tokenStore.updateInstanceState === 'function') {
+                Promise.resolve(client._tokenStore.updateInstanceState(client._aid, client._deviceId, client._slotId, (current) => {
+                    if (isJsonObject(current.seq_tracker_state)) {
+                        const next = { ...current.seq_tracker_state };
+                        delete next[ns];
+                        current.seq_tracker_state = next;
+                    }
+                    return current;
+                })).catch((exc) => {
+                    client._clientLog.debug(`delete repaired seq failed: ns=${ns} err=${formatDeliveryError(exc)}`);
+                });
+                return;
+            }
             if (seq > 0) {
-                this.saveSeqTrackerState();
+                void this.saveSeqTrackerState();
             }
         }
         catch (exc) {
@@ -1395,6 +1637,7 @@ export class MessageDeliveryEngine {
         const ready = [...queue.keys()]
             .filter((seq) => seq <= contig && (beforeSeq === undefined || seq < beforeSeq))
             .sort((a, b) => a - b);
+        let delivered = false;
         for (const seq of ready) {
             const item = queue.get(seq);
             queue.delete(seq);
@@ -1402,9 +1645,13 @@ export class MessageDeliveryEngine {
                 continue;
             await this.publishOrderedQueueItem(ns, item.event, seq, item.payload);
             this.markPublishedSeq(ns, seq);
+            delivered = true;
         }
-        if (queue.size === 0)
+        if (queue.size === 0) {
             client._pendingOrderedMsgs.delete(ns);
+            if (delivered)
+                await this.saveSeqTrackerState();
+        }
     }
     async publishOrderedMessage(event, ns, seq, payload) {
         const client = this.runtime.client;
@@ -1435,6 +1682,8 @@ export class MessageDeliveryEngine {
         await this.publishOrderedQueueItem(ns, event, seqNum, payload);
         this.markPublishedSeq(ns, seqNum);
         await this.drainOrderedMessages(ns);
+        if (!client._pendingOrderedMsgs.get(ns))
+            await this.saveSeqTrackerState();
         return true;
     }
     async publishPulledMessage(event, ns, seq, payload) {