@agentunion/fastaun 0.5.18 → 0.5.19

package/dist/client/delivery.js

@@ -175,9 +175,8 @@ export class MessageDeliveryEngine {
         const pageInlineGeneration = this.captureInlineAckGeneration();
         const deferredServerCursor = Number(coordinator.pendingForwardCursor(ns, pageContigBefore) ?? 0);
         const deferredForwardAck = Number(coordinator.pendingForwardAck(ns, pageContigBefore) ?? 0);
-        const pageTrackerSnapshot = typeof client._seqTracker.snapshotNamespace === 'function'
-            ? client._seqTracker.snapshotNamespace(ns)
-            : null;
+        let pageTrackerSnapshot = null;
+        let trackerMutated = false;
         response._contig_before = pageContigBefore;
         const cursor = isJsonObject(response.cursor)
             ? response.cursor
@@ -225,6 +224,18 @@ export class MessageDeliveryEngine {
                 }
             }
             this.ensurePullOperationCurrent(ns);
+            if (pageInlineGeneration !== this.captureInlineAckGeneration())
+                throw new Error('pull invalidated');
+            const previousWindow = client._seqTracker.getSyncState(ns);
+            const scanTarget = Math.max(pageContigBefore, ...messages.map((message) => positiveSafeSequenceHint(message.seq)), positiveSafeSequenceHint(response.contiguous_seq), retentionFloor, visibilityFloor, deferredServerCursor);
+            const deliveryTarget = scanTarget >= previousWindow.tail - 1
+                ? Math.max(scanTarget, previousWindow.head) : scanTarget;
+            await this.drainOrderedMessages(ns, undefined, false, false, 'pull', undefined, deliveryTarget);
+            this.ensurePullOperationCurrent(ns);
+            if (pageInlineGeneration !== this.captureInlineAckGeneration())
+                throw new Error('pull invalidated');
+            pageTrackerSnapshot = client._seqTracker.snapshotNamespace?.(ns) ?? null;
+            trackerMutated = true;
             client._seqTracker.onPullResult(ns, messages, afterSeq, Number.isSafeInteger(result.contiguous_seq)
                 ? result.contiguous_seq
                 : undefined);
@@ -233,16 +244,19 @@ export class MessageDeliveryEngine {
                 client._seqTracker.forceContiguousSeq(ns, commitTarget);
             }
             if (client._seqTracker.getContiguousSeq(ns) !== pageContigBefore) {
-                this.ensurePullOperationCurrent(ns);
-                await this.drainOrderedMessages(ns, undefined, false, false, 'pull');
                 this.ensurePullOperationCurrent(ns);
                 await client._commitSeqTrackerState(ns);
+                this.ensurePullOperationCurrent(ns);
+                if (pageInlineGeneration !== this.captureInlineAckGeneration())
+                    throw new Error('pull invalidated');
             }
             committed = true;
         }
         catch (exc) {
-            if (this.isPullOperationCurrent(ns) && !committed && typeof client._seqTracker.restoreNamespaceSnapshot === 'function') {
-                client._seqTracker.restoreNamespaceSnapshot(ns, pageTrackerSnapshot);
+            if (trackerMutated && pageInlineGeneration === this.captureInlineAckGeneration() && this.isPullOperationCurrent(ns)
+                && !committed && typeof client._seqTracker.restoreNamespaceSnapshot === 'function') {
+                (client._seqTracker._restoreNamespaceSnapshotPreservingPush ?? client._seqTracker.restoreNamespaceSnapshot)
+                    .call(client._seqTracker, ns, pageTrackerSnapshot);
                 this.dropSeqTrackerPending(ns);
             }
             throw exc;
@@ -702,6 +716,18 @@ export class MessageDeliveryEngine {
         }
         this.schedulePendingGroupPullIfNeeded(ns, 'pull-gate-idle');
     }
+    onForegroundPullsDrained() {
+        const client = this.runtime.client;
+        if (!client._aid || client._sessionOptions?.background_sync === false
+            || client.state !== ConnectionState.READY || client._closing)
+            return;
+        const ns = `p2p:${client._aid}`;
+        const state = this.syncState(ns);
+        const maxSeen = client._seqTracker.getMaxSeenSeq(ns);
+        if (maxSeen <= state.ack && state.ack >= state.tail - 1)
+            return;
+        client._safeAsync(this.fillP2pGap());
+    }
     recordPendingGroupPull(ns, seq) {
         if (!ns || !Number.isSafeInteger(seq) || seq <= 0)
             return;
@@ -792,12 +818,12 @@ export class MessageDeliveryEngine {
             return;
         }
         if (pullResponse) {
-            const published = client._withPullResponseProcessing(ns, () => this.publishAppEvent(event, payload, source, deliveryContext));
+            const published = client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, deliveryContext));
             if (isPromiseLike(published))
                 await published;
         }
         else {
-            const published = this.publishAppEvent(event, payload, source, deliveryContext);
+            const published = client._publishAppEvent(event, payload, source, deliveryContext);
             if (isPromiseLike(published))
                 await published;
         }
@@ -806,6 +832,12 @@ export class MessageDeliveryEngine {
     }
     async publishOrderedGroupChanged(payload, source = 'ordered') {
         const client = this.runtime.client;
+        const generation = this.captureInlineAckGeneration();
+        const published = client._publishAppEvent('group.changed', payload, source);
+        if (isPromiseLike(published))
+            await published;
+        if (generation !== this.captureInlineAckGeneration())
+            throw new Error('pull invalidated');
         if (isJsonObject(payload)) {
             const eventPayload = payload;
             client._groupState?.handleGroupChangedV2Membership?.(eventPayload);
@@ -816,9 +848,6 @@ export class MessageDeliveryEngine {
                     client._cleanupDissolvedGroup?.(groupId);
             }
         }
-        const published = client._publishAppEvent('group.changed', payload, source);
-        if (isPromiseLike(published))
-            await published;
     }
     isInstanceScopedMessageEvent(event) {
         return event === 'message.received'
@@ -1131,6 +1160,7 @@ export class MessageDeliveryEngine {
     }
     async publishMessageRecallTombstone(seq, message, source = 'push') {
         const client = this.runtime.client;
+        const generation = this.captureInlineAckGeneration();
         const eventPayload = this.recallEventFromMessage(message);
         if (!eventPayload)
             return false;
@@ -1144,13 +1174,17 @@ export class MessageDeliveryEngine {
             client._clientLog.debug(`message.recalled dedup suppressed: seq=${String(seq)} key=${dedupKey}`);
             return false;
         }
+        await client._publishAppEvent('message.recalled', eventPayload, source);
+        if (generation !== this.captureInlineAckGeneration())
+            throw new Error('pull invalidated');
+        if (this.isPullScopedSource(source))
+            this.ensurePullOperationCurrent(`p2p:${client._aid ?? ''}`);
         seen.set(dedupKey, Date.now());
         if (seen.size > MESSAGE_RECALL_SEEN_LIMIT) {
             const drop = [...seen.entries()].sort((a, b) => a[1] - b[1]).slice(0, seen.size - MESSAGE_RECALL_SEEN_LIMIT);
             for (const [oldKey] of drop)
                 seen.delete(oldKey);
         }
-        await client._publishAppEvent('message.recalled', eventPayload, source);
         client._clientLog.debug(`message.recalled published: seq=${String(seq)} ids=${JSON.stringify(eventPayload.message_ids)}`);
         return true;
     }
@@ -1235,6 +1269,7 @@ export class MessageDeliveryEngine {
     }
     async publishGroupRecallTombstone(groupId, seq, message, source = 'push') {
         const client = this.runtime.client;
+        const generation = this.captureInlineAckGeneration();
         const eventPayload = this.recallEventFromGroupMessage(message);
         if (!eventPayload)
             return false;
@@ -1250,13 +1285,17 @@ export class MessageDeliveryEngine {
             client._clientLog.debug(`group.message_recalled dedup suppressed: group=${groupId} seq=${String(seq)} key=${dedupKey}`);
             return false;
         }
+        await client._publishAppEvent('group.message_recalled', eventPayload, source);
+        if (generation !== this.captureInlineAckGeneration())
+            throw new Error('pull invalidated');
+        if (this.isPullScopedSource(source))
+            this.ensurePullOperationCurrent(`group:${groupId}`);
         seen.set(dedupKey, Date.now());
         if (seen.size > GROUP_RECALL_SEEN_LIMIT) {
             const drop = [...seen.entries()].sort((a, b) => a[1] - b[1]).slice(0, seen.size - GROUP_RECALL_SEEN_LIMIT);
             for (const [oldKey] of drop)
                 seen.delete(oldKey);
         }
-        await client._publishAppEvent('group.message_recalled', eventPayload, source);
         client._clientLog.debug(`group.message_recalled published: group=${groupId} seq=${String(seq)} ids=${JSON.stringify(eventPayload.message_ids)}`);
         return true;
     }
@@ -1325,11 +1364,14 @@ export class MessageDeliveryEngine {
         const generation = this.deliveryChangedGeneration;
         const normalized = this.normalizePublishedMessagePayload(event, payload, source);
         const dispatcher = client._dispatcher;
-        const result = typeof dispatcher.enqueue === 'function'
-            ? (dispatcher.enqueue(event, normalized), undefined)
-            : typeof dispatcher.publishSyncAware === 'function'
-                ? dispatcher.publishSyncAware(event, normalized)
-                : dispatcher.publish?.(event, normalized);
+        const result = ['message.received', 'group.message_created', 'message.recalled', 'group.message_recalled', 'group.changed'].includes(event)
+            && typeof dispatcher._publishAndWait === 'function'
+            ? dispatcher._publishAndWait(event, normalized)
+            : typeof dispatcher.enqueue === 'function'
+                ? (dispatcher.enqueue(event, normalized), undefined)
+                : typeof dispatcher.publishSyncAware === 'function'
+                    ? dispatcher.publishSyncAware(event, normalized)
+                    : dispatcher.publish?.(event, normalized);
         const note = () => {
             if (generation === this.deliveryChangedGeneration) {
                 this.noteDeliveryChanged(event, payload, source, deliveryContext);
@@ -1883,6 +1925,7 @@ export class MessageDeliveryEngine {
         if (!groupId)
             return;
         const ns = `group_event:${groupId}`;
+        const generation = this.captureInlineAckGeneration();
         const requestedAfterSeq = Number(options.afterSeq ?? 0);
         const afterSeq = Number.isSafeInteger(requestedAfterSeq) && requestedAfterSeq > 0
             ? requestedAfterSeq
@@ -1905,6 +1948,7 @@ export class MessageDeliveryEngine {
         let filled = 0;
         let continuationAfterSeq = 0;
         let failed = false;
+        let dissolved = false;
         try {
             let nextAfterSeq = afterSeq;
             const maxPages = singlePage ? 1 : 100;
@@ -1934,10 +1978,9 @@ export class MessageDeliveryEngine {
                 if (!Array.isArray(events))
                     return;
                 const pageContigBefore = client._seqTracker.getContiguousSeq(ns);
+                let pageTrackerSnapshot = null;
+                let trackerMutated = false;
                 const eventObjects = events.filter((evt) => isJsonObject(evt));
-                client._seqTracker.onPullResult(ns, eventObjects, nextAfterSeq, Number.isSafeInteger(result.contiguous_seq)
-                    ? result.contiguous_seq
-                    : undefined);
                 const cursor = isJsonObject(result.cursor)
                     ? result.cursor
                     : null;
@@ -1947,13 +1990,6 @@ export class MessageDeliveryEngine {
                 const earliestAvailable = Number(result.earliest_available_event_seq ?? 0);
                 const visibilityFloor = Math.max(0, Number.isFinite(Number(cursor?.join_seq)) ? Number(cursor?.join_seq) : 0, Number.isFinite(earliestAvailable) && earliestAvailable > 0 ? earliestAvailable - 1 : 0);
                 const effectiveFloor = Math.max(retentionFloor, serverAckFloor, visibilityFloor);
-                if (effectiveFloor > 0) {
-                    const contigBeforeFloor = client._seqTracker.getContiguousSeq(ns);
-                    if (contigBeforeFloor < effectiveFloor) {
-                        client._clientLog.info(`group.pull_events floor advance: ns=${ns} contiguous=${contigBeforeFloor} -> effective_floor=${effectiveFloor} retention_floor=${retentionFloor} server_ack=${serverAckFloor} visibility_floor=${visibilityFloor}`);
-                        client._seqTracker.forceContiguousSeq(ns, effectiveFloor);
-                    }
-                }
                 const eventSeqs = [];
                 let hasDissolvedEvent = false;
                 let publishedEventCount = 0;
@@ -1983,11 +2019,40 @@ export class MessageDeliveryEngine {
                     if (et !== 'group.message_created')
                         filled += 1;
                 }
-                const ackContig = client._seqTracker.getContiguousSeq(ns);
-                await this.drainOrderedMessages(ns);
-                if (ackContig !== pageContigBefore && !hasDissolvedEvent) {
-                    this.persistSeq(ns);
+                try {
+                    const scanTarget = Math.max(pageContigBefore, effectiveFloor, positiveSafeSequenceHint(result.contiguous_seq), ...eventSeqs);
+                    await this.drainOrderedMessages(ns, undefined, false, false, 'pull', undefined, scanTarget);
+                    if (generation !== this.captureInlineAckGeneration())
+                        throw new Error('pull invalidated');
+                    this.ensurePullOperationCurrent(ns);
+                    if (hasDissolvedEvent) {
+                        dissolved = true;
+                        break;
+                    }
+                    pageTrackerSnapshot = client._seqTracker.snapshotNamespace?.(ns) ?? null;
+                    trackerMutated = true;
+                    client._seqTracker.onPullResult(ns, eventObjects, nextAfterSeq, Number.isSafeInteger(result.contiguous_seq)
+                        ? result.contiguous_seq : undefined);
+                    if (client._seqTracker.getContiguousSeq(ns) < effectiveFloor) {
+                        client._seqTracker.forceContiguousSeq(ns, effectiveFloor);
+                    }
+                    if (client._seqTracker.getContiguousSeq(ns) !== pageContigBefore && !hasDissolvedEvent) {
+                        await client._commitSeqTrackerState(ns);
+                        this.ensurePullOperationCurrent(ns);
+                        if (generation !== this.captureInlineAckGeneration())
+                            throw new Error('pull invalidated');
+                    }
                 }
+                catch (exc) {
+                    if (trackerMutated && generation === this.captureInlineAckGeneration() && this.isPullOperationCurrent(ns)
+                        && typeof client._seqTracker.restoreNamespaceSnapshot === 'function') {
+                        (client._seqTracker._restoreNamespaceSnapshotPreservingPush ?? client._seqTracker.restoreNamespaceSnapshot)
+                            .call(client._seqTracker, ns, pageTrackerSnapshot);
+                        this.dropSeqTrackerPending(ns);
+                    }
+                    throw exc;
+                }
+                const ackContig = client._seqTracker.getContiguousSeq(ns);
                 if (eventObjects.length > 0 && ackContig > 0 && ackContig !== pageContigBefore) {
                     const ackSeq = this.clampAckSeq('group.ack_events', 'event_seq', ns, ackContig);
                     try {
@@ -2042,13 +2107,13 @@ export class MessageDeliveryEngine {
             if (legacyGateToken !== null && typeof client._releasePullGate === 'function') {
                 client._releasePullGate(ns, legacyGateToken);
             }
-            if (singlePage && continuationAfterSeq > afterSeq) {
+            if (!dissolved && singlePage && continuationAfterSeq > afterSeq) {
                 this.enqueueOnlineUnreadEventHint({
                     group_id: groupId,
                     _online_hint_after_event_seq: continuationAfterSeq,
                 });
             }
-            else if (!singlePage && filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
+            else if (!dissolved && !singlePage && filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
                 void this.fillGroupEventGap(groupId);
             }
             if (!client._rpcPipeline)
@@ -2864,7 +2929,8 @@ export class MessageDeliveryEngine {
             return false;
         const client = this.runtime.client;
         const tracker = client._seqTracker;
-        const snapshot = typeof tracker.snapshotNamespace === 'function' ? tracker.snapshotNamespace(ns) : null;
+        let snapshot = null;
+        let trackerMutated = false;
         let delivered = false;
         try {
             const selfSync = (event === 'message.received' && this.isSelfSentP2PMessage(payload))
@@ -2879,6 +2945,8 @@ export class MessageDeliveryEngine {
             delivered = true;
             if (!this.inlineGenerationIsCurrent(generation))
                 return false;
+            snapshot = typeof tracker.snapshotNamespace === 'function' ? tracker.snapshotNamespace(ns) : null;
+            trackerMutated = true;
             const needsPull = Boolean(tracker.onMessageSeq(ns, seq));
             if (!this.inlineGenerationIsCurrent(generation))
                 return false;
@@ -2901,9 +2969,10 @@ export class MessageDeliveryEngine {
             return true;
         }
         catch (exc) {
-            if (this.inlineGenerationIsCurrent(generation)
-                && typeof tracker.restoreNamespaceSnapshot === 'function')
-                tracker.restoreNamespaceSnapshot(ns, snapshot);
+            if (trackerMutated && this.inlineGenerationIsCurrent(generation)
+                && typeof tracker.restoreNamespaceSnapshot === 'function') {
+                (tracker._restoreNamespaceSnapshotPreservingPush ?? tracker.restoreNamespaceSnapshot).call(tracker, ns, snapshot);
+            }
             if (this.inlineGenerationIsCurrent(generation) && delivered)
                 this.markPublishedSeq(ns, seq);
             client._clientLog.debug(`inline realtime consume rolled back: ns=${ns} seq=${seq} err=${formatDeliveryError(exc)}`);
@@ -2929,11 +2998,13 @@ export class MessageDeliveryEngine {
                 throw new Error('inline realtime terminal cursor did not collapse after consume');
             }
             await client._commitSeqTrackerState(ns);
-            return true;
+            return this.inlineGenerationIsCurrent(generation);
         }
         catch (exc) {
-            if (typeof tracker.restoreNamespaceSnapshot === 'function')
-                tracker.restoreNamespaceSnapshot(ns, snapshot);
+            if (this.inlineGenerationIsCurrent(generation)
+                && typeof tracker.restoreNamespaceSnapshot === 'function') {
+                (tracker._restoreNamespaceSnapshotPreservingPush ?? tracker.restoreNamespaceSnapshot).call(tracker, ns, snapshot);
+            }
             client._clientLog.debug(`inline realtime terminal consume rolled back: ns=${ns} seq=${seq} err=${formatDeliveryError(exc)}`);
             return false;
         }
@@ -3711,8 +3782,9 @@ export class MessageDeliveryEngine {
         }
         return params;
     }
-    async drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true, source = 'push', context) {
+    async drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true, source = 'push', context, throughSeq) {
         const client = this.runtime.client;
+        const generation = this.captureInlineAckGeneration();
         const pullScoped = this.isPullScopedSource(source);
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
@@ -3728,11 +3800,11 @@ export class MessageDeliveryEngine {
                     this.ensurePullOperationCurrent(ns);
                 const contig = client._seqTracker.getContiguousSeq(ns);
                 const ready = [...queue.keys()]
-                    .filter((seq) => seq <= contig && (beforeSeq === undefined || seq < beforeSeq))
+                    .filter((seq) => seq <= Math.max(contig, throughSeq ?? contig) && (beforeSeq === undefined || seq < beforeSeq))
                     .sort((a, b) => a - b);
                 let seq = ready[0];
                 if (seq === undefined) {
-                    const nextSeq = contig + 1;
+                    const nextSeq = Math.max(contig, throughSeq ?? contig) + 1;
                     if (beforeSeq !== undefined && nextSeq >= beforeSeq)
                         break;
                     if (!queue.has(nextSeq))
@@ -3742,10 +3814,10 @@ export class MessageDeliveryEngine {
                 if (seq === undefined)
                     continue;
                 const item = queue.get(seq);
-                queue.delete(seq);
                 if (!item)
                     continue;
                 if (client._pushedSeqs.get(ns)?.has(seq)) {
+                    queue.delete(seq);
                     client._clientLog.debug(`publish ordered drain skipped duplicate: ns=${ns}, seq=${seq}, event=${item.event}`);
                     client._markOrderedSeqDelivered(ns, seq);
                     continue;
@@ -3763,10 +3835,18 @@ export class MessageDeliveryEngine {
                     }
                 }
                 await this.publishOrderedQueueItem(ns, item.event, seq, item.payload, itemSource, pullResponse, itemContext);
+                if (generation !== this.captureInlineAckGeneration())
+                    throw new Error('pull invalidated');
                 if (pullScoped)
                     this.ensurePullOperationCurrent(ns);
+                queue.delete(seq);
+                if (item.event === 'group.changed' && isJsonObject(item.payload)
+                    && item.payload.action === 'dissolved')
+                    break;
                 this.markPublishedSeq(ns, seq);
                 client._markOrderedSeqDelivered(ns, seq);
+                if (throughSeq !== undefined)
+                    throughSeq = Math.max(throughSeq, seq);
                 delivered = true;
                 client._clientLog.debug(`publish ordered drain delivered: ns=${ns}, seq=${seq}, event=${item.event}`);
             }
@@ -3810,6 +3890,7 @@ export class MessageDeliveryEngine {
     }
     async publishOrderedMessageInternal(event, ns, seq, payload, source, context) {
         const client = this.runtime.client;
+        const generation = this.captureInlineAckGeneration();
         const pullScoped = this.isPullScopedSource(source);
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
@@ -3853,12 +3934,14 @@ export class MessageDeliveryEngine {
             return false;
         }
         const queue = client._pendingOrderedMsgs.get(ns);
-        queue?.delete(seqNum);
-        if (queue && queue.size === 0)
-            client._pendingOrderedMsgs.delete(ns);
         await this.publishOrderedQueueItem(ns, event, seqNum, payload, source, false, context);
+        if (generation !== this.captureInlineAckGeneration())
+            throw new Error('pull invalidated');
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
+        queue?.delete(seqNum);
+        if (queue && queue.size === 0)
+            client._pendingOrderedMsgs.delete(ns);
         this.markPublishedSeq(ns, seqNum);
         client._markOrderedSeqDelivered(ns, seqNum);
         client._clientLog.debug(`publish ordered delivered: event=${event}, ns=${ns}, seq=${seqNum}`);
@@ -3872,6 +3955,7 @@ export class MessageDeliveryEngine {
     }
     async publishPulledMessage(event, ns, seq, payload, persist = true, source = 'pull') {
         const client = this.runtime.client;
+        const generation = this.captureInlineAckGeneration();
         const pullScoped = this.isPullScopedSource(source);
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
@@ -3907,13 +3991,15 @@ export class MessageDeliveryEngine {
         await this.drainOrderedMessages(ns, seqNum, true, persist, source);
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
-        queue?.delete(seqNum);
-        if (queue && queue.size === 0)
-            client._pendingOrderedMsgs.delete(ns);
         if (event === 'message.recalled') {
             const recallPublished = await this.publishMessageRecallTombstone(seqNum, payload, source);
+            if (generation !== this.captureInlineAckGeneration())
+                throw new Error('pull invalidated');
             if (pullScoped)
                 this.ensurePullOperationCurrent(ns);
+            queue?.delete(seqNum);
+            if (queue && queue.size === 0)
+                client._pendingOrderedMsgs.delete(ns);
             this.markPublishedSeq(ns, seqNum);
             client._clientLog.debug(`publish pulled delivered: event=${event}, ns=${ns}, seq=${seqNum}`);
             await this.drainOrderedMessages(ns, undefined, true, persist, source);
@@ -3924,8 +4010,13 @@ export class MessageDeliveryEngine {
         const published = client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source));
         if (isPromiseLike(published))
             await published;
+        if (generation !== this.captureInlineAckGeneration())
+            throw new Error('pull invalidated');
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
+        queue?.delete(seqNum);
+        if (queue && queue.size === 0)
+            client._pendingOrderedMsgs.delete(ns);
         this.markPublishedSeq(ns, seqNum);
         client._clientLog.debug(`publish pulled delivered: event=${event}, ns=${ns}, seq=${seqNum}`);
         await this.drainOrderedMessages(ns, undefined, true, persist, source);