@agentunion/fastaun 0.5.16 → 0.5.18

package/dist/client/delivery.js

@@ -7,6 +7,7 @@ const PUSHED_SEQS_LIMIT = 50_000;
 const PENDING_ORDERED_LIMIT = 50_000;
 const MESSAGE_RECALL_SEEN_LIMIT = 10_000;
 const GROUP_RECALL_SEEN_LIMIT = 10_000;
+const VOLATILE_SEEN_LIMIT = 10_000;
 const SEQ_TRACKER_PERSIST_FLUSH_DELAY_MS = 200;
 const DELIVERY_CHANGED_MESSAGE_EVENTS = new Set([
     'message.received',
@@ -35,7 +36,7 @@ const APP_SEND_ENVELOPE_METHODS = new Set([
 const APP_GROUP_EVENT_ENVELOPE_KEYS = [
     'module_id', 'event_id', 'event_seq', 'seq', 'event_type', 'action', 'group_id',
     'actor_aid', 'sender_aid', 'member_aid', 'target_aid', 'operator_aid',
-    'created_at', 'timestamp', 't_server', 'status', 'device_id', 'slot_id',
+    'created_at', 'timestamp', 't_server', 'status', 'device_id',
 ];
 function isPromiseLike(value) {
     return Boolean(value && typeof value.then === 'function');
@@ -87,6 +88,10 @@ export class MessageDeliveryEngine {
     deliveryChangedGeneration = 0;
     syncRun = 0;
     syncSessions = null;
+    volatileContext = '';
+    volatileCursor = '';
+    volatileSeenMessages = new Map();
+    volatileInFlightMessages = new Set();
     // 同一实例的 tracker 写入必须串行，避免旧的延迟 flush 覆盖新的 Forward 提交。
     seqTrackerWriteChain = Promise.resolve();
     constructor(runtime) {
@@ -157,9 +162,13 @@ export class MessageDeliveryEngine {
             throw new Error(`${method} response must be an object`);
         }
         const client = this.runtime.client;
+        const response = result;
+        const volatileMessages = method === 'message.pull' ? this.volatileMessages(response.messages) : [];
+        if (volatileMessages.length > 0) {
+            await this.publishPlainVolatileMessages(volatileMessages, 'pull', true);
+        }
         this.ensurePullOperationCurrent(ns);
         this.syncStarted(ns);
-        const response = result;
         const messages = deduplicatePlainForwardPageMessages(response.messages, afterSeq);
         const coordinator = this.forwardCoordinator();
         const pageContigBefore = client._seqTracker.getContiguousSeq(ns);
@@ -279,8 +288,121 @@ export class MessageDeliveryEngine {
             hasMore: typeof response.has_more === 'boolean' ? response.has_more : undefined,
             currentSeq: client._seqTracker.getContiguousSeq(ns),
         });
+        response.messages = (Array.isArray(response.messages) ? response.messages : [])
+            .map((message) => this.stripInternalSenderDeviceFields(message));
         return { rawCount: messages.length, publishedCount };
     }
+    isVolatileMessage(message) {
+        return isJsonObject(message)
+            && String(message.storage ?? '') === 'volatile';
+    }
+    volatileMessages(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.filter((item) => this.isVolatileMessage(item)).map((item) => ({ ...item }));
+    }
+    ensureVolatileContext() {
+        const client = this.runtime.client;
+        const context = JSON.stringify([client._aid ?? '', client._deviceId ?? '', client._slotId ?? '']);
+        if (context === this.volatileContext)
+            return;
+        this.volatileContext = context;
+        this.volatileCursor = '';
+        this.volatileSeenMessages.clear();
+        this.volatileInFlightMessages.clear();
+    }
+    volatilePullCursor() {
+        this.ensureVolatileContext();
+        return this.volatileCursor;
+    }
+    resetVolatilePullCursor() {
+        this.ensureVolatileContext();
+        this.volatileCursor = '';
+    }
+    volatileSeenKey(message) {
+        const messageId = String(message.message_id ?? '').trim();
+        const sender = String(message.from_aid ?? message.from ?? '').trim();
+        const cursor = String(message.volatile_cursor ?? '').trim();
+        return `${sender}|${messageId || cursor}`;
+    }
+    isVolatileSeen(message) {
+        this.ensureVolatileContext();
+        const now = Date.now();
+        for (const [key, expiresAt] of this.volatileSeenMessages) {
+            if (expiresAt <= now)
+                this.volatileSeenMessages.delete(key);
+        }
+        return this.volatileSeenMessages.has(this.volatileSeenKey(message));
+    }
+    markVolatileSeen(message) {
+        this.ensureVolatileContext();
+        const now = Date.now();
+        const expiresAt = Math.max(now + 60_000, Number(message.expires_at ?? now + 1_800_000) || now + 1_800_000);
+        this.volatileSeenMessages.set(this.volatileSeenKey(message), expiresAt);
+        while (this.volatileSeenMessages.size > VOLATILE_SEEN_LIMIT) {
+            const first = this.volatileSeenMessages.keys().next().value;
+            if (first === undefined)
+                break;
+            this.volatileSeenMessages.delete(first);
+        }
+    }
+    beginVolatileDelivery(message) {
+        if (this.isVolatileSeen(message))
+            return 'seen';
+        const key = this.volatileSeenKey(message);
+        if (this.volatileInFlightMessages.has(key))
+            return 'inflight';
+        this.volatileInFlightMessages.add(key);
+        return 'claimed';
+    }
+    finishVolatileDelivery(message) {
+        this.ensureVolatileContext();
+        this.volatileInFlightMessages.delete(this.volatileSeenKey(message));
+    }
+    publicVolatileMessage(message) {
+        const result = this.stripInternalSenderDeviceFields(message);
+        delete result.seq;
+        return result;
+    }
+    async ackVolatileMessages(messages, v2, advanceCursor) {
+        const cursors = [...new Set(messages
+                .map((message) => String(message.volatile_cursor ?? '').trim())
+                .filter(Boolean))];
+        if (cursors.length === 0)
+            return undefined;
+        const result = await this.runtime.client._callRawV2Rpc(v2 ? 'message.v2.ack' : 'message.ack', { volatile_cursors: cursors, _rpc_background: true });
+        if (advanceCursor) {
+            this.ensureVolatileContext();
+            this.volatileCursor = cursors[cursors.length - 1] ?? '';
+        }
+        return result;
+    }
+    async publishPlainVolatileMessages(messages, source, advanceCursor) {
+        const processed = [];
+        for (const rawMessage of messages) {
+            const message = this.publicVolatileMessage(rawMessage);
+            const claim = this.beginVolatileDelivery(message);
+            if (claim === 'seen') {
+                processed.push(rawMessage);
+                continue;
+            }
+            if (claim === 'inflight')
+                continue;
+            try {
+                const appEvent = this.p2pAppEventForMessage(message);
+                await this.runtime.client._publishAppEvent(appEvent.event, appEvent.payload, source);
+                this.markVolatileSeen(message);
+            }
+            finally {
+                this.finishVolatileDelivery(message);
+            }
+            processed.push(rawMessage);
+        }
+        if (processed.length > 0) {
+            await this.ackVolatileMessages(processed, false, advanceCursor);
+        }
+        return processed.map((message) => this.publicVolatileMessage(message));
+    }
     resetInlineAckState() {
         this.syncStopped('aborted');
         this.deliveryChangedGeneration += 1;
@@ -714,9 +836,6 @@ export class MessageDeliveryEngine {
         if (!('device_id' in result)) {
             result.device_id = client._deviceId;
         }
-        if (!('slot_id' in result)) {
-            result.slot_id = client._slotId;
-        }
         return result;
     }
     normalizePublishedMessagePayload(event, payload, source = 'direct') {
@@ -728,7 +847,7 @@ export class MessageDeliveryEngine {
             normalized = this.attachAppMessageEnvelope(this.stripInternalSenderDeviceFields(this.attachCurrentInstanceContext(payload)));
         }
         else if (this.isGroupScopedEvent(event)) {
-            normalized = this.attachAppGroupEventEnvelope(this.attachCurrentInstanceContext(payload));
+            normalized = this.attachAppGroupEventEnvelope(this.stripInternalSenderDeviceFields(this.attachCurrentInstanceContext(payload)));
         }
         else {
             normalized = payload;
@@ -901,7 +1020,7 @@ export class MessageDeliveryEngine {
             const authoritativeSource = hasGroupMentionModeField(serverSource) ? serverSource : out;
             out = normalizeGroupMentionMode(out, authoritativeSource);
         }
-        return out;
+        return this.stripInternalSenderDeviceFields(out);
     }
     attachAppGroupEventEnvelope(payload) {
         if (!isJsonObject(payload))
@@ -915,10 +1034,13 @@ export class MessageDeliveryEngine {
         if (!isJsonObject(payload))
             return payload;
         const result = { ...payload };
-        delete result.sender_device_id;
         delete result._sender_device_id;
         delete result.from_device_id;
         delete result.from_device;
+        delete result.slot_id;
+        delete result.sender_slot_id;
+        delete result.target_slot_id;
+        delete result.owner_slot_id;
         return result;
     }
     recallEventFromMessage(message) {
@@ -973,9 +1095,7 @@ export class MessageDeliveryEngine {
         }
         if ('device_id' in msg && !('device_id' in event))
             event.device_id = msg.device_id;
-        if ('slot_id' in msg && !('slot_id' in event))
-            event.slot_id = msg.slot_id;
-        return event;
+        return this.stripInternalSenderDeviceFields(event);
     }
     p2pAppEventForMessage(message) {
         const recall = this.recallEventFromMessage(message);
@@ -1082,7 +1202,7 @@ export class MessageDeliveryEngine {
             if (!('tombstone_message_id' in event))
                 event.tombstone_message_id = msg.message_id;
         }
-        return event;
+        return this.stripInternalSenderDeviceFields(event);
     }
     groupRecallDedupKey(groupId, payload) {
         // 群撤回去重键：group_id + 原始消息标识。
@@ -1340,6 +1460,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) {
@@ -1460,12 +1598,16 @@ export class MessageDeliveryEngine {
             client._clientLog.debug(`P2P push filtered by instance: message_id=${String(msg.message_id ?? '')}, seq=${String(msg.seq ?? '')}, target_device=${String(msg.device_id ?? '')}, target_slot=${String(msg.slot_id ?? '')}, local_device=${client._deviceId}, local_slot=${client._slotId}`);
             return;
         }
+        if (this.isVolatileMessage(msg)) {
+            await this.publishPlainVolatileMessages([msg], 'push', false);
+            return;
+        }
         // 新 SDK 的所有带合法 seq P2P Push 都只作为 Head 通知处理。
         // 新服务端为兼容旧 SDK 仍可能发送 message.received；V2 会话下必须
         // 在旧 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);
@@ -1482,10 +1624,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 {
@@ -1493,6 +1643,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');
         }
     }
@@ -1547,7 +1699,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);
@@ -1570,10 +1722,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 {
@@ -2250,7 +2412,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);
@@ -2327,7 +2489,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);
@@ -2598,10 +2760,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;
@@ -2626,16 +2788,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;
@@ -2701,9 +2867,13 @@ export class MessageDeliveryEngine {
         const snapshot = typeof tracker.snapshotNamespace === 'function' ? tracker.snapshotNamespace(ns) : null;
         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;
@@ -2740,6 +2910,34 @@ export class MessageDeliveryEngine {
             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 true;
+        }
+        catch (exc) {
+            if (typeof tracker.restoreNamespaceSnapshot === 'function')
+                tracker.restoreNamespaceSnapshot(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))
@@ -2759,7 +2957,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;
@@ -2797,7 +3002,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;
@@ -2916,20 +3128,24 @@ 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;
+        }
         if (String(pushData.kind ?? '').trim() === 'message.online_unread_hint') {
             if (client._sessionOptions?.background_sync === false)
                 return;
             this.enqueueOnlineUnreadP2pHint(pushData);
             return;
         }
-        const inlinePresent = hasNonEmptyInlineMessage(pushData.inline_message);
         const pushSeq = this.realtimeHeadSeq(rawPushSeq, inlinePresent);
         if (pushSeq === null) {
             if (inlinePresent) {
@@ -3026,8 +3242,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;
@@ -3035,6 +3251,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 ?? '')}`);
@@ -3611,6 +3829,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}`);
@@ -3624,6 +3847,11 @@ 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)
@@ -3671,6 +3899,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 pulled skipped current-device self-sync');
+            return source === 'inline_push';
+        }
         await this.drainOrderedMessages(ns, seqNum, true, persist, source);
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);