@agentunion/fastaun-browser 0.5.9 → 0.5.11

package/dist/client/delivery.js

@@ -1,4 +1,5 @@
 import { slotIsolationKey } from '../config.js';
+import { normalizeGroupAid } from '../group-id.js';
 import { ConnectionState, isJsonObject } from '../types.js';
 import { hasGroupMentionModeField, normalizeGroupMentionMode } from './mention-mode.js';
 const PUSHED_SEQS_LIMIT = 50_000;
@@ -62,6 +63,26 @@ function nonNegativeSafeSequenceHint(value) {
         return null;
     return value;
 }
+function canonicalDeliverySource(source) {
+    switch (String(source ?? '').trim()) {
+        case 'group-push':
+        case 'ordered':
+        case 'legacy':
+            return 'push';
+        case 'tail':
+        case 'pull-drained':
+        case 'pull_drained':
+            return 'pull';
+        case 'inline-push':
+            return 'inline_push';
+        case 'pending-retry':
+            return 'pending_retry';
+        case '':
+            return 'direct';
+        default:
+            return String(source).trim();
+    }
+}
 function deduplicatePlainForwardPageMessages(value, afterSeq) {
     if (!Array.isArray(value))
         return [];
@@ -94,6 +115,11 @@ function p2pAppEventFromPlainPullMessage(message) {
 }
 export class MessageDeliveryEngine {
     runtime;
+    syncRun = 0;
+    syncingNamespaces = new Set();
+    syncSessions = new Map();
+    pendingPullDeliveryChanges = null;
+    deliveryGeneration = 0;
     realtimeTailResults = null;
     realtimeSyncing = null;
     pendingP2pPullUpper = null;
@@ -113,7 +139,10 @@ export class MessageDeliveryEngine {
         this.runtime = runtime;
     }
     resetInlineAckState() {
+        this.syncStopped('aborted');
         this.inlineGeneration += 1;
+        this.deliveryGeneration += 1;
+        this.pendingPullDeliveryChanges = null;
         void this.runtime.client._rpcPipeline?.invalidatePulls?.();
         this.realtimeSyncing = null;
         this.pendingP2pPullUpper = null;
@@ -126,6 +155,8 @@ export class MessageDeliveryEngine {
         this.pendingP2PInlineAcks = null;
         this.pendingGroupInlineAcks = null;
         this.pendingGroupInlineAckNamespaces = null;
+        this.syncingNamespaces.clear();
+        this.syncSessions.clear();
     }
     isInlineGenerationCurrent(generation) {
         return generation === this.inlineGeneration;
@@ -158,6 +189,95 @@ export class MessageDeliveryEngine {
     endRealtimeSync(ns) {
         this.realtimeSyncing?.delete(ns);
     }
+    onPullStarted(ns) {
+        if (!ns || this.syncingNamespaces.has(ns))
+            return;
+        if (this.syncingNamespaces.size === 0) {
+            this.syncRun += 1;
+            this.syncSessions.clear();
+            this.runtime.client._dispatcher?.enqueue?.('sync.started', {
+                run_id: this.syncRun,
+                source: 'pull',
+                syncing: true,
+                namespaces_pending: 1,
+                received_total: 0,
+                namespace: ns,
+                started_at: Date.now(),
+            });
+        }
+        this.syncingNamespaces.add(ns);
+        this.syncSessions.set(ns, { pages: 0, raw: 0, pulled: 0 });
+    }
+    onPullPage(ns, pulledCount, hasMore, maxSeen, remaining, rawCount = pulledCount, currentSeq, targetSeq) {
+        this.onPullStarted(ns);
+        if (!ns)
+            return;
+        const session = this.syncSessions.get(ns) ?? { pages: 0, raw: 0, pulled: 0 };
+        session.pages += 1;
+        session.raw += Math.max(0, rawCount);
+        session.pulled += Math.max(0, pulledCount);
+        this.syncSessions.set(ns, session);
+        const received = session.pulled;
+        const progress = {
+            run_id: this.syncRun,
+            source: 'pull',
+            namespace: ns,
+            page: session.pages,
+            page_raw_count: Math.max(0, rawCount),
+            page_pulled_count: Math.max(0, pulledCount),
+            pulled_count: received,
+            received_total: received,
+            batch_size: Math.max(0, pulledCount),
+            estimated_remaining: hasMore ? undefined : 0,
+            max_seen: maxSeen,
+            has_more: hasMore,
+        };
+        if (typeof currentSeq === 'number' && Number.isSafeInteger(currentSeq) && currentSeq >= 0) {
+            progress.current_seq = currentSeq;
+        }
+        if (typeof targetSeq === 'number' && Number.isSafeInteger(targetSeq) && targetSeq >= 0) {
+            progress.target_seq = targetSeq;
+        }
+        if (typeof remaining === 'number' && Number.isSafeInteger(remaining) && remaining >= 0) {
+            progress.remaining = remaining;
+            progress.estimated_remaining = progress.remaining;
+        }
+        this.runtime.client._dispatcher?.enqueue?.('sync.progress', progress);
+    }
+    onPullAborted() {
+        this.syncStopped('aborted');
+    }
+    syncStopped(reason = 'pull_drained') {
+        if (this.syncingNamespaces.size === 0)
+            return;
+        const sessions = [...this.syncSessions.entries()];
+        const receivedTotal = sessions.reduce((total, [, session]) => total + session.pulled, 0);
+        this.syncingNamespaces.clear();
+        this.syncSessions.clear();
+        const payload = {
+            run_id: this.syncRun,
+            source: 'pull',
+            syncing: false,
+            namespaces_pending: 0,
+            received_total: receivedTotal,
+            reason,
+            stopped_at: Date.now(),
+        };
+        if (sessions.length === 1) {
+            const [namespace, session] = sessions[0];
+            payload.namespace = namespace;
+            payload.pages = session.pages;
+            payload.pulled_count = session.pulled;
+        }
+        else if (sessions.length > 1) {
+            payload.namespaces = sessions.map(([namespace]) => namespace);
+            payload.pages = sessions.reduce((total, [, session]) => total + session.pages, 0);
+            payload.pulled_count = receivedTotal;
+        }
+        this.runtime.client._dispatcher?.enqueue?.('sync.stopped', {
+            ...payload,
+        });
+    }
     hasPendingPull(ns) {
         const pending = ns.startsWith('p2p:') ? this.pendingP2pPullUpper : this.pendingGroupPullUpper;
         return (pending?.get(ns) ?? 0) > 0;
@@ -167,6 +287,93 @@ export class MessageDeliveryEngine {
             return;
         this.schedulePendingPullIfNeeded(ns, 'pull-gate-idle');
     }
+    onPullWorkSettled() {
+        const pipeline = this.runtime.client._rpcPipeline;
+        if (pipeline?.hasAnyPullActivity?.() === true)
+            return;
+        void this.flushPullDeliveryChanges().finally(() => this.syncStopped('pull_drained'));
+    }
+    deliveryChangeNamespace(event, payload, ns = '') {
+        if (event === 'message.received')
+            return 'p2p';
+        if (event !== 'group.message_created')
+            return '';
+        if (!isJsonObject(payload))
+            return '';
+        const aid = String(this.runtime.client._aid ?? '').trim().toLowerCase();
+        const dot = aid.indexOf('.');
+        const localIssuer = dot > 0 ? aid.slice(dot + 1) : '';
+        const fallback = ns.startsWith('group:') ? ns.slice('group:'.length) : '';
+        const groupAid = normalizeGroupAid(payload.group_aid ?? payload.group_id ?? fallback, { localIssuer });
+        return groupAid.includes('.') ? `group:${groupAid}` : '';
+    }
+    isDeliverableMessageBody(event, payload) {
+        if ((event !== 'message.received' && event !== 'group.message_created') || !isJsonObject(payload))
+            return false;
+        const messageId = typeof payload.message_id === 'string' && payload.message_id.trim().length > 0;
+        const seq = typeof payload.seq === 'number' && Number.isSafeInteger(payload.seq) && payload.seq > 0;
+        return messageId || seq;
+    }
+    recordDeliveryChange(changes, event, payload, ns, generation) {
+        if (generation !== this.deliveryGeneration || !this.isDeliverableMessageBody(event, payload))
+            return;
+        const namespace = this.deliveryChangeNamespace(event, payload, ns);
+        if (!namespace)
+            return;
+        changes.set(namespace, (changes.get(namespace) ?? 0) + 1);
+    }
+    deliveryChangesPayload(changes) {
+        return [...changes.entries()]
+            .filter(([, deliveredCount]) => deliveredCount > 0)
+            .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+            .map(([namespace, deliveredCount]) => ({ namespace, delivered_count: deliveredCount }));
+    }
+    createDeliveryChangeBatch(trigger) {
+        return { generation: this.deliveryGeneration, trigger, changes: new Map(), closed: false };
+    }
+    async flushRealtimeDeliveryChanges(batch) {
+        if (batch.closed)
+            return;
+        batch.closed = true;
+        if (batch.generation !== this.deliveryGeneration)
+            return;
+        if (this.deliveryChangesPayload(batch.changes).length === 0)
+            return;
+        const pendingPull = this.pendingPullDeliveryChanges;
+        this.pendingPullDeliveryChanges = null;
+        if (pendingPull) {
+            for (const [namespace, count] of pendingPull) {
+                batch.changes.set(namespace, (batch.changes.get(namespace) ?? 0) + count);
+            }
+        }
+        if (batch.generation !== this.deliveryGeneration)
+            return;
+        const changes = this.deliveryChangesPayload(batch.changes);
+        if (changes.length === 0)
+            return;
+        this.runtime.client._dispatcher.enqueue('delivery.changed', {
+            trigger: batch.trigger,
+            source: batch.trigger,
+            changes,
+        });
+    }
+    async flushPullDeliveryChanges() {
+        const generation = this.deliveryGeneration;
+        const pending = this.pendingPullDeliveryChanges;
+        if (!pending || pending.size === 0 || generation !== this.deliveryGeneration)
+            return;
+        this.pendingPullDeliveryChanges = null;
+        if (generation !== this.deliveryGeneration)
+            return;
+        const changes = this.deliveryChangesPayload(pending);
+        if (changes.length === 0)
+            return;
+        this.runtime.client._dispatcher.enqueue('delivery.changed', {
+            trigger: 'pull_drained',
+            source: 'pull',
+            changes,
+        });
+    }
     recordPendingPull(ns, seq) {
         if (!ns || !Number.isSafeInteger(seq) || seq <= 0)
             return;
@@ -768,7 +975,7 @@ export class MessageDeliveryEngine {
                 }
                 const message = normalizeGroupMentionMode(rawMessage);
                 if (this.recallEventFromGroupMessage(message)) {
-                    if (await this.publishGroupRecallTombstone(groupId, seq, message)) {
+                    if (await this.publishGroupRecallTombstone(groupId, seq, message, 'pull')) {
                         this.ensurePullOperationCurrent();
                         this.markPublishedSeq(ns, seq);
                         publishedCount += 1;
@@ -835,16 +1042,19 @@ export class MessageDeliveryEngine {
             this.ensurePullOperationCurrent();
             await this.confirmPlainForwardAck(ns, ackMethod, pendingAckSeq, groupId);
         }
+        const remaining = typeof response.remaining === 'number' && Number.isSafeInteger(response.remaining) && response.remaining >= 0
+            ? response.remaining : null;
+        this.onPullPage(ns, publishedCount, response.has_more === true, messages.length > 0 ? Number(messages[messages.length - 1].seq ?? 0) : undefined, remaining, messages.length, client._seqTracker.getContiguousSeq(ns), messages.length > 0 ? Number(messages[messages.length - 1].seq ?? 0) : undefined);
         return { rawCount: messages.length, publishedCount };
     }
-    enqueueOrderedMessage(ns, event, seq, payload) {
+    enqueueOrderedMessage(ns, event, seq, payload, source = 'push') {
         const client = this.runtime.client;
         let queue = client._pendingOrderedMsgs.get(ns);
         if (!queue) {
             queue = new Map();
             client._pendingOrderedMsgs.set(ns, queue);
         }
-        queue.set(seq, { event, payload });
+        queue.set(seq, { event, payload, source });
         if (queue.size > PENDING_ORDERED_LIMIT) {
             const drop = [...queue.keys()].sort((a, b) => a - b).slice(0, queue.size - PENDING_ORDERED_LIMIT);
             for (const oldSeq of drop)
@@ -854,23 +1064,23 @@ export class MessageDeliveryEngine {
     isGroupEventNamespace(ns) {
         return ns.startsWith('group_event:');
     }
-    async publishOrderedQueueItem(ns, event, seq, payload, pullResponse = false) {
+    async publishOrderedQueueItem(ns, event, seq, payload, pullResponse = false, source = 'push', batch) {
         const client = this.runtime.client;
         if (event === 'group.changed' && this.isGroupEventNamespace(ns)) {
-            await this.publishOrderedGroupChanged(payload);
+            await this.publishOrderedGroupChanged(payload, source);
             return;
         }
         if (event === 'message.recalled') {
-            await this.publishMessageRecallTombstone(seq, payload);
+            await this.publishMessageRecallTombstone(seq, payload, source);
             return;
         }
         if (pullResponse) {
-            await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload));
+            await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
             return;
         }
-        await client._publishAppEvent(event, payload);
+        await client._publishAppEvent(event, payload, source, ns, batch);
     }
-    async publishOrderedGroupChanged(payload) {
+    async publishOrderedGroupChanged(payload, source = 'ordered') {
         const client = this.runtime.client;
         if (isJsonObject(payload)) {
             const eventPayload = payload;
@@ -882,7 +1092,7 @@ export class MessageDeliveryEngine {
                     client._cleanupDissolvedGroup?.(groupId);
             }
         }
-        await client._publishAppEvent('group.changed', payload);
+        await client._publishAppEvent('group.changed', payload, source);
     }
     isInstanceScopedMessageEvent(event) {
         return event === 'message.received'
@@ -905,18 +1115,27 @@ export class MessageDeliveryEngine {
         }
         return result;
     }
-    normalizePublishedMessagePayload(event, payload) {
+    normalizePublishedMessagePayload(event, payload, source = 'direct') {
+        let normalized;
         if (this.isInstanceScopedMessageEvent(event)) {
             payload = this.stripInlineInternalFields(payload);
             if (event === 'group.message_created')
                 payload = normalizeGroupMentionMode(payload);
-            return this.attachAppMessageEnvelope(this.stripInternalSenderDeviceFields(this.attachCurrentInstanceContext(payload)));
+            normalized = this.attachAppMessageEnvelope(this.stripInternalSenderDeviceFields(this.attachCurrentInstanceContext(payload)));
         }
-        if (this.isGroupScopedEvent(event)) {
+        else if (this.isGroupScopedEvent(event)) {
             payload = this.stripInlineInternalFields(payload);
-            return this.attachAppGroupEventEnvelope(this.attachCurrentInstanceContext(payload));
+            normalized = this.attachAppGroupEventEnvelope(this.attachCurrentInstanceContext(payload));
         }
-        return payload;
+        else {
+            normalized = payload;
+        }
+        const canonicalSource = canonicalDeliverySource(source);
+        if (canonicalSource === 'direct' || !isJsonObject(normalized))
+            return normalized;
+        if (!this.isInstanceScopedMessageEvent(event) && !this.isGroupScopedEvent(event))
+            return normalized;
+        return { ...normalized, source: canonicalSource };
     }
     stripInlineInternalFields(payload) {
         if (!isJsonObject(payload))
@@ -1043,6 +1262,7 @@ export class MessageDeliveryEngine {
         setIfPresent('type', firstValue(body.type, params.type, params.message_type, params.payload_type));
         setIfPresent('kind', firstValue(body.kind, params.kind));
         setIfPresent('version', firstValue(body.version, params.version));
+        setIfPresent('message_id', firstValue(params.message_id, body.message_id, resultObj.message_id));
         setIfPresent('timestamp', firstValue(params.timestamp, resultObj.timestamp, resultObj.created_at, resultObj.t_server, Date.now()));
         envelope.encrypted = Boolean(encrypted);
         const context = this.envelopeMetadata(params.context);
@@ -1184,7 +1404,7 @@ export class MessageDeliveryEngine {
             return `p2p|tombstone:${tombstoneId}`;
         return `p2p|unknown:${Date.now()}:${Math.random()}`;
     }
-    async publishMessageRecallTombstone(seq, message) {
+    async publishMessageRecallTombstone(seq, message, source = 'push') {
         const client = this.runtime.client;
         const eventPayload = this.recallEventFromMessage(message);
         if (!eventPayload)
@@ -1205,7 +1425,7 @@ export class MessageDeliveryEngine {
             for (const [oldKey] of drop)
                 seen.delete(oldKey);
         }
-        await client._publishAppEvent('message.recalled', eventPayload);
+        await client._publishAppEvent('message.recalled', eventPayload, source);
         client._clientLog.debug(`message.recalled published: seq=${String(seq)} ids=${JSON.stringify(eventPayload.message_ids)}`);
         return true;
     }
@@ -1288,7 +1508,7 @@ export class MessageDeliveryEngine {
             return `${normalizedGroupId}|tombstone:${tombstoneId}`;
         return `${normalizedGroupId}|unknown:${Date.now()}:${Math.random()}`;
     }
-    async publishGroupRecallTombstone(groupId, seq, message) {
+    async publishGroupRecallTombstone(groupId, seq, message, source = 'push') {
         const client = this.runtime.client;
         const eventPayload = this.recallEventFromGroupMessage(message);
         if (!eventPayload)
@@ -1311,7 +1531,7 @@ export class MessageDeliveryEngine {
             for (const [oldKey] of drop)
                 seen.delete(oldKey);
         }
-        await client._publishAppEvent('group.message_recalled', eventPayload);
+        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;
     }
@@ -1385,8 +1605,9 @@ export class MessageDeliveryEngine {
         if (contig !== contigBefore)
             this.persistSeq(ns);
     }
-    async publishAppEvent(event, payload) {
+    async publishAppEvent(event, payload, source = 'direct', ns = '', batch) {
         const client = this.runtime.client;
+        const generation = this.deliveryGeneration;
         if ((event === 'message.received' || event === 'group.message_created') && isJsonObject(payload)) {
             client._maybeAppendEchoTraceReceive(payload);
         }
@@ -1406,7 +1627,32 @@ export class MessageDeliveryEngine {
                 client._clientLog.debug(`agent_md etag inject skipped: ${String(exc)}`);
             }
         }
-        await client._dispatcher.publish(event, this.normalizePublishedMessagePayload(event, payload));
+        const canonicalSource = canonicalDeliverySource(source);
+        let normalized = this.normalizePublishedMessagePayload(event, payload, source);
+        if (isJsonObject(normalized)
+            && (this.isInstanceScopedMessageEvent(event) || this.isGroupScopedEvent(event))
+            && canonicalSource !== 'direct') {
+            normalized = { ...normalized, source: canonicalSource };
+        }
+        client._dispatcher.enqueue(event, normalized);
+        if (generation !== this.deliveryGeneration)
+            return;
+        if (canonicalSource !== 'pull' && canonicalSource !== 'pending_retry'
+            && canonicalSource !== 'push' && canonicalSource !== 'inline_push')
+            return;
+        if (canonicalSource === 'push' || canonicalSource === 'inline_push') {
+            const localBatch = batch ?? this.createDeliveryChangeBatch(canonicalSource);
+            this.recordDeliveryChange(localBatch.changes, event, payload, ns, generation);
+            if (!batch)
+                await this.flushRealtimeDeliveryChanges(localBatch);
+        }
+        else {
+            const changes = this.pendingPullDeliveryChanges ?? new Map();
+            this.pendingPullDeliveryChanges = changes;
+            this.recordDeliveryChange(changes, event, payload, ns, generation);
+            if (client._rpcPipeline?.hasAnyPullActivity?.() !== true)
+                await this.flushPullDeliveryChanges();
+        }
     }
     messageTargetsCurrentInstance(message) {
         if (!isJsonObject(message))
@@ -1562,7 +1808,7 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         try {
             if (!isJsonObject(data)) {
-                await client._publishAppEvent('message.received', data);
+                await client._publishAppEvent('message.received', data, 'push');
                 return;
             }
             const msg = { ...data };
@@ -1614,7 +1860,7 @@ export class MessageDeliveryEngine {
                     await client._publishEncryptedPushMessage('message.received', 'message.undecryptable', '', seq ?? 0, msg, false);
                     return;
                 }
-                await client._publishAppEvent('message.received', msg);
+                await client._publishAppEvent('message.received', msg, 'push');
             }
         }
         catch (exc) {
@@ -1630,7 +1876,7 @@ export class MessageDeliveryEngine {
                     _decrypt_error: String(exc),
                 };
                 client._attachV2EnvelopeMetadataFromSource(safeEvent, data);
-                await client._publishAppEvent('message.undecryptable', safeEvent);
+                await client._publishAppEvent('message.undecryptable', safeEvent, 'push');
             }
         }
     }
@@ -1658,7 +1904,7 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         try {
             if (!isJsonObject(data)) {
-                await client._publishAppEvent('group.message_created', data);
+                await client._publishAppEvent('group.message_created', data, 'push');
                 return;
             }
             const msg = { ...data };
@@ -1737,7 +1983,7 @@ export class MessageDeliveryEngine {
                     await client._publishEncryptedPushMessage('group.message_created', 'group.message_undecryptable', '', seq ?? 0, msg, true);
                     return;
                 }
-                await client._publishAppEvent('group.message_created', msg);
+                await client._publishAppEvent('group.message_created', msg, 'push');
             }
         }
         catch (exc) {
@@ -1753,7 +1999,7 @@ export class MessageDeliveryEngine {
                     _decrypt_error: String(exc),
                 };
                 client._attachV2EnvelopeMetadataFromSource(safeEvent, data);
-                await client._publishAppEvent('group.message_undecryptable', safeEvent);
+                await client._publishAppEvent('group.message_undecryptable', safeEvent, 'push');
             }
         }
     }
@@ -1761,7 +2007,7 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         const groupId = (notification.group_id ?? '');
         if (!groupId) {
-            await client._publishAppEvent('group.message_created', notification);
+            await client._publishAppEvent('group.message_created', notification, 'push');
             return;
         }
         if (client._sessionOptions?.background_sync === false) {
@@ -1778,7 +2024,7 @@ export class MessageDeliveryEngine {
             }
             catch (exc) {
                 client._clientLog.warn(`auto pull group message failed:${String(exc)}`);
-                await client._publishAppEvent('group.message_created', notification);
+                await client._publishAppEvent('group.message_created', notification, 'push');
                 return;
             }
         }
@@ -1808,7 +2054,7 @@ export class MessageDeliveryEngine {
             // 两种情况都不能再把原始通知当作第二条业务消息发布。
             client._clientLog.warn(`auto pull group message commit/ack failed:${String(exc)}`);
             if (!rawCompleted) {
-                await client._publishAppEvent('group.message_created', notification);
+                await client._publishAppEvent('group.message_created', notification, 'push');
             }
         }
     }
@@ -1821,12 +2067,15 @@ export class MessageDeliveryEngine {
             return;
         const delayMs = Math.min(P2P_GAP_FILL_RETRY_BASE_MS * retryAttempt, P2P_GAP_FILL_RETRY_MAX_MS);
         client._gapFillDone.add(retryKey);
+        const releasePullWork = client._rpcPipeline?.reservePullWork?.() ?? (() => { });
         client._clientLog.debug(`P2P message gap-fill retry scheduled: ns=${ns} attempt=${retryAttempt} delay_ms=${delayMs}`);
         globalThis.setTimeout(() => {
             client._gapFillDone.delete(retryKey);
-            if (client.state !== ConnectionState.READY || client._closing)
+            if (client.state !== ConnectionState.READY || client._closing) {
+                releasePullWork();
                 return;
-            client._safeAsync(this.fillP2pGap(retryAttempt));
+            }
+            client._safeAsync(this.fillP2pGap(retryAttempt).finally(releasePullWork));
         }, delayMs);
     }
     async fillP2pGap(retryAttempt = 0) {
@@ -1943,6 +2192,7 @@ export class MessageDeliveryEngine {
         client._gapFillDone.add(dedupKey);
         this.runtime.delivery.setGapFillActive(true);
         let continuationAfterSeq = 0;
+        let failed = false;
         try {
             let nextAfterSeq = afterSeq;
             const maxPages = singlePage ? 1 : 100;
@@ -1982,6 +2232,7 @@ export class MessageDeliveryEngine {
                 }
                 const eventSeqs = [];
                 let hasDissolvedEvent = false;
+                let publishedEventCount = 0;
                 for (const evt of eventObjects) {
                     const eventSeq = Number(evt.event_seq ?? 0);
                     if (Number.isFinite(eventSeq) && eventSeq > 0)
@@ -2003,7 +2254,8 @@ export class MessageDeliveryEngine {
                         }
                     }
                     if (Number.isFinite(eventSeq) && eventSeq > 0 && !client._pushedSeqs.get(ns)?.has(eventSeq)) {
-                        this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, evt);
+                        this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, evt, 'pull');
+                        publishedEventCount += 1;
                     }
                 }
                 const ackContig = client._seqTracker.getContiguousSeq(ns);
@@ -2029,6 +2281,7 @@ export class MessageDeliveryEngine {
                         client._clientLog.warn('group event auto-ack failed: group=' + groupId, e);
                     }
                 }
+                this.onPullPage(ns, publishedEventCount, result.has_more === true, eventObjects.length > 0 ? Number(eventObjects[eventObjects.length - 1].event_seq ?? 0) : undefined, typeof result.remaining === 'number' && Number.isSafeInteger(result.remaining) && result.remaining >= 0 ? result.remaining : null, eventObjects.length, ackContig, eventObjects.length > 0 ? Number(eventObjects[eventObjects.length - 1].event_seq ?? 0) : undefined);
                 const nextAfter = Math.max(eventSeqs.length > 0 ? Math.max(...eventSeqs) : nextAfterSeq, nextAfterSeq);
                 if (singlePage && result.has_more === true && nextAfter > nextAfterSeq) {
                     continuationAfterSeq = nextAfter;
@@ -2042,11 +2295,14 @@ export class MessageDeliveryEngine {
             }
         }
         catch (exc) {
+            failed = true;
             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,
@@ -2527,7 +2783,7 @@ export class MessageDeliveryEngine {
             ? tracker.snapshotNamespace(ns)
             : null;
         try {
-            const published = await this.publishPulledMessage(event, ns, seq, payload);
+            const published = await this.publishPulledMessage(event, ns, seq, payload, true, 'inline_push');
             if (!this.isInlineGenerationCurrent(generation))
                 return false;
             if (!published)
@@ -3107,13 +3363,13 @@ export class MessageDeliveryEngine {
             }
         }
         catch (exc) {
-            client._dispatcher.publish('seq_tracker.persist_error', {
+            client._dispatcher.enqueue('seq_tracker.persist_error', {
                 phase: 'restore',
                 aid,
                 device_id: deviceId,
                 slot_id: slotId,
                 error: String(exc),
-            }).catch(() => { });
+            });
         }
     }
     async migrateSeqStateGroupIds(state) {
@@ -3321,13 +3577,13 @@ export class MessageDeliveryEngine {
         catch (exc) {
             const error = formatDeliveryError(exc);
             client._clientLog.warn(`save SeqTracker state failed: ${error}`);
-            client._dispatcher.publish('seq_tracker.persist_error', {
+            client._dispatcher.enqueue('seq_tracker.persist_error', {
                 phase: 'save',
                 aid,
                 device_id: deviceId,
                 slot_id: slotId,
                 error: String(error),
-            }).catch(() => { });
+            });
             if (throwOnError)
                 throw exc;
         }
@@ -3446,7 +3702,7 @@ export class MessageDeliveryEngine {
         }
         return params;
     }
-    async drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true) {
+    async drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true, batch, source = 'pull') {
         const client = this.runtime.client;
         this.ensurePullOperationCurrent();
         const queue = client._pendingOrderedMsgs.get(ns);
@@ -3457,16 +3713,34 @@ export class MessageDeliveryEngine {
             .filter((seq) => seq <= contig && (beforeSeq === undefined || seq < beforeSeq))
             .sort((a, b) => a - b);
         let delivered = false;
-        for (const seq of ready) {
-            this.ensurePullOperationCurrent();
-            const item = queue.get(seq);
-            queue.delete(seq);
-            if (!item || client._pushedSeqs.get(ns)?.has(seq))
-                continue;
-            await this.publishOrderedQueueItem(ns, item.event, seq, item.payload, pullResponse);
-            this.ensurePullOperationCurrent();
-            this.markPublishedSeq(ns, seq);
-            delivered = true;
+        const drainBatches = new Map();
+        try {
+            for (const seq of ready) {
+                this.ensurePullOperationCurrent();
+                const item = queue.get(seq);
+                queue.delete(seq);
+                if (!item || client._pushedSeqs.get(ns)?.has(seq))
+                    continue;
+                const itemSource = item.source ?? source;
+                let itemBatch = batch;
+                if ((itemSource === 'push' || itemSource === 'inline_push')
+                    && (!batch || batch.trigger !== itemSource)) {
+                    itemBatch = drainBatches.get(itemSource);
+                    if (!itemBatch) {
+                        itemBatch = this.createDeliveryChangeBatch(itemSource);
+                        drainBatches.set(itemSource, itemBatch);
+                    }
+                }
+                await this.publishOrderedQueueItem(ns, item.event, seq, item.payload, pullResponse, itemSource, itemBatch);
+                this.ensurePullOperationCurrent();
+                this.markPublishedSeq(ns, seq);
+                delivered = true;
+            }
+        }
+        finally {
+            for (const drainBatch of drainBatches.values()) {
+                await this.flushRealtimeDeliveryChanges(drainBatch);
+            }
         }
         if (queue.size === 0) {
             client._pendingOrderedMsgs.delete(ns);
@@ -3476,75 +3750,91 @@ export class MessageDeliveryEngine {
             }
         }
     }
-    async publishOrderedMessage(event, ns, seq, payload) {
+    async publishOrderedMessage(event, ns, seq, payload, source = 'push', operationBatch) {
         const client = this.runtime.client;
-        const seqNum = Number(seq);
-        if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0) {
-            await this.publishOrderedQueueItem(ns, event, seqNum, payload);
-            return true;
-        }
-        if (client._pushedSeqs.get(ns)?.has(seqNum)) {
+        const ownsBatch = !operationBatch && (source === 'push' || source === 'inline_push');
+        const batch = operationBatch ?? (ownsBatch ? this.createDeliveryChangeBatch(source) : undefined);
+        try {
+            const seqNum = Number(seq);
+            if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0) {
+                await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch);
+                return true;
+            }
+            if (client._pushedSeqs.get(ns)?.has(seqNum)) {
+                const queue = client._pendingOrderedMsgs.get(ns);
+                queue?.delete(seqNum);
+                if (queue && queue.size === 0)
+                    client._pendingOrderedMsgs.delete(ns);
+                return false;
+            }
+            const contig = client._seqTracker.getContiguousSeq(ns);
+            if (seqNum > contig) {
+                this.enqueueOrderedMessage(ns, event, seqNum, payload, source);
+                return false;
+            }
+            await this.drainOrderedMessages(ns, seqNum, true, true, batch, source);
+            if (client._pushedSeqs.get(ns)?.has(seqNum))
+                return false;
             const queue = client._pendingOrderedMsgs.get(ns);
             queue?.delete(seqNum);
             if (queue && queue.size === 0)
                 client._pendingOrderedMsgs.delete(ns);
-            return false;
+            await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch);
+            this.markPublishedSeq(ns, seqNum);
+            await this.drainOrderedMessages(ns, undefined, false, true, batch, source);
+            if (!client._pendingOrderedMsgs.get(ns))
+                await this.saveSeqTrackerState();
+            return true;
         }
-        const contig = client._seqTracker.getContiguousSeq(ns);
-        if (seqNum > contig) {
-            this.enqueueOrderedMessage(ns, event, seqNum, payload);
-            return false;
+        finally {
+            if (ownsBatch && batch)
+                await this.flushRealtimeDeliveryChanges(batch);
         }
-        await this.drainOrderedMessages(ns, seqNum, true);
-        if (client._pushedSeqs.get(ns)?.has(seqNum))
-            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);
-        this.markPublishedSeq(ns, seqNum);
-        await this.drainOrderedMessages(ns);
-        if (!client._pendingOrderedMsgs.get(ns))
-            await this.saveSeqTrackerState();
-        return true;
     }
-    async publishPulledMessage(event, ns, seq, payload, persist = true) {
+    async publishPulledMessage(event, ns, seq, payload, persist = true, source = 'pull', operationBatch) {
         const client = this.runtime.client;
-        this.ensurePullOperationCurrent();
-        const seqNum = Number(seq);
-        if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0 || !ns) {
-            if (event === 'message.recalled') {
-                const published = await client._withPullResponseProcessing(ns, () => this.publishMessageRecallTombstone(seq, payload));
+        const ownsBatch = !operationBatch && (source === 'push' || source === 'inline_push');
+        const batch = operationBatch ?? (ownsBatch ? this.createDeliveryChangeBatch(source) : undefined);
+        try {
+            this.ensurePullOperationCurrent();
+            const seqNum = Number(seq);
+            if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0 || !ns) {
+                if (event === 'message.recalled') {
+                    const published = await client._withPullResponseProcessing(ns, () => this.publishMessageRecallTombstone(seq, payload, source));
+                    this.ensurePullOperationCurrent();
+                    return published;
+                }
+                await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
                 this.ensurePullOperationCurrent();
-                return published;
+                return true;
+            }
+            const queue = client._pendingOrderedMsgs.get(ns);
+            if (client._pushedSeqs.get(ns)?.has(seqNum)) {
+                queue?.delete(seqNum);
+                if (queue && queue.size === 0)
+                    client._pendingOrderedMsgs.delete(ns);
+                return false;
             }
-            await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload));
+            await this.drainOrderedMessages(ns, seqNum, false, persist, batch, source);
             this.ensurePullOperationCurrent();
-            return true;
-        }
-        const queue = client._pendingOrderedMsgs.get(ns);
-        if (client._pushedSeqs.get(ns)?.has(seqNum)) {
             queue?.delete(seqNum);
             if (queue && queue.size === 0)
                 client._pendingOrderedMsgs.delete(ns);
-            return false;
-        }
-        await this.drainOrderedMessages(ns, seqNum, false, persist);
-        this.ensurePullOperationCurrent();
-        queue?.delete(seqNum);
-        if (queue && queue.size === 0)
-            client._pendingOrderedMsgs.delete(ns);
-        if (event === 'message.recalled') {
-            const published = await client._withPullResponseProcessing(ns, () => this.publishMessageRecallTombstone(seqNum, payload));
+            if (event === 'message.recalled') {
+                const published = await client._withPullResponseProcessing(ns, () => this.publishMessageRecallTombstone(seqNum, payload, source));
+                this.ensurePullOperationCurrent();
+                this.markPublishedSeq(ns, seqNum);
+                return published;
+            }
+            await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
             this.ensurePullOperationCurrent();
             this.markPublishedSeq(ns, seqNum);
-            return published;
+            return true;
+        }
+        finally {
+            if (ownsBatch && batch)
+                await this.flushRealtimeDeliveryChanges(batch);
         }
-        await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload));
-        this.ensurePullOperationCurrent();
-        this.markPublishedSeq(ns, seqNum);
-        return true;
     }
 }
 //# sourceMappingURL=delivery.js.map