@agentunion/fastaun 0.5.34 → 0.5.36

package/dist/client/delivery.js

@@ -104,9 +104,73 @@ function deduplicatePlainForwardPageMessages(value, afterSeq) {
 }
 export class MessageDeliveryEngine {
     runtime;
+    forwardAckJobs = new Map();
+    forwardAckTasks = new Set();
+    scheduleForwardAck(ns, seq, send) {
+        const client = this.runtime.client;
+        if (client._closing || seq <= 0)
+            return;
+        const scope = () => [client._aid, client._deviceId, client._slotId, this.captureInlineAckGeneration(),
+            client._v2RuntimeGeneration, client._transport, client._transport?._connectionGeneration,
+            client._transport?._workerGeneration, this.captureSeqNamespaceGeneration(ns)];
+        const current = scope();
+        const previous = this.forwardAckJobs.get(ns);
+        if (previous && previous.scope.every((value, i) => value === current[i])) {
+            if (seq > previous.seq) {
+                previous.seq = seq;
+                previous.send = send;
+            }
+            return;
+        }
+        const job = { seq, scope: current, send };
+        this.forwardAckJobs.set(ns, job);
+        const isCurrent = () => this.forwardAckJobs.get(ns) === job && job.scope.every((value, i) => value === scope()[i]);
+        const task = (async () => {
+            let failures = 0;
+            while (isCurrent()) {
+                const pending = job.seq;
+                try {
+                    await job.send(pending);
+                    failures = 0;
+                    if (job.seq <= pending) {
+                        if (this.forwardAckJobs.get(ns) === job)
+                            this.forwardAckJobs.delete(ns);
+                        return;
+                    }
+                }
+                catch {
+                    if (!isCurrent() || client._closing || client.state !== ConnectionState.READY)
+                        return;
+                    if (job.seq <= pending)
+                        await new Promise(resolve => setTimeout(resolve, Math.min(100 * 2 ** Math.min(failures++, 5), 3000)));
+                }
+            }
+        })().finally(() => {
+            if (this.forwardAckJobs.get(ns) === job)
+                this.forwardAckJobs.delete(ns);
+            this.forwardAckTasks.delete(task);
+        });
+        this.forwardAckTasks.add(task);
+    }
+    drainForwardAcks() {
+        if (!this.forwardAckTasks.size)
+            return;
+        return this.waitForwardAcks();
+    }
+    async waitForwardAcks() {
+        let timer;
+        try {
+            await Promise.race([Promise.allSettled([...this.forwardAckTasks]), new Promise(resolve => { timer = setTimeout(resolve, 1000); })]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     realtimeTailHeads = null;
     realtimeSyncing = null;
     pendingGroupPullUpper = null;
+    pendingV2GroupPulls = new Set();
     onlineUnreadHintTargets = null;
     onlineUnreadHintTasks = null;
     backgroundPullNeeds = new Map();
@@ -116,6 +180,7 @@ export class MessageDeliveryEngine {
     backgroundPullTimerAt = 0;
     pendingP2PInlineAcks = null;
     pendingGroupInlineAcks = null;
+    pendingGroupInlineAckCount = 0;
     pendingGroupInlineAckNamespaces = null;
     inlineAckGeneration = 0;
     pendingDeliveryChanges = null;
@@ -574,6 +639,7 @@ export class MessageDeliveryEngine {
         if (!namespace.startsWith('p2p.peer.v1/') || !Number.isSafeInteger(sequence) || sequence < 0)
             return;
         this.peerServerConfirmedAcks.set(namespace, Math.max(this.peerServerConfirmedAcks.get(namespace) ?? 0, sequence));
+        this.runtime.client._rpcPipeline?.confirmBackgroundAck?.(namespace, sequence);
     }
     rememberCommittedSeqState(namespace) {
         this.ensurePeerContext();
@@ -935,6 +1001,8 @@ export class MessageDeliveryEngine {
         if (this.peerRecoveryTasks.has(sender))
             return;
         const generation = this.captureInlineAckGeneration();
+        const recoveryVersion = this.capturePeerTailVersion(sender);
+        const recoveryAck = this.peerCommittedAck(namespace);
         const task = (async () => {
             await this.runAutomaticPull(`peer-init:${sender}`, () => this.initializePeer(sender));
             if (!this.hasP2pApplicationSubscription())
@@ -996,7 +1064,9 @@ export class MessageDeliveryEngine {
                     const beforeAck = this.peerCommittedAck(namespace);
                     const beforeVolatile = this.peerVolatilePullCursor(sender);
                     const beforeWindow = this.syncState(namespace);
-                    const result = await client._v2E2EE.pullPeerV2(sender, { background: true, retainMessages: false, budget: { remaining: 100 } });
+                    const result = await client._v2E2EE.pullPeerV2(sender, { background: true, retainMessages: false, budget: { remaining: 100 },
+                        ...(!need.volatile && need.head > 0 && pushVersion === recoveryVersion.push && catalogVersion === recoveryVersion.catalog
+                            ? { autoPeerHead: need.head, autoPeerAckFloor: recoveryAck } : {}) });
                     need.volatile ||= result.volatile_has_more === true;
                     const afterWindow = this.syncState(namespace);
                     if ((!result.complete || result.ack_seq < need.head) && this.peerCommittedAck(namespace) <= beforeAck && this.peerVolatilePullCursor(sender) === beforeVolatile
@@ -1106,7 +1176,7 @@ export class MessageDeliveryEngine {
             this.onGroupV2AckSucceeded(groupId, actualAckSeq, generation);
         }
     }
-    async commitPlainForwardPage(ns, afterSeq, method, result, groupId = '') {
+    async commitPlainForwardPage(ns, afterSeq, method, result, groupId = '', background = false) {
         if (!isJsonObject(result)) {
             throw new Error(`${method} response must be an object`);
         }
@@ -1250,7 +1320,10 @@ export class MessageDeliveryEngine {
                 throw new Error(`${ackMethod} cannot confirm pending Forward watermark ${pendingAckSeq}`);
             }
             this.ensurePullOperationCurrent(ns);
-            await this.confirmPlainForwardAck(ns, ackMethod, pendingAckSeq, groupId);
+            if (background)
+                this.scheduleForwardAck(ns, pendingAckSeq, seq => this.confirmPlainForwardAck(ns, ackMethod, seq, groupId));
+            else
+                await this.confirmPlainForwardAck(ns, ackMethod, pendingAckSeq, groupId);
         }
         this.syncProgress(ns, {
             rawCount: messages.length,
@@ -1455,9 +1528,11 @@ export class MessageDeliveryEngine {
         void this.runtime.client._rpcPipeline?.invalidatePulls?.();
         this.pendingP2PInlineAcks = null;
         this.pendingGroupInlineAcks = null;
+        this.pendingGroupInlineAckCount = 0;
         this.pendingGroupInlineAckNamespaces = null;
         this.realtimeSyncing = null;
         this.pendingGroupPullUpper = null;
+        this.pendingV2GroupPulls.clear();
         this.onlineUnreadHintTargets = null;
         this.onlineUnreadHintTasks = null;
         this.realtimeTailHeads = null;
@@ -1715,7 +1790,7 @@ export class MessageDeliveryEngine {
             await processing;
     }
     pendingInlineAckNamespaceCount() {
-        return (this.pendingP2PInlineAcks?.size ?? 0) + (this.pendingGroupInlineAcks?.size ?? 0);
+        return (this.pendingP2PInlineAcks?.size ?? 0) + this.pendingGroupInlineAckCount;
     }
     markRealtimeTailCompleted(result, tailHead) {
         const heads = this.realtimeTailHeads ?? new WeakMap();
@@ -1937,6 +2012,11 @@ export class MessageDeliveryEngine {
                     this.backgroundPullNeeds.delete(ns);
                     continue;
                 }
+                if (this.pendingV2GroupPulls.has(ns)) {
+                    if (!client._v2Session)
+                        continue;
+                    this.pendingV2GroupPulls.delete(ns);
+                }
                 if (ns.startsWith('p2p:') && !this.hasP2pApplicationSubscription())
                     continue;
                 if (need.messageClassRequest && need.messageClassRequest.message_class !== 'sdk_control') {
@@ -2362,6 +2442,8 @@ export class MessageDeliveryEngine {
             return applicationResult({ ...result, message_class: 'sdk_control' });
         if (!APP_SEND_ENVELOPE_METHODS.has(method) || !isJsonObject(result))
             return result;
+        if (result.status === 'echo_return')
+            return result;
         let out = { ...result };
         const serverEnvelope = method === 'group.send' && isJsonObject(out.envelope)
             ? { ...out.envelope }
@@ -2686,8 +2768,10 @@ export class MessageDeliveryEngine {
                 return this.runApplicationPage(namespace, source, async () => { await this.publishAppEvent(event, payload, source, deliveryContext); });
             }
         }
-        if ((event === 'message.received' || event === 'group.message_created') && isJsonObject(payload)) {
-            client._maybeAppendEchoTraceReceive(payload);
+        if (source !== 'echo_return' && (event === 'message.received' || event === 'group.message_created') && isJsonObject(payload)) {
+            if (client._maybeAppendEchoTraceReceive(payload)) {
+                return client._returnReceivedEcho(payload);
+            }
         }
         this.logAppMessagePublish(event, payload, source);
         if (isJsonObject(payload)) {
@@ -2929,7 +3013,14 @@ export class MessageDeliveryEngine {
     }
     async onRawMessageReceived(data) {
         const client = this.runtime.client;
-        if (client._p2pPeerPullEnabled) {
+        if (isJsonObject(data) && !client._echoStarts.has(data))
+            client._echoStarts.set(data, performance.now());
+        const message = isJsonObject(data) ? data : undefined;
+        const payload = message?.payload;
+        const plainEcho = message && !message.encrypted && !message.encrypt && isJsonObject(payload)
+            && !String(payload.type ?? '').trim().toLowerCase().startsWith('e2ee') && !payload.ciphertext
+            && !client._isEncryptedPushMessage(message) && client._isEchoPayload(payload);
+        if (client._p2pPeerPullEnabled && !plainEcho) {
             await this.onPeerPush(data);
             return;
         }
@@ -2998,6 +3089,7 @@ export class MessageDeliveryEngine {
             return;
         }
         const msg = { ...data };
+        client._echoStarts.set(msg, client._echoStarts.get(data) ?? performance.now());
         if (!this.messageTargetsCurrentInstance(msg)) {
             client._clientLog.debug(`P2P push filtered by instance: message_id=${String(msg.message_id ?? '')}, seq=${String(msg.seq ?? '')}, target_device=${String(msg.device_id ?? '')}, target_slot=${String(msg.slot_id ?? '')}, local_device=${client._deviceId}, local_slot=${client._slotId}`);
             return;
@@ -3054,6 +3146,8 @@ export class MessageDeliveryEngine {
     }
     async onRawGroupMessageCreated(data) {
         const client = this.runtime.client;
+        if (isJsonObject(data) && !client._echoStarts.has(data))
+            client._echoStarts.set(data, performance.now());
         const tStart = Date.now();
         if (isJsonObject(data)) {
             client._logMessageDebug('server-push', '_raw.group.message_created', 'group.message_created', data);
@@ -3094,6 +3188,7 @@ export class MessageDeliveryEngine {
         }
         const msg = { ...data };
         const groupId = String(msg.group_id ?? '');
+        client._echoStarts.set(msg, client._echoStarts.get(data) ?? performance.now());
         const seq = msg.seq;
         const payload = msg.payload;
         if (groupId) {
@@ -3210,7 +3305,7 @@ export class MessageDeliveryEngine {
         try {
             // Gap Fill 本身就是 Forward Pull，必须沿用协调器的完整事务：
             // 原始页提交成功后由协调器负责 Piggyback/终端 ACK。
-            const operation = () => client._pullV2(afterSeq, _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize, { gateLocked: true });
+            const operation = () => client._pullV2(afterSeq, _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize, { gateLocked: true, background: true });
             const messages = await this.runAutomaticPull(ns, operation, (attempt) => client._rpcPipeline
                 ? client._rpcPipeline.runPullSerialized(client._rpcPipeline.pullGateKeyForCall('message.pull', { after_seq: afterSeq, limit: _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize }), attempt, true)
                 : client._withBackgroundRpc(attempt));
@@ -3606,7 +3701,7 @@ export class MessageDeliveryEngine {
         return result;
     }
     reservePendingGroupInlineAck(ns, seq, row, groupAid) {
-        if (!ns || !Number.isSafeInteger(seq) || seq <= 0 || this.pendingGroupInlineAcks?.has(ns)
+        if (!ns || !Number.isSafeInteger(seq) || seq <= 0 || this.pendingGroupInlineAcks?.get(ns)?.has(seq)
             || this.pendingInlineAckNamespaceCount() >= MAX_INLINE_PENDING_ACK_NAMESPACES)
             return false;
         const normalizedGroupAid = typeof groupAid === 'string' ? groupAid.trim() : '';
@@ -3616,7 +3711,9 @@ export class MessageDeliveryEngine {
         const namespaceMap = this.pendingGroupInlineAckNamespaces ?? new Map();
         this.pendingGroupInlineAcks = pendingMap;
         this.pendingGroupInlineAckNamespaces = namespaceMap;
-        pendingMap.set(ns, {
+        const entries = pendingMap.get(ns) ?? new Map();
+        pendingMap.set(ns, entries);
+        entries.set(seq, {
             seq,
             row: this.inlinePostAckRow(row),
             groupAid: normalizedGroupAid,
@@ -3625,6 +3722,7 @@ export class MessageDeliveryEngine {
             committed: false,
             observedAckSeq: 0,
         });
+        this.pendingGroupInlineAckCount++;
         for (const namespace of namespaces) {
             let candidates = namespaceMap.get(namespace);
             if (!candidates) {
@@ -3637,10 +3735,23 @@ export class MessageDeliveryEngine {
     }
     removePendingGroupInlineAck(ns, pending) {
         const pendingMap = this.pendingGroupInlineAcks;
-        if (pendingMap?.get(ns) !== pending)
+        const entries = pendingMap?.get(ns);
+        if (entries?.get(pending.seq) !== pending)
             return false;
-        pendingMap.delete(ns);
+        entries.delete(pending.seq);
+        this.pendingGroupInlineAckCount--;
+        if (entries.size === 0)
+            pendingMap?.delete(ns);
         for (const namespace of pending.namespaces) {
+            let retained = false;
+            for (const other of entries.values()) {
+                if (other.namespaces.includes(namespace)) {
+                    retained = true;
+                    break;
+                }
+            }
+            if (retained)
+                continue;
             const aliases = this.pendingGroupInlineAckNamespaces?.get(namespace);
             if (!aliases)
                 continue;
@@ -3651,8 +3762,8 @@ export class MessageDeliveryEngine {
         return true;
     }
     dropPendingGroupInlineAck(ns, seq) {
-        const pending = this.pendingGroupInlineAcks?.get(ns);
-        if (pending?.seq === seq)
+        const pending = this.pendingGroupInlineAcks?.get(ns)?.get(seq);
+        if (pending)
             this.removePendingGroupInlineAck(ns, pending);
     }
     resolvePendingGroupInlineAckNamespace(ns) {
@@ -3673,19 +3784,23 @@ export class MessageDeliveryEngine {
         const canonicalNs = candidates.values().next().value;
         if (typeof canonicalNs !== 'string')
             return;
-        const pending = this.pendingGroupInlineAcks?.get(canonicalNs);
-        if (!pending || upToSeq < pending.seq)
-            return;
-        if (!pending.committed) {
-            pending.observedAckSeq = Math.max(pending.observedAckSeq, upToSeq);
+        const entries = this.pendingGroupInlineAcks?.get(canonicalNs);
+        if (!entries)
             return;
+        for (const pending of entries.values()) {
+            if (upToSeq < pending.seq)
+                continue;
+            if (!pending.committed) {
+                pending.observedAckSeq = Math.max(pending.observedAckSeq, upToSeq);
+                continue;
+            }
+            this.removePendingGroupInlineAck(canonicalNs, pending);
+            this.runPostInlineCommit(pending.row);
         }
-        this.removePendingGroupInlineAck(canonicalNs, pending);
-        this.runPostInlineCommit(pending.row);
     }
     markPendingGroupInlineAckCommitted(ns, seq) {
-        const pending = this.pendingGroupInlineAcks?.get(ns);
-        if (!pending || pending.seq !== seq)
+        const pending = this.pendingGroupInlineAcks?.get(ns)?.get(seq);
+        if (!pending)
             return false;
         pending.committed = true;
         if (pending.observedAckSeq < seq)
@@ -3695,8 +3810,8 @@ export class MessageDeliveryEngine {
         return true;
     }
     retryPendingGroupInlineAck(ns, seq, reason, ackThrough = seq) {
-        const pending = this.pendingGroupInlineAcks?.get(ns);
-        if (!pending || pending.seq !== seq)
+        const pending = this.pendingGroupInlineAcks?.get(ns)?.get(seq);
+        if (!pending)
             return false;
         if (pending.acking || !pending.committed)
             return true;
@@ -3715,12 +3830,12 @@ export class MessageDeliveryEngine {
             })).then((result) => {
                 this.onGroupV2AckResult(groupId, result, requestedSeq, generation);
             }).catch((error) => {
-                const current = this.pendingGroupInlineAcks?.get(ns);
+                const current = this.pendingGroupInlineAcks?.get(ns)?.get(seq);
                 if (current === pending)
                     current.acking = false;
                 this.runtime.client._clientLog.debug(`group.v2 ${reason} ack failed: group=${groupId} ${formatDeliveryError(error)}`);
             }).finally(() => {
-                const current = this.pendingGroupInlineAcks?.get(ns);
+                const current = this.pendingGroupInlineAcks?.get(ns)?.get(seq);
                 if (current === pending)
                     current.acking = false;
             });
@@ -3743,6 +3858,7 @@ export class MessageDeliveryEngine {
         const gid = String(groupId ?? '').trim();
         if (!gid || !Number.isSafeInteger(upToSeq) || upToSeq <= 0)
             return;
+        this.runtime.client._rpcPipeline?.confirmBackgroundAck?.(this.resolvePendingGroupInlineAckNamespace(`group:${gid}`), upToSeq);
         this.completePendingGroupInlineAck(`group:${gid}`, upToSeq);
     }
     onGroupV2AckResult(groupId, result, requestedSeq, generation = this.inlineAckGeneration) {
@@ -3859,7 +3975,7 @@ export class MessageDeliveryEngine {
                     tailHead = this.syncState(ns).head;
                     return tailResult;
                 }
-                const opts = { gateLocked: true };
+                const opts = { gateLocked: true, background };
                 if (request.max_pages !== undefined)
                     opts.maxPages = request.max_pages;
                 const messages = await client._pullV2(after, pageLimit, opts);
@@ -3985,7 +4101,7 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         const request = { after_seq: this.syncState(ns).ack, limit: pageLimit, max_pages: 1 };
         const invoke = async () => {
-            const messages = await client._pullV2(Number(request.after_seq), pageLimit, { gateLocked: true, maxPages: 1 });
+            const messages = await client._pullV2(Number(request.after_seq), pageLimit, { gateLocked: true, maxPages: 1, background });
             return { messages, raw_count: messages.length };
         };
         if (!client._rpcPipeline)
@@ -4709,15 +4825,20 @@ export class MessageDeliveryEngine {
                     client._seqTracker._restoreNamespaceSnapshotPreservingPush(ns, snapshot);
                     throw error;
                 }
-                await client._v2E2EE.ackPeerV2(sender, this.syncState(ns).ack);
                 return true;
             })).catch((error) => {
                 if (generation === this.captureInlineAckGeneration())
                     this.schedulePeerRecovery(sender, seq);
                 throw error;
             });
-            if (consumed?.acquired && consumed.value && !unbounded)
-                return;
+            if (consumed?.acquired && consumed.value && generation === this.captureInlineAckGeneration()) {
+                this.scheduleForwardAck(ns, this.peerCommittedAck(ns), async (ack) => {
+                    if (!this.isPeerHeadCovered(ns, ack))
+                        await client._v2E2EE.ackPeerV2(sender, ack);
+                });
+                if (!unbounded)
+                    return;
+            }
         }
         if ((!unbounded && this.isPeerHeadCovered(ns, seq)) || !this.hasP2pApplicationSubscription())
             return;
@@ -4729,7 +4850,7 @@ export class MessageDeliveryEngine {
         }
         else {
             await this.runAutomaticPull(ns, () => client._v2E2EE.pullPeerV2(sender, { limit: _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize, budget: { remaining: 1 },
-                ...(!unbounded ? { autoPeerHead: seq, peerPullVersion } : {}),
+                ...(!unbounded ? { autoPeerHead: seq, autoPeerAckFloor: committedAck, peerPullVersion } : {}),
                 ...(this.shouldTailPeer(ns, seq, _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize) ? { window_mode: 'tail', autoTail: { head: seq, forward: false } } : {}) }));
         }
     }
@@ -4843,11 +4964,11 @@ export class MessageDeliveryEngine {
             const coordinator = client._v2E2EE;
             const pendingAckSeq = Number(coordinator.pendingForwardAck?.(ns, committedAck) ?? 0);
             if (pendingAckSeq > 0) {
-                client._safeAsync(coordinator.confirmForwardGroupAck(groupId, pendingAckSeq, String(data.group_aid ?? '').trim() || undefined, true));
+                this.scheduleForwardAck(ns, pendingAckSeq, seq => coordinator.confirmForwardGroupAck(groupId, seq, String(data.group_aid ?? '').trim() || undefined, true));
             }
             else {
                 const pendingNs = this.resolvePendingGroupInlineAckNamespace(ns);
-                const pending = this.pendingGroupInlineAcks?.get(pendingNs);
+                const pending = this.pendingGroupInlineAcks?.get(pendingNs)?.values().next().value;
                 if (pending)
                     this.retryPendingGroupInlineAck(pendingNs, pending.seq, 'covered online hint', committedAck);
             }
@@ -4904,8 +5025,6 @@ export class MessageDeliveryEngine {
         const groupId = typeof d.group_id === 'string' ? d.group_id.trim() : '';
         const rawSeq = d.seq;
         const inlinePresent = hasNonEmptyInlineMessage(d.inline_message);
-        if (!client._v2Session && !(expectedVersion === 'v1' && inlinePresent))
-            return;
         const seq = this.realtimeHeadSeq(rawSeq, inlinePresent);
         if (!groupId) {
             client._clientLog.debug(`_onRawGroupV2MessageCreated skipped: group=${groupId || '<empty>'}, seq=${String(d.seq ?? '')}`);
@@ -4918,6 +5037,15 @@ export class MessageDeliveryEngine {
             return;
         }
         const eventKind = String(d.kind ?? '').trim();
+        if (!client._v2Session && !(expectedVersion === 'v1' && inlinePresent)) {
+            if (client._sessionOptions?.background_sync !== false) {
+                const ns = `group:${groupId}`;
+                this.recordBackgroundPullNeed(ns, seq, eventKind === 'group.online_unread_hint', true);
+                if (this.backgroundPullNeeds.has(ns))
+                    this.pendingV2GroupPulls.add(ns);
+            }
+            return;
+        }
         if (eventKind === 'group.online_unread_hint') {
             if (client._sessionOptions.background_sync === false)
                 return;
@@ -4928,9 +5056,7 @@ export class MessageDeliveryEngine {
         if (this.automaticGroupPullStopped(ns))
             return;
         let inlineConsumed = false;
-        const pendingInlineAck = this.pendingGroupInlineAcks?.get(ns);
-        const inlineBlockedByPendingAck = Boolean(pendingInlineAck && pendingInlineAck.seq !== seq);
-        if (inlinePresent && !inlineBlockedByPendingAck && isJsonObject(d.inline_message)) {
+        if (inlinePresent && isJsonObject(d.inline_message)) {
             try {
                 inlineConsumed = await this.tryConsumeInlineGroup(d, groupId, ns, seq, expectedVersion, inlineGeneration);
                 if (inlineGeneration !== undefined && !this.inlineGenerationIsCurrent(inlineGeneration))
@@ -4951,8 +5077,8 @@ export class MessageDeliveryEngine {
         client._seqTracker.updateMaxSeen(ns, seq);
         if (seq <= before.ack && before.ack >= before.tail - 1) {
             client._clientLog.debug(`V2 group duplicate push ignored: group=${groupId} seq=${seq} A/T/H=${JSON.stringify(before)}`);
-            const pending = this.pendingGroupInlineAcks?.get(ns);
-            if (inlinePresent && pending?.seq === seq) {
+            const pending = this.pendingGroupInlineAcks?.get(ns)?.get(seq);
+            if (inlinePresent && pending) {
                 this.retryPendingGroupInlineAck(ns, seq, 'covered inline push');
             }
             return;
@@ -5052,18 +5178,44 @@ export class MessageDeliveryEngine {
             this.refreshPendingPeers();
             return;
         }
-        if (!client._aid || !client._v2Session)
+        if (!client._aid || !client._v2Session || client._sessionOptions?.background_sync === false)
             return;
         const ns = `p2p:${client._aid}`;
         const generation = this.captureInlineAckGeneration();
-        const afterSeq = this.syncState(ns).ack;
-        this.recordBackgroundPullNeed(ns, positiveSafeSequenceHint(data.seq), true, true);
+        const state = this.syncState(ns);
+        const afterSeq = state.ack;
+        const hintSeq = positiveSafeSequenceHint(data.seq);
+        if (hintSeq > 0 && afterSeq >= Math.max(hintSeq, state.head, Number(client._seqTracker.getMaxSeenSeq?.(ns) ?? 0), Number(client._pendingP2pPullUpper?.get?.(ns) ?? 0))
+            && afterSeq >= state.tail - 1 && !client._pendingOrderedMsgs.get(ns)?.size) {
+            const coordinator = client._v2E2EE;
+            const pendingAckSeq = Number(coordinator.pendingForwardAck?.(ns, afterSeq) ?? 0);
+            if (pendingAckSeq > 0) {
+                this.scheduleForwardAck(ns, pendingAckSeq, seq => coordinator.confirmForwardP2PAck(seq));
+            }
+            else {
+                const pending = this.pendingP2PInlineAcks?.get(ns);
+                if (pending)
+                    this.retryPendingP2PInlineAck(ns, pending.seq, 'covered online hint', afterSeq);
+            }
+            return;
+        }
+        this.recordBackgroundPullNeed(ns, hintSeq, true, true);
         const pullTrigger = this.backgroundPullNeeds.get(ns)?.trigger;
+        const tasks = this.onlineUnreadHintTasks ?? new Map();
+        this.onlineUnreadHintTasks = tasks;
+        if (tasks.has(ns))
+            return;
         let failed = false;
-        client._safeAsync(this.runP2PForwardRecovery(ns, _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize, true).catch((exc) => {
+        const task = this.runP2PForwardRecovery(ns, _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize, true).then(() => undefined).catch((exc) => {
             failed = true;
             client._clientLog.debug(`P2P online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
-        }).finally(() => this.finishBackgroundPull(ns, generation, afterSeq, failed, pullTrigger)));
+        }).finally(() => {
+            if (tasks.get(ns) === task)
+                tasks.delete(ns);
+            this.finishBackgroundPull(ns, generation, afterSeq, failed, pullTrigger);
+        });
+        tasks.set(ns, task);
+        client._safeAsync(task);
     }
     async saveSeqTrackerState() {
         const client = this.runtime.client;
@@ -5413,9 +5565,10 @@ export class MessageDeliveryEngine {
             }
             else if (method === 'group.v2.ack' || method === 'group.ack_messages') {
                 const canonicalNs = this.resolvePendingGroupInlineAckNamespace(ns);
-                const pending = this.pendingGroupInlineAcks?.get(canonicalNs);
-                if (pending && !pending.committed && next >= pending.seq)
-                    next = pending.seq - 1;
+                for (const pending of this.pendingGroupInlineAcks?.get(canonicalNs)?.values() ?? []) {
+                    if (!pending.committed && next >= pending.seq)
+                        next = pending.seq - 1;
+                }
             }
         }
         return next;