@agentunion/fastaun 0.5.35 → 0.5.36

package/dist/client/delivery.js

@@ -180,6 +180,7 @@ export class MessageDeliveryEngine {
     backgroundPullTimerAt = 0;
     pendingP2PInlineAcks = null;
     pendingGroupInlineAcks = null;
+    pendingGroupInlineAckCount = 0;
     pendingGroupInlineAckNamespaces = null;
     inlineAckGeneration = 0;
     pendingDeliveryChanges = null;
@@ -638,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();
@@ -999,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())
@@ -1060,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
@@ -1522,6 +1528,7 @@ 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;
@@ -1783,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();
@@ -3694,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() : '';
@@ -3704,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,
@@ -3713,6 +3722,7 @@ export class MessageDeliveryEngine {
             committed: false,
             observedAckSeq: 0,
         });
+        this.pendingGroupInlineAckCount++;
         for (const namespace of namespaces) {
             let candidates = namespaceMap.get(namespace);
             if (!candidates) {
@@ -3725,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;
@@ -3739,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) {
@@ -3761,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)
@@ -3783,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;
@@ -3803,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;
             });
@@ -3831,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) {
@@ -4797,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;
@@ -4817,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 } } : {}) }));
         }
     }
@@ -4935,7 +4968,7 @@ export class MessageDeliveryEngine {
             }
             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);
             }
@@ -5023,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))
@@ -5046,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;
@@ -5534,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;