@agentunion/fastaun 0.5.36 → 0.5.37

package/dist/client/delivery.d.ts

@@ -16,6 +16,7 @@ export declare class MessageDeliveryEngine {
     private readonly forwardAckJobs;
     private readonly forwardAckTasks;
     scheduleForwardAck(ns: string, seq: number, send: (seq: number) => Promise<void>): void;
+    confirmForwardAck(ns: string, seq: number): void;
     drainForwardAcks(): Promise<void> | undefined;
     private waitForwardAcks;
     private realtimeTailHeads;

package/dist/client/delivery.js

@@ -122,13 +122,39 @@ export class MessageDeliveryEngine {
             }
             return;
         }
-        const job = { seq, scope: current, send };
+        const job = { seq, confirmed: 0, 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 () => {
+            const checkedPulls = new Set();
             let failures = 0;
             while (isCurrent()) {
+                if (job.confirmed >= job.seq)
+                    return;
+                const nextPull = client._rpcPipeline?.queuedForwardPull?.(ns);
+                if (nextPull && !checkedPulls.has(nextPull)) {
+                    checkedPulls.add(nextPull);
+                    try {
+                        const result = await nextPull;
+                        if (!isCurrent())
+                            return;
+                        const response = result;
+                        const peer = ns.startsWith('p2p.peer.v1/');
+                        const bound = !peer || response?.cursor_scope === 'peer'
+                            && typeof response.sender_aid === 'string' && this.peerNamespace(response.sender_aid) === ns;
+                        const actual = !bound ? 0 : ns.startsWith('group:')
+                            ? this.resolveGroupPullAckSeq(result, job.seq) : this.resolveP2PPullAckSeq(result, job.seq);
+                        if (actual > 0) {
+                            client._v2E2EE?.clearForwardAck?.(ns, actual);
+                            job.confirmed = Math.max(job.confirmed, actual);
+                        }
+                    }
+                    catch { }
+                    continue;
+                }
                 const pending = job.seq;
+                if (job.confirmed >= pending)
+                    return;
                 try {
                     await job.send(pending);
                     failures = 0;
@@ -152,6 +178,11 @@ export class MessageDeliveryEngine {
         });
         this.forwardAckTasks.add(task);
     }
+    confirmForwardAck(ns, seq) {
+        const job = this.forwardAckJobs.get(ns);
+        if (job)
+            job.confirmed = Math.max(job.confirmed, seq);
+    }
     drainForwardAcks() {
         if (!this.forwardAckTasks.size)
             return;
@@ -639,6 +670,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.confirmForwardAck(namespace, sequence);
         this.runtime.client._rpcPipeline?.confirmBackgroundAck?.(namespace, sequence);
     }
     rememberCommittedSeqState(namespace) {
@@ -829,7 +861,7 @@ export class MessageDeliveryEngine {
                         return tail;
                     }
                     if (!budget.remaining) {
-                        this.schedulePeerRecovery(peer, Number(tail.head_seq ?? 0), true);
+                        this.schedulePeerRecovery(peer, Number(tail.head_seq ?? 0), tail.volatile_has_more === true);
                         return { ...tail, complete: false };
                     }
                     forwardNeed = this.peerForwardNeeds.get(ns);
@@ -855,7 +887,7 @@ export class MessageDeliveryEngine {
                     const complete = this.canClosePeerTail(ns, result, pushVersion, catalogVersion);
                     if (!complete) {
                         this.peerForwardNeeds.set(ns, {});
-                        this.schedulePeerRecovery(peer, Number(result.head_seq ?? 0), true);
+                        this.schedulePeerRecovery(peer, Number(result.head_seq ?? 0), result.volatile_has_more === true);
                     }
                     else if (this.peerForwardNeeds.get(ns) === forwardNeed)
                         this.peerForwardNeeds.delete(ns);
@@ -987,9 +1019,16 @@ export class MessageDeliveryEngine {
             this.peerForwardNeeds.set(namespace, {});
             return;
         }
-        if (volatile && client._syncChannelCoordinator?.needsSplit?.()
-            && (this.peerRecoveryTasks.has(sender) || this.oversizedPulls.has(namespace)))
+        if (volatile && client._syncChannelCoordinator?.needsSplit?.()) {
             this.schedulePeerVolatileRecovery(sender);
+            const ack = this.peerCommittedAck(namespace);
+            const state = this.syncState(namespace);
+            if (this.initializedPeers.has(namespace) && Number.isSafeInteger(head) && head > 0 && head <= ack
+                && state.head <= ack && client._seqTracker.getMaxSeenSeq(namespace) <= ack
+                && (this.peerServerConfirmedAcks.get(namespace) ?? 0) >= ack
+                && !this.peerForwardNeeds.has(namespace) && !this.peerRecoveryNeeds.has(sender))
+                return;
+        }
         if (this.oversizedPulls.has(namespace))
             return;
         const need = this.peerRecoveryNeeds.get(sender) ?? { head: 0, volatile: false, pending: false };
@@ -1842,7 +1881,7 @@ export class MessageDeliveryEngine {
         return [...namespaces];
     }
     hasAnyPendingPull() {
-        return this.peerCatalogDirty || [...this.peerRecoveryNeeds.values()].some((need) => !need.paused) || this.peerRecoveryTasks.size > 0 || Boolean(this.peerCatalogTask)
+        return this.forwardAckTasks.size > 0 || this.peerCatalogDirty || [...this.peerRecoveryNeeds.values()].some((need) => !need.paused) || this.peerRecoveryTasks.size > 0 || Boolean(this.peerCatalogTask)
             || Boolean(this.peerVolatileTask) || this.peerVolatileNeeds.size > 0
             || [...(this.pendingGroupPullUpper?.values() ?? [])].some((seq) => seq > 0)
             || [...this.backgroundPullNeeds.values()].some((need) => need.retryAt !== Infinity)