@agentunion/fastaun 0.5.17 → 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);
@@ -1460,6 +1502,24 @@ export class MessageDeliveryEngine {
             return false;
         return senderDevice.trim() === String(client._deviceId).trim();
     }
+    isSelfSentP2PMessage(message) {
+        if (!isJsonObject(message))
+            return false;
+        const client = this.runtime.client;
+        if (String(message.direction ?? '').trim() !== 'outbound_sync')
+            return false;
+        const selfAid = String(client._aid ?? '').trim().toLowerCase();
+        const senderAid = String(message.sender_aid ?? message.from_aid ?? message.from ?? '').trim().toLowerCase();
+        if (!selfAid || senderAid !== selfAid)
+            return false;
+        const senderDevice = Object.prototype.hasOwnProperty.call(message, 'sender_device_id')
+            ? message.sender_device_id
+            : message.from_device_id;
+        return typeof senderDevice === 'string'
+            && Boolean(senderDevice.trim())
+            && Boolean(String(client._deviceId ?? '').trim())
+            && senderDevice.trim() === String(client._deviceId).trim();
+    }
     async runPushProcessSerialized(ns, operation, inlineGeneration) {
         const client = this.runtime.client;
         if (inlineGeneration === undefined) {
@@ -1589,7 +1649,7 @@ export class MessageDeliveryEngine {
         // 在旧 seq tracking / ordered publish 之前转入前台 Tail 协调器。
         const inlinePresent = hasNonEmptyInlineMessage(msg.inline_message);
         const legacyPushSeq = this.realtimeHeadSeq(msg.seq, inlinePresent);
-        if (client._v2Session && client._aid && (msg.seq !== undefined && msg.seq !== null || inlinePresent)) {
+        if ((client._v2Session || inlinePresent) && client._aid && (msg.seq !== undefined && msg.seq !== null || inlinePresent)) {
             if (legacyPushSeq === null) {
                 if (inlinePresent)
                     await this.recoverInvalidP2PRealtimeHead(`p2p:${client._aid}`, msg.seq);
@@ -1606,10 +1666,18 @@ export class MessageDeliveryEngine {
             const ns = `p2p:${client._aid}`;
             if (seq > 0)
                 client._seqTracker.updateMaxSeen(ns, seq);
+            if (encryptedPush) {
+                if (Number(seq) > client._seqTracker.getContiguousSeq(ns) && client._sessionOptions?.background_sync !== false) {
+                    client._clientLog.debug(`P2P push triggering Forward: ns=${ns}, seq=${seq}, contiguous=${client._seqTracker.getContiguousSeq(ns)}`);
+                    this.fillP2pGap().catch((exc) => client._clientLog.warn(`background gap fill trigger failed: ${formatDeliveryError(exc)}`));
+                }
+                return;
+            }
             if (Number(seq) > client._seqTracker.getContiguousSeq(ns) && client._sessionOptions?.background_sync !== false) {
                 client._clientLog.debug(`P2P push triggering Forward: ns=${ns}, seq=${seq}, contiguous=${client._seqTracker.getContiguousSeq(ns)}`);
                 this.fillP2pGap().catch((exc) => client._clientLog.warn(`background gap fill trigger failed: ${formatDeliveryError(exc)}`));
             }
+            await this.publishOrderedMessage('message.received', ns, seq, msg, 'push');
             return;
         }
         else {
@@ -1617,6 +1685,8 @@ export class MessageDeliveryEngine {
                 await client._publishEncryptedPushMessage('message.received', 'message.undecryptable', '', seq ?? 0, msg, false);
                 return;
             }
+            if (this.isSelfSentP2PMessage(msg))
+                return;
             await client._publishAppEvent('message.received', msg, 'push');
         }
     }
@@ -1671,7 +1741,7 @@ export class MessageDeliveryEngine {
         // 不能让 payload 路径直接推进旧 ordered publish 状态。
         const inlinePresent = hasNonEmptyInlineMessage(msg.inline_message);
         const legacyPushSeq = this.realtimeHeadSeq(seq, inlinePresent);
-        if (client._v2Session && groupId && (seq !== undefined && seq !== null || inlinePresent)) {
+        if ((client._v2Session || inlinePresent) && groupId && (seq !== undefined && seq !== null || inlinePresent)) {
             if (legacyPushSeq === null) {
                 if (inlinePresent)
                     await this.recoverInvalidGroupRealtimeHead(groupId, `group:${groupId}`, seq);
@@ -1694,10 +1764,20 @@ export class MessageDeliveryEngine {
             const ns = `group:${groupId}`;
             if (seq > 0)
                 client._seqTracker.updateMaxSeen(ns, seq);
+            if (encryptedPush) {
+                if (Number(seq) > client._seqTracker.getContiguousSeq(ns) && client._sessionOptions?.background_sync !== false) {
+                    client._clientLog.debug(`group push triggering Forward: group=${groupId}, seq=${seq}, contiguous=${client._seqTracker.getContiguousSeq(ns)}`);
+                    this.fillGroupGap(groupId).catch((exc) => client._clientLog.warn(`background gap fill trigger failed: ${formatDeliveryError(exc)}`));
+                }
+                return;
+            }
             if (Number(seq) > client._seqTracker.getContiguousSeq(ns) && client._sessionOptions?.background_sync !== false) {
                 client._clientLog.debug(`group push triggering Forward: group=${groupId}, seq=${seq}, contiguous=${client._seqTracker.getContiguousSeq(ns)}`);
                 this.fillGroupGap(groupId).catch((exc) => client._clientLog.warn(`background gap fill trigger failed: ${formatDeliveryError(exc)}`));
             }
+            if (!this.isSelfSentGroupMessage(msg)) {
+                await this.publishOrderedMessage('group.message_created', ns, seq, msg, 'group-push');
+            }
             return;
         }
         else {
@@ -1845,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
@@ -1867,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;
@@ -1896,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;
@@ -1909,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;
@@ -1945,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 {
@@ -2004,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)
@@ -2374,7 +2477,7 @@ export class MessageDeliveryEngine {
                 after_seq: state.ack,
                 limit: pageLimit,
                 ...(headForward ? { max_pages: Math.max(2, requiredPages) } : order[0] === 'tail' ? { max_pages: requiredPages } : {}),
-            }, !foregroundForward, headForward || tailMissedDuringPull);
+            }, true, headForward || tailMissedDuringPull);
         }
         if (tailHead !== null && this.syncState(ns).ack < this.syncState(ns).tail - 1) {
             this.scheduleRealtimeWindowForward(ns);
@@ -2451,7 +2554,7 @@ export class MessageDeliveryEngine {
                 after_seq: state.ack,
                 limit: pageLimit,
                 ...(headForward ? { max_pages: Math.max(2, requiredPages) } : order[0] === 'tail' ? { max_pages: requiredPages } : {}),
-            }, !foregroundForward, headForward || tailMissedDuringPull);
+            }, true, headForward || tailMissedDuringPull);
         }
         if (tailHead !== null && this.syncState(ns).ack < this.syncState(ns).tail - 1) {
             this.scheduleRealtimeWindowForward(ns, groupId);
@@ -2722,10 +2825,10 @@ export class MessageDeliveryEngine {
         const pending = client._pendingOrderedMsgs.get(ns);
         return !pending || pending.size === 0;
     }
-    async decodeInlineP2P(row) {
+    async decodeInlineP2P(row, deferStatus) {
         const client = this.runtime.client;
         if (this.inlineRowKind(row) === 'v2') {
-            const decrypted = await client._decryptV2PushMessage(row);
+            const decrypted = await client._decryptV2PushMessage(row, deferStatus);
             return isJsonObject(decrypted) ? decrypted : null;
         }
         const legacy = isJsonObject(row.legacy_v1) ? row.legacy_v1 : null;
@@ -2750,16 +2853,20 @@ export class MessageDeliveryEngine {
             timestamp: row.t_server,
             payload: payload,
             encrypted: false,
-            direction: String(row.direction ?? '').trim() || (fromAid && fromAid === client._aid ? 'outbound_sync' : 'inbound'),
         };
+        const direction = String(row.direction ?? '').trim();
+        if (direction)
+            result.direction = direction;
+        else if (fromAid && fromAid !== client._aid)
+            result.direction = 'inbound';
         if (row.sender_device_id !== undefined)
             result.sender_device_id = row.sender_device_id;
         return result;
     }
-    async decodeInlineGroup(row, groupId, groupAid) {
+    async decodeInlineGroup(row, groupId, groupAid, deferStatus) {
         const client = this.runtime.client;
         if (this.inlineRowKind(row) === 'v2') {
-            const decrypted = await client._decryptV2PushMessage(row);
+            const decrypted = await client._decryptV2PushMessage(row, deferStatus);
             if (!isJsonObject(decrypted))
                 return null;
             const decoded = decrypted;
@@ -2822,17 +2929,24 @@ 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 published = client._publishAppEvent(event, payload, 'inline-push');
-            if (isPromiseLike(published))
-                await published;
+            const selfSync = (event === 'message.received' && this.isSelfSentP2PMessage(payload))
+                || (event === 'group.message_created' && this.isSelfSentGroupMessage(payload));
+            if (!selfSync) {
+                const published = client._publishAppEvent(event, payload, 'inline-push');
+                if (isPromiseLike(published))
+                    await published;
+            }
             if (!this.inlineGenerationIsCurrent(generation))
                 return false;
             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;
@@ -2855,15 +2969,46 @@ 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)}`);
             return false;
         }
     }
+    async commitInlineTerminalDecryptSeq(ns, seq, generation) {
+        const client = this.runtime.client;
+        const tracker = client._seqTracker;
+        if (!this.inlineGenerationIsCurrent(generation) || !this.inlineStateIsCaughtUp(ns, seq))
+            return false;
+        const snapshot = typeof tracker.snapshotNamespace === 'function' ? tracker.snapshotNamespace(ns) : null;
+        try {
+            const needsPull = Boolean(tracker.onMessageSeq(ns, seq));
+            tracker.commitTailWindow(ns, {
+                windowStartSeq: seq,
+                headSeq: seq,
+                coveredThroughSeq: seq,
+                pageLimit: 1,
+            });
+            const committed = this.syncState(ns);
+            if (needsPull || committed.ack !== seq || committed.tail !== seq || committed.head !== seq) {
+                throw new Error('inline realtime terminal cursor did not collapse after consume');
+            }
+            await client._commitSeqTrackerState(ns);
+            return this.inlineGenerationIsCurrent(generation);
+        }
+        catch (exc) {
+            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;
+        }
+    }
     async tryConsumeInlineP2P(head, ns, pushSeq, expectedVersion, inlineGeneration) {
         const client = this.runtime.client;
         if (!isJsonObject(head.inline_message))
@@ -2883,7 +3028,14 @@ export class MessageDeliveryEngine {
                 return false;
             let committed = false;
             try {
-                const decoded = await this.decodeInlineP2P(row);
+                const decryptStatus = {};
+                const decoded = await this.decodeInlineP2P(row, decryptStatus);
+                if (!decoded && decryptStatus.terminal) {
+                    if (!await this.commitInlineTerminalDecryptSeq(ns, pushSeq, generation))
+                        return false;
+                    committed = this.markPendingP2PInlineAckCommitted(ns, pushSeq);
+                    return committed;
+                }
                 if (!this.inlineGenerationIsCurrent(generation) || !decoded || !this.inlineStateIsCaughtUp(ns, pushSeq)
                     || !this.decodedInlineMatches(head, decoded, pushSeq))
                     return false;
@@ -2921,7 +3073,14 @@ export class MessageDeliveryEngine {
                 return false;
             let committed = false;
             try {
-                const decoded = await this.decodeInlineGroup(row, groupId, groupAid || groupId);
+                const decryptStatus = {};
+                const decoded = await this.decodeInlineGroup(row, groupId, groupAid || groupId, decryptStatus);
+                if (!decoded && decryptStatus.terminal) {
+                    if (!await this.commitInlineTerminalDecryptSeq(ns, pushSeq, generation))
+                        return false;
+                    committed = this.markPendingGroupInlineAckCommitted(ns, pushSeq);
+                    return committed;
+                }
                 if (!this.inlineGenerationIsCurrent(generation) || !decoded || !this.inlineStateIsCaughtUp(ns, pushSeq)
                     || !this.decodedInlineMatches(head, decoded, pushSeq, groupId))
                     return false;
@@ -3040,13 +3199,14 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         if (inlineGeneration !== undefined && !this.inlineGenerationIsCurrent(inlineGeneration))
             return;
-        if (!client._v2Session)
-            return;
         const pushData = isJsonObject(data) ? data : null;
         const rawPushSeq = pushData?.seq;
         const ns = client._aid ? `p2p:${client._aid}` : '';
         if (!pushData || !ns)
             return;
+        const inlinePresent = hasNonEmptyInlineMessage(pushData.inline_message);
+        if (!client._v2Session && !(expectedVersion === 'v1' && inlinePresent))
+            return;
         if (this.isVolatileMessage(pushData)) {
             await client._v2E2EE.publishV2VolatileMessages([pushData], 'push', false);
             return;
@@ -3057,7 +3217,6 @@ export class MessageDeliveryEngine {
             this.enqueueOnlineUnreadP2pHint(pushData);
             return;
         }
-        const inlinePresent = hasNonEmptyInlineMessage(pushData.inline_message);
         const pushSeq = this.realtimeHeadSeq(rawPushSeq, inlinePresent);
         if (pushSeq === null) {
             if (inlinePresent) {
@@ -3154,8 +3313,8 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         if (inlineGeneration !== undefined && !this.inlineGenerationIsCurrent(inlineGeneration))
             return;
-        if (!isJsonObject(data) || !client._v2Session) {
-            client._clientLog.debug(`_onRawGroupV2MessageCreated skipped: is_object=${String(isJsonObject(data))}, has_v2_session=${String(!!client._v2Session)}`);
+        if (!isJsonObject(data)) {
+            client._clientLog.debug('_onRawGroupV2MessageCreated skipped: is_object=false');
             return;
         }
         const d = data;
@@ -3163,6 +3322,8 @@ export class MessageDeliveryEngine {
         const groupId = typeof d.group_id === 'string' ? d.group_id.trim() : '';
         const rawSeq = d.seq;
         const inlinePresent = hasNonEmptyInlineMessage(d.inline_message);
+        if (!client._v2Session && !(expectedVersion === 'v1' && inlinePresent))
+            return;
         const seq = this.realtimeHeadSeq(rawSeq, inlinePresent);
         if (!groupId) {
             client._clientLog.debug(`_onRawGroupV2MessageCreated skipped: group=${groupId || '<empty>'}, seq=${String(d.seq ?? '')}`);
@@ -3621,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);
@@ -3638,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))
@@ -3652,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;
@@ -3673,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}`);
             }
@@ -3720,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);
@@ -3739,6 +3910,11 @@ export class MessageDeliveryEngine {
                 client._pendingOrderedMsgs.delete(ns);
             return false;
         }
+        if (event === 'message.received' && this.isSelfSentP2PMessage(payload)) {
+            this.markPublishedSeq(ns, seqNum);
+            client._clientLog.debug(`publish ordered skipped current-device self-sync: ns=${ns}, seq=${seqNum}`);
+            return false;
+        }
         const contig = client._seqTracker.getContiguousSeq(ns);
         if (seqNum > contig && seqNum !== contig + 1) {
             client._clientLog.debug(`publish ordered enqueue(gap): event=${event}, ns=${ns}, seq=${seqNum}, contiguous=${contig}`);
@@ -3752,13 +3928,20 @@ export class MessageDeliveryEngine {
             client._clientLog.debug(`publish ordered skipped after-drain duplicate: event=${event}, ns=${ns}, seq=${seqNum}`);
             return false;
         }
+        if (event === 'message.received' && this.isSelfSentP2PMessage(payload)) {
+            this.markPublishedSeq(ns, seqNum);
+            client._clientLog.debug(`publish pulled skipped current-device self-sync: ns=${ns}, seq=${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, 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}`);
@@ -3772,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);
@@ -3799,16 +3983,23 @@ export class MessageDeliveryEngine {
                 client._pendingOrderedMsgs.delete(ns);
             return false;
         }
+        if (event === 'message.received' && this.isSelfSentP2PMessage(payload)) {
+            this.markPublishedSeq(ns, seqNum);
+            client._clientLog.debug('publish pulled skipped current-device self-sync');
+            return source === 'inline_push';
+        }
         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);
@@ -3819,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);