@agentunion/fastaun-browser 0.5.19 → 0.5.20

package/dist/client/delivery.js

@@ -133,6 +133,9 @@ export class MessageDeliveryEngine {
     pendingPullNoProgressAcks = null;
     onlineUnreadHintTargets = null;
     onlineUnreadHintOwners = null;
+    backgroundPullDemands = new Map();
+    backgroundPullTimer = null;
+    backgroundPullRecoveryQueued = false;
     realtimeAcking = null;
     pendingP2PInlineAcks = null;
     pendingGroupInlineAcks = null;
@@ -161,6 +164,11 @@ export class MessageDeliveryEngine {
         this.pendingPullNoProgressAcks = null;
         this.onlineUnreadHintTargets = null;
         this.onlineUnreadHintOwners = null;
+        this.backgroundPullDemands.clear();
+        if (this.backgroundPullTimer !== null)
+            clearTimeout(this.backgroundPullTimer);
+        this.backgroundPullTimer = null;
+        this.backgroundPullRecoveryQueued = false;
         this.realtimeTailResults = null;
         this.realtimeAcking = null;
         this.pendingP2PInlineAcks = null;
@@ -326,8 +334,107 @@ export class MessageDeliveryEngine {
         if (!ns)
             return;
         this.schedulePendingPullIfNeeded(ns, 'pull-gate-idle');
+        this.requestBackgroundPullRecovery();
+    }
+    recordBackgroundPullDemand(ns, throughSeq = 0, probe = false) {
+        const demand = this.backgroundPullDemands.get(ns) ?? {
+            throughSeq: 0, hasMore: false, probe: false, afterSeq: -1, retryAt: 0,
+        };
+        demand.throughSeq = Math.max(demand.throughSeq, positiveSafeSequenceHint(throughSeq));
+        demand.probe ||= probe;
+        this.backgroundPullDemands.set(ns, demand);
+        return demand;
+    }
+    observeBackgroundPullResponse(ns, afterSeq, result, limit = 50) {
+        if (!ns || this.runtime.client._sessionOptions?.background_sync === false)
+            return;
+        const cursor = isJsonObject(result.cursor) ? result.cursor : null;
+        const rows = Array.isArray(result.messages) ? result.messages : Array.isArray(result.events) ? result.events : [];
+        let throughSeq = Math.max(positiveSafeSequenceHint(cursor?.latest_seq), positiveSafeSequenceHint(result.latest_seq), positiveSafeSequenceHint(result.latest_message_seq), positiveSafeSequenceHint(result.latest_event_seq));
+        for (const row of rows) {
+            if (!isJsonObject(row) || this.isVolatileMessage(row))
+                continue;
+            throughSeq = Math.max(throughSeq, positiveSafeSequenceHint(row.seq ?? row.event_seq));
+        }
+        const demand = this.recordBackgroundPullDemand(ns, throughSeq);
+        if (afterSeq >= demand.afterSeq) {
+            demand.afterSeq = afterSeq;
+            demand.hasMore = result.has_more === true
+                || positiveSafeSequenceHint(result.remaining) > 0
+                || (!Object.prototype.hasOwnProperty.call(result, 'has_more') && limit > 0 && rows.length >= limit);
+            demand.probe = false;
+        }
+        this.requestBackgroundPullRecovery();
+    }
+    finishBackgroundPull(ns, afterSeq, failed) {
+        const demand = this.backgroundPullDemands.get(ns);
+        if (demand) {
+            const state = this.syncState(ns);
+            const ack = state.ack;
+            if (ack < state.tail - 1)
+                demand.throughSeq = Math.max(demand.throughSeq, state.tail - 1);
+            demand.probe = failed;
+            if (!demand.probe && !demand.hasMore && ack >= demand.throughSeq)
+                this.backgroundPullDemands.delete(ns);
+            else
+                demand.retryAt = failed || ack <= afterSeq || ack <= (this.pendingPullNoProgressAcks?.get(ns) ?? -1)
+                    ? Date.now() + P2P_GAP_FILL_RETRY_BASE_MS
+                    : 0;
+        }
+        this.requestBackgroundPullRecovery();
+    }
+    requestBackgroundPullRecovery() {
+        if (this.backgroundPullRecoveryQueued)
+            return;
+        const generation = this.captureInlineGeneration();
+        this.backgroundPullRecoveryQueued = true;
+        void Promise.resolve().then(() => {
+            if (!this.isInlineGenerationCurrent(generation))
+                return;
+            this.backgroundPullRecoveryQueued = false;
+            const client = this.runtime.client;
+            if (!client._aid || client._sessionOptions?.background_sync === false
+                || client.state !== ConnectionState.READY || client._closing)
+                return;
+            if (this.backgroundPullTimer !== null)
+                clearTimeout(this.backgroundPullTimer);
+            this.backgroundPullTimer = null;
+            let retryAt = 0;
+            for (const [ns, demand] of this.backgroundPullDemands) {
+                if (ns.startsWith('p2p:') && ns !== `p2p:${client._aid}`)
+                    continue;
+                const dedupKey = ns.startsWith('p2p:') ? `p2p_pull:${ns}`
+                    : ns.startsWith('group_event:') ? `group_event_pull:${ns}` : `group_pull:${ns}`;
+                if (client._gapFillDone.has(dedupKey) || this.onlineUnreadHintOwners?.has(ns)
+                    || this.realtimeSyncing?.has(ns) || client._rpcPipeline?.hasPullActivity?.(ns, false))
+                    continue;
+                const ack = this.syncState(ns).ack;
+                if (!demand.probe && !demand.hasMore && ack >= demand.throughSeq) {
+                    this.backgroundPullDemands.delete(ns);
+                    continue;
+                }
+                if (demand.retryAt > Date.now()) {
+                    retryAt = retryAt === 0 ? demand.retryAt : Math.min(retryAt, demand.retryAt);
+                    continue;
+                }
+                if (ns.startsWith('p2p:'))
+                    client._safeAsync(this.fillP2pGap());
+                else if (ns.startsWith('group_event:'))
+                    client._safeAsync(this.fillGroupEventGap(ns.slice('group_event:'.length)));
+                else if (ns.startsWith('group:'))
+                    client._safeAsync(this.fillGroupGap(ns.slice('group:'.length)));
+            }
+            if (retryAt > 0) {
+                this.backgroundPullTimer = globalThis.setTimeout(() => {
+                    this.backgroundPullTimer = null;
+                    if (this.isInlineGenerationCurrent(generation))
+                        this.requestBackgroundPullRecovery();
+                }, Math.max(0, retryAt - Date.now()));
+            }
+        });
     }
     onForegroundPullsDrained() {
+        this.requestBackgroundPullRecovery();
         const client = this.runtime.client;
         if (!client._aid || client._sessionOptions?.background_sync === false
             || client.state !== ConnectionState.READY || client._closing)
@@ -340,6 +447,7 @@ export class MessageDeliveryEngine {
         client._safeAsync(this.fillP2pGap());
     }
     onPullWorkSettled() {
+        this.requestBackgroundPullRecovery();
         const pipeline = this.runtime.client._rpcPipeline;
         if (pipeline?.hasAnyPullActivity?.() === true)
             return;
@@ -2228,7 +2336,14 @@ export class MessageDeliveryEngine {
                 return;
             }
         }
+        const generation = this.captureInlineGeneration();
+        const dedupKey = `group_pull:${ns}`;
+        this.recordBackgroundPullDemand(ns, positiveSafeSequenceHint(notification.seq), true);
+        if (client._gapFillDone.has(dedupKey))
+            return;
+        client._gapFillDone.add(dedupKey);
         let rawCompleted = false;
+        let failed = false;
         try {
             const key = client._rpcPipeline.pullGateKeyForCall('group.pull', {
                 group_id: groupId,
@@ -2244,12 +2359,17 @@ export class MessageDeliveryEngine {
                     limit: 50,
                     _rpc_background: true,
                 }, { background: true });
+                if (!this.isInlineGenerationCurrent(generation))
+                    throw new Error('pull invalidated');
                 rawCompleted = true;
+                if (isJsonObject(result))
+                    this.observeBackgroundPullResponse(ns, afterSeq, result, 50);
                 await this.commitPlainForwardPage(ns, afterSeq, 'group.pull', result, groupId);
                 this.prunePushedSeqs(ns);
             }, true);
         }
         catch (exc) {
+            failed = true;
             // 页发布或本地提交失败不能 ACK；提交后 ACK 失败则保留 pending。
             // 两种情况都不能再把原始通知当作第二条业务消息发布。
             client._clientLog.warn(`auto pull group message commit/ack failed:${String(exc)}`);
@@ -2257,6 +2377,12 @@ export class MessageDeliveryEngine {
                 await client._publishAppEvent('group.message_created', notification, 'push');
             }
         }
+        finally {
+            if (this.isInlineGenerationCurrent(generation)) {
+                client._gapFillDone.delete(dedupKey);
+                this.finishBackgroundPull(ns, afterSeq, failed);
+            }
+        }
     }
     scheduleP2pGapRetry(ns, retryAttempt) {
         const client = this.runtime.client;
@@ -2280,6 +2406,7 @@ export class MessageDeliveryEngine {
     }
     async fillP2pGap(retryAttempt = 0) {
         const client = this.runtime.client;
+        const generation = this.captureInlineGeneration();
         if (client._sessionOptions?.background_sync === false)
             return;
         if (client.state !== ConnectionState.READY || client._closing)
@@ -2291,9 +2418,11 @@ export class MessageDeliveryEngine {
         const dedupKey = `p2p_pull:${ns}`;
         if (client._gapFillDone.has(dedupKey))
             return;
+        this.recordBackgroundPullDemand(ns, 0, true);
         client._gapFillDone.add(dedupKey);
         this.runtime.delivery.setGapFillActive(true);
         let filled = 0;
+        let failed = false;
         try {
             const key = client._rpcPipeline.pullGateKeyForCall('message.pull', { after_seq: afterSeq, limit: 50 });
             const messages = await client._rpcPipeline.runPullSerialized(key, () => client._pullV2(afterSeq, 50, { gateLocked: true }), true);
@@ -2309,22 +2438,27 @@ export class MessageDeliveryEngine {
                     client._clientLog.warn(`P2P message gap-fill V2 unavailable, used plain pull fallback:${String(formatDeliveryError(exc))}`);
                 }
                 catch (fallbackExc) {
+                    failed = true;
                     client._clientLog.warn(`P2P message gap-fill plain fallback failed:${String(formatDeliveryError(fallbackExc))}`);
-                    this.scheduleP2pGapRetry(ns, retryAttempt + 1);
                 }
             }
             else {
+                failed = true;
                 client._clientLog.warn(`P2P message gap-fill failed:${String(formatDeliveryError(exc))}`);
             }
         }
         finally {
-            client._gapFillDone.delete(dedupKey);
-            this.runtime.delivery.setGapFillActive(false);
-            this.schedulePendingPullIfNeeded(ns, 'gap-fill-complete');
+            if (this.isInlineGenerationCurrent(generation)) {
+                client._gapFillDone.delete(dedupKey);
+                this.runtime.delivery.setGapFillActive(false);
+                this.schedulePendingPullIfNeeded(ns, 'gap-fill-complete');
+                this.finishBackgroundPull(ns, afterSeq, failed);
+            }
         }
     }
     async fillP2pGapWithPlainPull(ns, afterSeq) {
         const client = this.runtime.client;
+        const generation = this.captureInlineGeneration();
         const params = {
             after_seq: afterSeq,
             limit: 50,
@@ -2333,11 +2467,16 @@ export class MessageDeliveryEngine {
             _rpc_background: true,
         };
         const raw = await client._rpcPipeline.rawCall('message.pull', params, { background: true });
+        if (!this.isInlineGenerationCurrent(generation))
+            throw new Error('pull invalidated');
+        if (isJsonObject(raw))
+            this.observeBackgroundPullResponse(ns, afterSeq, raw, 50);
         const page = await this.commitPlainForwardPage(ns, afterSeq, 'message.pull', raw);
         return page.publishedCount;
     }
     async fillGroupGap(groupId) {
         const client = this.runtime.client;
+        const generation = this.captureInlineGeneration();
         if (client._sessionOptions?.background_sync === false)
             return;
         if (client.state !== ConnectionState.READY || client._closing)
@@ -2350,25 +2489,48 @@ export class MessageDeliveryEngine {
         const dedupKey = `group_pull:${ns}`;
         if (client._gapFillDone.has(dedupKey))
             return;
+        this.recordBackgroundPullDemand(ns, 0, true);
         client._gapFillDone.add(dedupKey);
         this.runtime.delivery.setGapFillActive(true);
         let filled = 0;
+        let failed = false;
         try {
             const key = client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, after_seq: afterSeq, limit: 50 });
-            const messages = await client._rpcPipeline.runPullSerialized(key, () => client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true }), true);
+            const messages = await client._rpcPipeline.runPullSerialized(key, async () => {
+                if (client._v2Session)
+                    return await client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true });
+                const result = await client._rpcPipeline.rawCall('group.pull', {
+                    group_id: groupId,
+                    after_message_seq: afterSeq,
+                    device_id: client._deviceId,
+                    slot_id: client._slotId,
+                    limit: 50,
+                    _rpc_background: true,
+                }, { background: true });
+                if (!this.isInlineGenerationCurrent(generation))
+                    throw new Error('pull invalidated');
+                if (isJsonObject(result))
+                    this.observeBackgroundPullResponse(ns, afterSeq, result, 50);
+                await this.commitPlainForwardPage(ns, afterSeq, 'group.pull', result, groupId);
+                return isJsonObject(result) && Array.isArray(result.messages) ? result.messages : [];
+            }, true);
             filled = messages.length;
             this.prunePushedSeqs(ns);
         }
         catch (exc) {
+            failed = true;
             client._clientLog.warn(`group message gap-fill failed:${String(exc)}`);
         }
         finally {
-            client._gapFillDone.delete(dedupKey);
-            this.runtime.delivery.setGapFillActive(false);
-            if (filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
-                client._safeAsync(this.fillGroupGap(groupId));
+            if (this.isInlineGenerationCurrent(generation)) {
+                client._gapFillDone.delete(dedupKey);
+                this.runtime.delivery.setGapFillActive(false);
+                if (filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
+                    this.recordBackgroundPullDemand(ns, 0, true);
+                }
+                this.schedulePendingPullIfNeeded(ns, 'gap-fill-complete');
+                this.finishBackgroundPull(ns, afterSeq, failed);
             }
-            this.schedulePendingPullIfNeeded(ns, 'gap-fill-complete');
         }
     }
     async fillGroupEventGap(groupId, options) {
@@ -2390,6 +2552,7 @@ export class MessageDeliveryEngine {
         const dedupKey = `group_event_pull:${ns}`;
         if (client._gapFillDone.has(dedupKey))
             return;
+        this.recordBackgroundPullDemand(ns, 0, true);
         client._gapFillDone.add(dedupKey);
         this.runtime.delivery.setGapFillActive(true);
         let continuationAfterSeq = 0;
@@ -2409,6 +2572,10 @@ export class MessageDeliveryEngine {
                     _rpc_background: true,
                 };
                 const result = await client.call('group.pull_events', request);
+                if (!this.isInlineGenerationCurrent(generation))
+                    throw new Error('pull invalidated');
+                if (isJsonObject(result))
+                    this.observeBackgroundPullResponse(ns, nextAfterSeq, result, 50);
                 if (!isJsonObject(result))
                     return;
                 const events = result.events;
@@ -2455,8 +2622,10 @@ export class MessageDeliveryEngine {
                 await this.drainOrderedMessages(ns, undefined, false, false, undefined, 'pull', deliveryThrough);
                 if (!this.isInlineGenerationCurrent(generation))
                     throw new Error('pull invalidated');
-                if (hasDissolvedEvent)
+                if (hasDissolvedEvent) {
+                    this.backgroundPullDemands.delete(ns);
                     break;
+                }
                 if (contiguousSeq === undefined)
                     client._seqTracker.onPullResult(ns, eventObjects, nextAfterSeq);
                 else
@@ -2504,15 +2673,12 @@ export class MessageDeliveryEngine {
             client._clientLog.warn(`group event gap-fill failed:${String(exc)}`);
         }
         finally {
-            client._gapFillDone.delete(dedupKey);
-            this.runtime.delivery.setGapFillActive(false);
-            if (!client._rpcPipeline)
-                this.syncStopped(failed ? 'aborted' : 'pull_drained');
-            if (singlePage && continuationAfterSeq > afterSeq) {
-                this.enqueueOnlineUnreadEventHint({
-                    group_id: groupId,
-                    _online_hint_after_event_seq: continuationAfterSeq,
-                });
+            if (this.isInlineGenerationCurrent(generation)) {
+                client._gapFillDone.delete(dedupKey);
+                this.runtime.delivery.setGapFillActive(false);
+                if (!client._rpcPipeline)
+                    this.syncStopped(failed ? 'aborted' : 'pull_drained');
+                this.finishBackgroundPull(ns, afterSeq, failed);
             }
         }
     }
@@ -2568,6 +2734,9 @@ export class MessageDeliveryEngine {
         if (!groupId)
             return;
         const ns = `group:${groupId}`;
+        const generation = this.captureInlineGeneration();
+        const afterSeq = this.syncState(ns).ack;
+        this.recordBackgroundPullDemand(ns, positiveSafeSequenceHint(data.seq), true);
         const targets = this.onlineUnreadHintTargets ?? new Map();
         const owners = this.onlineUnreadHintOwners ?? new Set();
         this.onlineUnreadHintTargets = targets;
@@ -2577,11 +2746,16 @@ export class MessageDeliveryEngine {
             return;
         owners.add(ns);
         client._safeAsync((async () => {
+            let failed = false;
+            let attemptAfterSeq = afterSeq;
             try {
                 while (true) {
                     const throughSeq = targets.get(ns) ?? 0;
                     const ackBefore = this.syncState(ns).ack;
+                    attemptAfterSeq = ackBefore;
                     await this.runGroupForwardRecovery(groupId, ns, 50, true, throughSeq);
+                    if (!this.isInlineGenerationCurrent(generation))
+                        return;
                     const ackAfter = this.syncState(ns).ack;
                     const target = targets.get(ns) ?? 0;
                     if (ackAfter >= target || ackAfter <= ackBefore)
@@ -2589,6 +2763,7 @@ export class MessageDeliveryEngine {
                 }
             }
             catch (exc) {
+                failed = true;
                 client._clientLog?.debug(`online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
             }
             finally {
@@ -2596,6 +2771,8 @@ export class MessageDeliveryEngine {
                     targets.delete(ns);
                 if (this.onlineUnreadHintOwners === owners)
                     owners.delete(ns);
+                if (this.isInlineGenerationCurrent(generation))
+                    this.finishBackgroundPull(ns, attemptAfterSeq, failed);
             }
         })());
     }
@@ -2604,6 +2781,7 @@ export class MessageDeliveryEngine {
         const groupId = String(data.group_id ?? '').trim();
         if (!groupId || client._sessionOptions?.background_sync === false)
             return;
+        this.recordBackgroundPullDemand(`group_event:${groupId}`, positiveSafeSequenceHint(data.event_seq), true);
         const rawAfter = Number(data._online_hint_after_event_seq ?? 0);
         const afterSeq = Number.isSafeInteger(rawAfter) && rawAfter > 0 ? rawAfter : 0;
         client._safeAsync(this.fillGroupEventGap(groupId, {
@@ -3378,22 +3556,30 @@ export class MessageDeliveryEngine {
             }
             return;
         }
+        if (client._sessionOptions?.background_sync !== false)
+            this.recordBackgroundPullDemand(ns, seq);
         const pullActive = client._rpcPipeline?.hasPullActivity?.(ns) === true;
         if (pullActive || !this.beginRealtimeSync(ns)) {
             this.recordPendingPull(ns, seq);
             client._clientLog?.debug(`V2 group push queued behind in-flight realtime sync: ns=${ns} seq=${seq}`);
             return;
         }
+        const generation = this.captureInlineGeneration();
+        let failed = false;
         try {
             // namespace 串行区必须覆盖 Tail 与其后至多一次 Forward 的完整周期。
             await this.runGroupRealtimeSync(groupId, ns, seq, 50, false);
         }
         catch (exc) {
+            failed = true;
             client._clientLog.warn(`V2 group push auto-sync failed: group=${groupId} err=${formatDeliveryError(exc)}`);
         }
         finally {
-            this.endRealtimeSync(ns);
-            this.schedulePendingPullIfNeeded(ns, 'push-auto-pull-complete');
+            if (this.isInlineGenerationCurrent(generation)) {
+                this.endRealtimeSync(ns);
+                this.schedulePendingPullIfNeeded(ns, 'push-auto-pull-complete');
+                this.finishBackgroundPull(ns, before.ack, failed);
+            }
         }
     }
     async onV2PushNotification(data) {
@@ -3466,31 +3652,60 @@ export class MessageDeliveryEngine {
             }
             return;
         }
+        if (client._sessionOptions?.background_sync !== false)
+            this.recordBackgroundPullDemand(ns, pushSeq);
         const pullActive = client._rpcPipeline?.hasPullActivity?.(ns) === true;
         if (pullActive || !this.beginRealtimeSync(ns)) {
             this.recordPendingPull(ns, pushSeq);
             client._clientLog?.debug(`V2 P2P push queued behind in-flight realtime sync: ns=${ns} seq=${pushSeq}`);
             return;
         }
+        const generation = this.captureInlineGeneration();
+        let failed = false;
         try {
             await this.runP2PRealtimeSync(ns, pushSeq, 50, false);
         }
         catch (exc) {
+            failed = true;
             client._clientLog.warn(`V2 P2P push auto-sync failed: ${formatDeliveryError(exc)}`);
         }
         finally {
-            this.endRealtimeSync(ns);
-            this.schedulePendingPullIfNeeded(ns, 'push-auto-pull-complete');
+            if (this.isInlineGenerationCurrent(generation)) {
+                this.endRealtimeSync(ns);
+                this.schedulePendingPullIfNeeded(ns, 'push-auto-pull-complete');
+                this.finishBackgroundPull(ns, before.ack, failed);
+            }
         }
     }
     enqueueOnlineUnreadP2pHint(data) {
         const client = this.runtime.client;
-        if (!client._aid || !client._v2Session)
+        if (!client._aid || !client._v2Session || client._sessionOptions?.background_sync === false)
             return;
         const ns = `p2p:${client._aid}`;
-        client._safeAsync(this.runP2PForwardRecovery(ns, 50, true).catch((exc) => {
-            client._clientLog?.debug(`P2P online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
-        }));
+        const generation = this.captureInlineGeneration();
+        const afterSeq = this.syncState(ns).ack;
+        this.recordBackgroundPullDemand(ns, positiveSafeSequenceHint(data.seq), true);
+        const owners = this.onlineUnreadHintOwners ?? new Set();
+        this.onlineUnreadHintOwners = owners;
+        if (owners.has(ns))
+            return;
+        owners.add(ns);
+        client._safeAsync((async () => {
+            let failed = false;
+            try {
+                await this.runP2PForwardRecovery(ns, 50, true);
+            }
+            catch (exc) {
+                failed = true;
+                client._clientLog?.debug(`P2P online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
+            }
+            finally {
+                if (this.onlineUnreadHintOwners === owners)
+                    owners.delete(ns);
+                if (this.isInlineGenerationCurrent(generation))
+                    this.finishBackgroundPull(ns, afterSeq, failed);
+            }
+        })());
     }
     async restoreSeqTrackerState() {
         const client = this.runtime.client;