@agentunion/fastaun-browser 0.5.19 → 0.5.21

package/dist/client/delivery.js

@@ -1,4 +1,5 @@
 import { slotIsolationKey } from '../config.js';
+import { StateError, ValidationError } from '../errors.js';
 import { normalizeGroupAid } from '../group-id.js';
 import { SeqTracker } from '../seq-tracker.js';
 import { ConnectionState, isJsonObject } from '../types.js';
@@ -16,7 +17,7 @@ const APP_MESSAGE_ENVELOPE_KEYS = [
     'module_id', 'message_type', 'type', 'kind', 'version',
     'from', 'from_aid', 'sender_aid', 'to', 'to_aid', 'group_id',
     'timestamp', 'created_at', 'encrypted',
-    'context', 'protected_headers', 'headers', 'payload_type', 'mention_mode',
+    'context', 'protected_headers', 'headers', 'payload_type', 'mention_mode', 'need_render',
 ];
 const RECALL_PAYLOAD_KEYS = [
     'message_ids', 'target_message_seqs',
@@ -36,6 +37,11 @@ const APP_GROUP_EVENT_ENVELOPE_KEYS = [
     'actor_aid', 'sender_aid', 'member_aid', 'target_aid', 'operator_aid',
     'created_at', 'timestamp', 't_server', 'status', 'device_id',
 ];
+const APPLICATION_EVENT_FAMILIES = {
+    'message.received': 'message.batch', 'message.recalled': 'message.batch',
+    'group.message_created': 'group.message_batch', 'group.message_recalled': 'group.message_batch',
+    'group.changed': 'group.event_batch',
+};
 const MAX_INLINE_PENDING_ACK_NAMESPACES = 4096;
 function formatDeliveryError(error) {
     return error instanceof Error ? error : String(error);
@@ -120,6 +126,440 @@ function p2pAppEventFromPlainPullMessage(message) {
     return { event: 'message.received', payload: message };
 }
 export class MessageDeliveryEngine {
+    peerBootstrapContext = '';
+    peerTracker = null;
+    peerTrackerGeneration = 0;
+    peerBootstrapFloor = null;
+    peerInitializations = new Map();
+    peerInitialized = new Set();
+    committedSeqTrackerStates = new Map();
+    seqTrackerNamespaceGenerations = new Map();
+    peerDirectoryRequests = new Map();
+    peerRecoveries = new Map();
+    peerPendingSeqHints = new Map();
+    peerPendingConfirmedThrough = new Map();
+    peerRecoveryTimer = null;
+    peerVolatileCursors = new Map();
+    peerDirectoryDirty = false;
+    peerDirectoryRefreshing = false;
+    p2pDeliveryInflight = new Map();
+    p2pDeliveryCompleted = new Map();
+    peerNamespace(sender) {
+        return `p2p.peer.v1/${btoa(String.fromCharCode(...new TextEncoder().encode(sender))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')}`;
+    }
+    peerSender(ns) {
+        if (!ns.startsWith('p2p.peer.v1/'))
+            return '';
+        try {
+            return new TextDecoder().decode(Uint8Array.from(atob(ns.slice(12).replace(/-/g, '+').replace(/_/g, '/')), (value) => value.charCodeAt(0)));
+        }
+        catch {
+            return '';
+        }
+    }
+    peerContext() {
+        const client = this.runtime.client;
+        const context = JSON.stringify([client._aid, client._deviceId, slotIsolationKey(client._slotId)]);
+        if (context !== this.peerBootstrapContext || this.peerTracker !== client._seqTracker) {
+            this.peerBootstrapContext = context;
+            this.peerTracker = client._seqTracker;
+            this.peerTrackerGeneration += 1;
+            this.peerBootstrapFloor = null;
+            this.peerInitializations.clear();
+            this.peerInitialized.clear();
+            this.committedSeqTrackerStates.clear();
+            this.seqTrackerNamespaceGenerations.clear();
+            this.peerRecoveries.clear();
+            this.peerPendingSeqHints.clear();
+            this.peerPendingConfirmedThrough.clear();
+            this.peerVolatileCursors.clear();
+        }
+        return JSON.stringify([context, this.peerTrackerGeneration]);
+    }
+    isPeerInitialized(ns) {
+        if (!this.peerInitialized.has(ns))
+            return false;
+        if (this.runtime.client._seqTracker.snapshotNamespace(ns) !== null)
+            return true;
+        this.peerInitialized.delete(ns);
+        this.committedSeqTrackerStates.delete(ns);
+        return false;
+    }
+    async initializePeer(sender, initial) {
+        const client = this.runtime.client;
+        const context = this.peerContext();
+        const scope = [client._aid, client._deviceId, client._slotId];
+        if (!sender)
+            throw new ValidationError('sender_aid is required');
+        const ns = this.peerNamespace(sender);
+        if (this.isPeerInitialized(ns))
+            return;
+        const restored = client._seqTracker.exportSyncState()[ns];
+        if (restored && (restored.ack > 0 || restored.tail > 0 || restored.head > 0)) {
+            this.committedSeqTrackerStates.set(ns, { ...restored });
+            this.peerInitialized.add(ns);
+            return;
+        }
+        if (initial === undefined && this.peerBootstrapFloor !== null) {
+            let pageToken = '';
+            const visited = new Set();
+            do {
+                const directory = await this.peers({ filter: 'all', ...(pageToken ? { page_token: pageToken } : {}) }, true);
+                if (this.peerContext() !== context)
+                    throw new StateError('peer initialization invalidated');
+                if (this.isPeerInitialized(ns))
+                    return;
+                if (directory.has_more !== true)
+                    break;
+                const next = directory.next_page_token;
+                if (typeof next !== 'string' || !next || visited.has(next))
+                    throw new ValidationError('invalid peer directory pagination');
+                visited.add(next);
+                pageToken = next;
+            } while (true);
+        }
+        const existing = this.peerInitializations.get(sender);
+        if (existing)
+            return await existing;
+        const task = (async () => {
+            const ack = initial ?? this.peerBootstrapFloor;
+            if (!Number.isSafeInteger(ack) || Number(ack) < 0)
+                throw new StateError('peer bootstrap is not ready');
+            const state = { ack: Number(ack), tail: Number(ack), head: Number(ack) };
+            if (typeof client._tokenStore.saveSyncStates !== 'function')
+                throw new StateError('peer cursor persistence unavailable');
+            await this.enqueueSeqTrackerWrite(async () => {
+                if (this.peerContext() !== context)
+                    throw new StateError('peer initialization invalidated');
+                await client._tokenStore.saveSyncStates(...scope, { [ns]: state });
+                if (this.peerContext() === context)
+                    this.committedSeqTrackerStates.set(ns, { ...state });
+            });
+            if (this.peerContext() !== context)
+                throw new StateError('peer initialization invalidated');
+            client._seqTracker.forceContiguousSeq(ns, Number(ack));
+            client._seqTracker.getSyncState(ns);
+            this.peerInitialized.add(ns);
+        })();
+        this.peerInitializations.set(sender, task);
+        try {
+            await task;
+        }
+        finally {
+            if (this.peerInitializations.get(sender) === task)
+                this.peerInitializations.delete(sender);
+        }
+    }
+    peerDurableAck(ns) {
+        return this.committedSeqTrackerAck(ns);
+    }
+    rememberCommittedSeqState(ns) {
+        this.peerContext();
+        if (!this.isReliableSeqNamespace(ns) || this.committedSeqTrackerStates.has(ns))
+            return;
+        this.committedSeqTrackerStates.set(ns, { ...this.syncState(ns) });
+    }
+    committedSeqTrackerAck(ns) {
+        this.peerContext();
+        return this.committedSeqTrackerStates.get(ns)?.ack ?? 0;
+    }
+    captureSeqNamespaceGeneration(ns) {
+        return JSON.stringify([this.peerContext(), this.seqTrackerNamespaceGenerations.get(ns) ?? 0]);
+    }
+    isSeqNamespaceGenerationCurrent(ns, generation) {
+        return this.captureSeqNamespaceGeneration(ns) === generation;
+    }
+    isReliableSeqNamespace(ns) {
+        return ns.startsWith('p2p.peer.v1/') || ns.startsWith('group:') || ns.startsWith('group_event:');
+    }
+    async peers(params = {}, background = false) {
+        const client = this.runtime.client;
+        const context = this.peerContext();
+        const generation = this.captureInlineGeneration();
+        const filter = String(params.filter ?? 'pending');
+        const key = JSON.stringify([context, filter, params.page_token ?? '', params.limit ?? null]);
+        const existing = this.peerDirectoryRequests.get(key);
+        if (existing) {
+            if (!background)
+                existing.application = true;
+            return await existing.promise;
+        }
+        const request = { application: !background, promise: Promise.resolve({}) };
+        request.promise = (async () => {
+            const result = await client._callRawV2Rpc('message.peers', { ...params, cursor_scope: 'peer', filter, ...(background ? { _rpc_background: true } : { _rpc_foreground: true }) });
+            if (this.peerContext() !== context || !this.isInlineGenerationCurrent(generation))
+                throw new StateError('peer directory invalidated');
+            if (result.catalog_ready !== true || !Array.isArray(result.peers) || (filter === 'pending' && result.has_more === true))
+                throw new StateError('peer catalog is not ready', { retryable: true });
+            if (result.cursor_scope !== 'peer' || (result.filter !== undefined && result.filter !== filter))
+                throw new ValidationError('peer directory scope mismatch');
+            for (const peer of result.peers) {
+                if (!peer || typeof peer !== 'object' || typeof peer.sender_aid !== 'string' || !peer.sender_aid.trim())
+                    throw new ValidationError('invalid peer sender_aid');
+                const initial = peer.initial_after_seq ?? peer.server_ack_seq ?? result.bootstrap_floor_seq;
+                if (!Number.isSafeInteger(initial) || Number(initial) < 0)
+                    throw new ValidationError('invalid peer initial_after_seq');
+            }
+            const floor = result.bootstrap_floor_seq;
+            if (!Number.isSafeInteger(floor) || Number(floor) < 0)
+                throw new ValidationError('invalid bootstrap_floor_seq');
+            if (this.peerBootstrapFloor === null) {
+                if (typeof client._tokenStore.updateInstanceState !== 'function')
+                    throw new StateError('peer bootstrap persistence unavailable');
+                await client._tokenStore.updateInstanceState(client._aid, client._deviceId, client._slotId, (state) => {
+                    const saved = state.p2p_peer_bootstrap_floor_seq;
+                    if (Number.isSafeInteger(saved) && saved !== floor)
+                        throw new StateError('peer bootstrap changed');
+                    state.p2p_peer_bootstrap_floor_seq = floor;
+                });
+                if (this.peerContext() !== context || !this.isInlineGenerationCurrent(generation))
+                    throw new StateError('peer bootstrap invalidated');
+                this.peerBootstrapFloor = Number(floor);
+            }
+            else if (this.peerBootstrapFloor !== floor)
+                throw new StateError('peer bootstrap changed');
+            const rows = result.peers;
+            for (const peer of rows)
+                await this.initializePeer(String(peer.sender_aid ?? ''), Number(peer.initial_after_seq ?? peer.server_ack_seq ?? floor));
+            if (this.peerContext() !== context || !this.isInlineGenerationCurrent(generation))
+                throw new StateError('peer directory invalidated');
+            for (const peer of rows) {
+                const ns = this.peerNamespace(String(peer.sender_aid));
+                const next = peer.next_pending_seq;
+                const confirmed = Math.max(this.peerPendingConfirmedThrough.get(ns) ?? 0, Number(peer.server_ack_seq ?? peer.initial_after_seq ?? floor));
+                this.peerPendingConfirmedThrough.set(ns, confirmed);
+                if (typeof next === 'number' && Number.isSafeInteger(next) && next >= confirmed)
+                    this.peerPendingSeqHints.set(ns, Math.max(this.peerPendingSeqHints.get(ns) ?? next, next));
+                else if ((this.peerPendingSeqHints.get(ns) ?? Infinity) <= confirmed)
+                    this.peerPendingSeqHints.delete(ns);
+            }
+            if (request.application || rows.length > 0) {
+                client._dispatcher.enqueue('message.peers_snapshot', {
+                    aid: client._aid, device_id: client._deviceId, slot_id: client._slotId, cursor_scope: 'peer', filter,
+                    trigger: request.application ? 'application' : 'background', catalog_revision: result.catalog_revision,
+                    peers: rows.map((peer) => ({ ...peer })), peer_count: rows.length, bootstrap_floor_seq: floor,
+                    ...(result.pending_count_estimate === undefined ? {} : { pending_count_estimate: result.pending_count_estimate }),
+                    ...(filter === 'all' ? { has_more: result.has_more === true, next_page_token: result.next_page_token } : {}),
+                }, () => this.peerContext() === context && this.isInlineGenerationCurrent(generation));
+            }
+            return result;
+        })();
+        this.peerDirectoryRequests.set(key, request);
+        try {
+            return await request.promise;
+        }
+        finally {
+            if (this.peerDirectoryRequests.get(key) === request)
+                this.peerDirectoryRequests.delete(key);
+        }
+    }
+    async pullPeers(params = {}, background = false) {
+        const context = this.peerContext();
+        const generation = this.captureInlineGeneration();
+        const sender = String(params.sender_aid ?? params.peer_aid ?? '').trim();
+        if (!sender && ('after_seq' in params || 'after_volatile_cursor' in params || params.force === true || 'window_mode' in params))
+            throw new ValidationError('sender_aid is required for an explicit cursor or window');
+        const pending = sender && this.peerBootstrapFloor !== null && this.peerInitialized.has(this.peerNamespace(sender))
+            ? [] : (await this.peers({}, background)).peers;
+        if (this.peerContext() !== context || !this.isInlineGenerationCurrent(generation))
+            throw new StateError('pull invalidated');
+        const peers = sender ? [{ sender_aid: sender }] : background ? this.orderBackgroundPeers(pending) : pending;
+        const budget = { remaining: Math.max(1, Math.trunc(Number(params.max_pages ?? 100) || 100)) };
+        const results = await Promise.all(peers.map(async (peer) => {
+            const aid = String(peer.sender_aid ?? '');
+            await this.initializePeer(aid);
+            try {
+                return await this.runtime.client._v2E2EE.pullPeerV2(aid, params, background, budget);
+            }
+            catch (error) {
+                if (this.peerContext() !== context || !this.isInlineGenerationCurrent(generation))
+                    throw new StateError('pull invalidated');
+                this.schedulePeerRecovery(aid, Number(peer.head_seq ?? 0), peer.volatile_has_more === true);
+                return { sender_aid: aid, messages: [], complete: false, error: String(error) };
+            }
+        }));
+        if (this.peerContext() !== context || !this.isInlineGenerationCurrent(generation))
+            throw new StateError('pull invalidated');
+        return { cursor_scope: 'peer', peers: results, messages: results.flatMap((peer) => peer.messages ?? []), partial: results.some((peer) => !peer.complete) };
+    }
+    schedulePeerRecovery(sender, head = 0, volatile = false) {
+        const client = this.runtime.client;
+        if (!sender || client._sessionOptions?.background_sync === false || client._closing)
+            return;
+        this.peerContext();
+        const work = this.peerRecoveries.get(sender) ?? { head: 0, volatile: false, running: false, retryAt: 0, pending: false };
+        work.head = Math.max(work.head, head);
+        work.volatile ||= volatile;
+        work.pending = true;
+        this.peerRecoveries.set(sender, work);
+        this.requestPeerRecovery();
+    }
+    requestPeerRecovery() {
+        const client = this.runtime.client;
+        if (!client._p2pPeerPullEnabled || client._sessionOptions?.background_sync === false || client._closing || client.state !== ConnectionState.READY)
+            return;
+        for (const [sender, work] of this.peerRecoveries) {
+            if (work.running)
+                continue;
+            if (work.retryAt > Date.now()) {
+                if (this.peerRecoveryTimer === null)
+                    this.peerRecoveryTimer = setTimeout(() => { this.peerRecoveryTimer = null; this.requestBackgroundPullRecovery(); }, Math.max(1, work.retryAt - Date.now()));
+                continue;
+            }
+            work.running = true;
+            work.pending = false;
+            const generation = this.captureInlineGeneration();
+            client._safeAsync((async () => {
+                try {
+                    if (this.peerBootstrapFloor === null)
+                        await this.peers({}, true);
+                    await this.initializePeer(sender);
+                    const result = await client._v2E2EE.pullPeerV2(sender, {}, true, { remaining: 100 }, { retainMessages: false });
+                    if (!this.isInlineGenerationCurrent(generation))
+                        return;
+                    if (result.complete && Number(result.ack_seq ?? 0) >= work.head && !work.pending)
+                        this.peerRecoveries.delete(sender);
+                    else
+                        work.retryAt = result.complete && !work.pending ? Date.now() + 1000 : 0;
+                }
+                catch {
+                    work.retryAt = Date.now() + 1000;
+                }
+                finally {
+                    work.running = false;
+                    if (this.isInlineGenerationCurrent(generation))
+                        queueMicrotask(() => this.requestPeerRecovery());
+                }
+            })());
+        }
+    }
+    async refreshPeerDirectory() {
+        const result = await this.peers({}, true);
+        for (const peer of this.orderBackgroundPeers(result.peers))
+            this.schedulePeerRecovery(String(peer.sender_aid ?? ''), Number(peer.head_seq ?? 0), peer.volatile_has_more === true);
+    }
+    orderBackgroundPeers(peers) {
+        const hint = (peer) => this.peerBackgroundPullPriority(this.peerNamespace(String(peer.sender_aid)));
+        return [...peers].sort((left, right) => hint(left) - hint(right));
+    }
+    peerBackgroundPullPriority(ns) {
+        this.peerContext();
+        if (!ns.startsWith('p2p.peer.v1/'))
+            return undefined;
+        return this.peerPendingSeqHints.get(ns) ?? Math.max(this.peerPendingConfirmedThrough.get(ns) ?? 0, this.runtime.client._seqTracker.getContiguousSeq(ns));
+    }
+    consumePeerBackgroundPullPriority(ns, covered, next) {
+        this.peerContext();
+        if (covered < (this.peerPendingConfirmedThrough.get(ns) ?? 0))
+            return;
+        this.peerPendingConfirmedThrough.set(ns, Math.max(this.peerPendingConfirmedThrough.get(ns) ?? 0, covered));
+        if ((this.peerPendingSeqHints.get(ns) ?? Infinity) <= covered)
+            this.peerPendingSeqHints.delete(ns);
+        if (next !== undefined)
+            this.peerPendingSeqHints.set(ns, Math.max(this.peerPendingSeqHints.get(ns) ?? next, next));
+    }
+    peerVolatileCursor(sender) { this.peerContext(); return this.peerVolatileCursors.get(sender) ?? ''; }
+    setPeerVolatileCursor(sender, cursor, page) { this.deferApplicationAfterDelivery(page, () => { this.peerContext(); this.peerVolatileCursors.set(sender, cursor); }); }
+    async ownPeerType() {
+        return String(await this.runtime.client._agentMdManager?.ownType?.() ?? '');
+    }
+    requestPeerDirectoryRefresh() {
+        this.peerDirectoryDirty = true;
+        const client = this.runtime.client;
+        if (this.peerDirectoryRefreshing || client._sessionOptions?.background_sync === false || client._closing || client.state !== ConnectionState.READY)
+            return;
+        this.peerDirectoryRefreshing = true;
+        const generation = this.captureInlineGeneration();
+        client._safeAsync((async () => {
+            try {
+                do {
+                    this.peerDirectoryDirty = false;
+                    await this.refreshPeerDirectory();
+                } while (this.peerDirectoryDirty && this.isInlineGenerationCurrent(generation));
+            }
+            catch {
+                this.peerDirectoryDirty = true;
+                if (this.peerRecoveryTimer === null)
+                    this.peerRecoveryTimer = setTimeout(() => {
+                        this.peerRecoveryTimer = null;
+                        if (this.isInlineGenerationCurrent(generation))
+                            this.requestBackgroundPullRecovery();
+                    }, 1000);
+            }
+            finally {
+                this.peerDirectoryRefreshing = false;
+            }
+        })());
+    }
+    handlePeerNotification(data) {
+        const client = this.runtime.client;
+        if (!isJsonObject(data) || !this.messageTargetsCurrentInstance(data))
+            return;
+        const sender = String(data.sender_aid ?? data.from_aid ?? data.from ?? '').trim();
+        if (String(data.kind ?? '') === 'message.online_unread_hint' || !sender || data.cursor_scope !== 'peer') {
+            this.requestPeerDirectoryRefresh();
+            return;
+        }
+        const seq = positiveSafeSequenceHint(data.seq);
+        const ns = this.peerNamespace(sender);
+        this.isPeerInitialized(ns);
+        const volatile = this.isVolatileMessage(data) || data.volatile_has_more === true;
+        if (seq > 0 && seq <= client._seqTracker.getContiguousSeq(ns) && !volatile)
+            return;
+        if (seq > 0)
+            client._seqTracker.updateMaxSeen(ns, seq);
+        const inline = this.inlineMessage(data);
+        if (inline && seq > 0 && !volatile) {
+            const generation = this.captureInlineGeneration();
+            client._safeAsync((async () => {
+                let consumed = false;
+                try {
+                    if (this.peerBootstrapFloor === null)
+                        await this.peers({}, true);
+                    await this.initializePeer(sender);
+                    consumed = await client._v2E2EE.serializePeerPage(ns, async () => {
+                        const state = this.syncState(ns);
+                        const previous = data.prev_peer_seq;
+                        const expectedVersion = inline.version === 'v1' ? 'v1' : 'v2';
+                        if (!this.isInlineGenerationCurrent(generation) || !Number.isSafeInteger(previous) || Number(previous) < 0
+                            || Number(previous) >= seq || Number(previous) > state.ack || state.tail !== state.ack || state.head !== state.ack
+                            || !this.inlineP2PBindingMatches(data, inline, seq, expectedVersion)
+                            || (inline.prev_peer_seq !== undefined && inline.prev_peer_seq !== previous))
+                            return false;
+                        const decoded = await client._v2E2EE.decodeInlineP2PMessage(inline);
+                        if (!decoded || !this.isInlineGenerationCurrent(generation) || !this.decodedInlineP2PMatches(data, decoded, seq))
+                            return false;
+                        decoded.need_render = inline.need_render !== false;
+                        const event = this.p2pAppEventForMessage(decoded);
+                        await client._publishAppEvent(event.event, event.payload, 'inline_push', ns);
+                        if (!this.isInlineGenerationCurrent(generation))
+                            return false;
+                        const snapshot = client._seqTracker.snapshotNamespace(ns);
+                        try {
+                            client._seqTracker.forceContiguousSeq(ns, Math.max(state.ack, seq));
+                            await client._commitSeqTrackerState(ns);
+                            if (!this.isInlineGenerationCurrent(generation))
+                                return false;
+                        }
+                        catch (error) {
+                            if (this.isInlineGenerationCurrent(generation))
+                                client._seqTracker._restoreNamespaceSnapshotPreservingPush(ns, snapshot);
+                            throw error;
+                        }
+                        await client._v2E2EE.ackPeerV2({ sender_aid: sender, up_to_seq: client._seqTracker.getContiguousSeq(ns) });
+                        return true;
+                    });
+                }
+                catch {
+                    consumed = false;
+                }
+                if (!consumed && this.isInlineGenerationCurrent(generation))
+                    this.schedulePeerRecovery(sender, seq, false);
+            })());
+            return;
+        }
+        this.schedulePeerRecovery(sender, seq, volatile);
+    }
     runtime;
     syncRun = 0;
     syncingNamespaces = new Set();
@@ -133,11 +573,15 @@ export class MessageDeliveryEngine {
     pendingPullNoProgressAcks = null;
     onlineUnreadHintTargets = null;
     onlineUnreadHintOwners = null;
+    backgroundPullDemands = new Map();
+    backgroundPullTimer = null;
+    backgroundPullRecoveryQueued = false;
     realtimeAcking = null;
     pendingP2PInlineAcks = null;
     pendingGroupInlineAcks = null;
     pendingGroupInlineAckNamespaces = null;
     pendingTailWindows = new Map();
+    deferredApplicationPages = new Map();
     volatileContext = '';
     volatilePullCursorValue = '';
     volatileSeenMessages = new Map();
@@ -149,10 +593,143 @@ export class MessageDeliveryEngine {
     constructor(runtime) {
         this.runtime = runtime;
     }
+    beginApplicationPage(namespace, source = 'pull', reservation) {
+        const client = this.runtime.client;
+        if (typeof client._dispatcher?._snapshotApplicationHandlers !== 'function')
+            return undefined;
+        const generation = this.captureInlineGeneration();
+        const runtimeGeneration = Number(client._v2RuntimeGeneration ?? 0);
+        const namespaceGeneration = this.captureSeqNamespaceGeneration(namespace);
+        let resolve;
+        let reject;
+        const done = new Promise((yes, no) => { resolve = yes; reject = no; });
+        void done.catch(() => { });
+        const handlers = client._dispatcher._snapshotApplicationHandlers(Object.values(APPLICATION_EVENT_FAMILIES));
+        const family = namespace.startsWith('group_event:') ? 'group.event_batch' : namespace.startsWith('group:') ? 'group.message_batch' : 'message.batch';
+        return { namespace, source: canonicalDeliverySource(source), handlers, batch: (handlers.get(family)?.length ?? 0) > 0,
+            items: [], effects: [], afterDelivery: [], cleanup: [], claims: new Map(), consumed: new Set(), seen: new Set(), done, resolve, reject, closed: false, flushed: false, deferred: false, reservation,
+            ensureCurrent: () => {
+                if (!this.isSeqNamespaceGenerationCurrent(namespace, namespaceGeneration) || !this.isInlineGenerationCurrent(generation)
+                    || Number(client._v2RuntimeGeneration ?? 0) !== runtimeGeneration
+                    || client._rpcPipeline?.isPullNamespaceCurrent?.(namespace) === false)
+                    throw new StateError('delivery invalidated');
+            } };
+    }
+    async flushApplicationPage(page) {
+        if (!page)
+            return;
+        if (page.flushed)
+            return;
+        if (page.closed)
+            throw new StateError('delivery page closed');
+        if (page.deferred) {
+            page.ensureCurrent();
+            return;
+        }
+        try {
+            page.ensureCurrent();
+            const family = page.items.length > 0 ? APPLICATION_EVENT_FAMILIES[page.items[0].event] : '';
+            const handlers = page.handlers.get(family) ?? [];
+            if (page.batch && page.items.length > 0 && handlers.length > 0) {
+                await this.runtime.client._dispatcher._publishAndWait(family, {
+                    namespace: page.namespace, items: page.items, source: page.source,
+                }, handlers, page.reservation, () => { page.ensureCurrent(); return true; });
+            }
+            page.ensureCurrent();
+            for (const effect of page.effects) {
+                await effect();
+                page.ensureCurrent();
+            }
+            for (const effect of page.afterDelivery) {
+                await effect();
+                page.ensureCurrent();
+            }
+            page.closed = true;
+            page.flushed = true;
+            page.resolve();
+        }
+        catch (error) {
+            this.abortApplicationPage(page, error);
+            throw error;
+        }
+        finally {
+            for (const cleanup of page.cleanup.splice(0))
+                cleanup();
+            for (const key of page.claims.keys())
+                if (this.p2pDeliveryInflight.get(key) === page.done)
+                    this.p2pDeliveryInflight.delete(key);
+        }
+    }
+    abortApplicationPage(page, error) {
+        if (!page || page.closed)
+            return;
+        page.closed = true;
+        page.reject(error);
+        for (const cleanup of page.cleanup.splice(0))
+            cleanup();
+        for (const key of page.claims.keys())
+            if (this.p2pDeliveryInflight.get(key) === page.done)
+                this.p2pDeliveryInflight.delete(key);
+    }
+    deferApplicationEffect(page, effect) {
+        if (page?.batch) {
+            if (page.closed)
+                throw new StateError('delivery page closed');
+            page.effects.push(effect);
+        }
+        else
+            void effect();
+    }
+    deferApplicationAfterDelivery(page, effect) {
+        if (page?.batch) {
+            if (page.closed)
+                throw new StateError('delivery page closed');
+            page.afterDelivery.push(effect);
+        }
+        else
+            void effect();
+    }
+    async applicationOwnership(key, page, operation) {
+        if (page?.batch && page.claims.has(key))
+            return undefined;
+        for (;;) {
+            const pending = this.p2pDeliveryInflight.get(key);
+            if (!pending)
+                break;
+            await pending;
+            page?.ensureCurrent();
+        }
+        if (page?.batch) {
+            if (page.closed)
+                throw new StateError('delivery page closed');
+            page.claims.set(key, { sender_aid: '', message_id: '' });
+            this.p2pDeliveryInflight.set(key, page.done);
+            return await operation();
+        }
+        const task = Promise.resolve().then(operation);
+        const owner = task.then(() => undefined);
+        this.p2pDeliveryInflight.set(key, owner);
+        try {
+            return await task;
+        }
+        finally {
+            if (this.p2pDeliveryInflight.get(key) === owner)
+                this.p2pDeliveryInflight.delete(key);
+            void owner.catch(() => { });
+        }
+    }
     resetInlineAckState() {
         this.syncStopped('aborted');
         this.inlineGeneration += 1;
         this.deliveryGeneration += 1;
+        this.peerRecoveries.clear();
+        this.peerPendingSeqHints.clear();
+        this.peerPendingConfirmedThrough.clear();
+        this.peerDirectoryDirty = false;
+        this.peerDirectoryRefreshing = false;
+        if (this.peerRecoveryTimer !== null)
+            clearTimeout(this.peerRecoveryTimer);
+        this.peerRecoveryTimer = null;
         this.pendingPullDeliveryChanges = null;
         void this.runtime.client._rpcPipeline?.invalidatePulls?.();
         this.realtimeSyncing = null;
@@ -161,12 +738,21 @@ export class MessageDeliveryEngine {
         this.pendingPullNoProgressAcks = null;
         this.onlineUnreadHintTargets = null;
         this.onlineUnreadHintOwners = null;
+        this.backgroundPullDemands.clear();
+        if (this.backgroundPullTimer !== null)
+            clearTimeout(this.backgroundPullTimer);
+        this.backgroundPullTimer = null;
+        this.backgroundPullRecoveryQueued = false;
         this.realtimeTailResults = null;
         this.realtimeAcking = null;
         this.pendingP2PInlineAcks = null;
         this.pendingGroupInlineAcks = null;
         this.pendingGroupInlineAckNamespaces = null;
         this.pendingTailWindows.clear();
+        for (const pages of this.deferredApplicationPages.values())
+            for (const page of new Set(pages.values()))
+                this.abortApplicationPage(page, new StateError('delivery invalidated'));
+        this.deferredApplicationPages.clear();
         this.syncingNamespaces.clear();
         this.syncSessions.clear();
     }
@@ -189,34 +775,57 @@ export class MessageDeliveryEngine {
     captureInlineGeneration() {
         return this.inlineGeneration;
     }
-    deferTailWindow(ns, proof) {
+    deferTailWindow(ns, proof, page) {
         const tracker = new SeqTracker();
         tracker.restoreNamespaceSnapshot(ns, this.runtime.client._seqTracker.snapshotNamespace(ns));
         tracker.commitTailWindow(ns, proof);
+        if (page)
+            page.tailProof = proof;
         this.pendingTailWindows.set(ns, proof);
     }
+    pendingTailProofs(ns) {
+        const proofs = new Set();
+        const latest = this.pendingTailWindows.get(ns);
+        if (latest)
+            proofs.add(latest);
+        for (const page of this.deferredApplicationPages.get(ns)?.values() ?? [])
+            if (page.tailProof)
+                proofs.add(page.tailProof);
+        return [...proofs].sort((a, b) => a.windowStartSeq - b.windowStartSeq);
+    }
     prospectiveTailState(ns) {
-        const proof = this.pendingTailWindows.get(ns);
-        if (!proof)
+        const proofs = this.pendingTailProofs(ns);
+        if (proofs.length === 0)
             return this.syncState(ns);
         const tracker = new SeqTracker();
         tracker.restoreNamespaceSnapshot(ns, this.runtime.client._seqTracker.snapshotNamespace(ns));
-        tracker.commitTailWindow(ns, proof);
+        for (const proof of proofs)
+            tracker.commitTailWindow(ns, proof);
         return tracker.getSyncState(ns);
     }
     pendingTailDeliveryThrough(ns, scanThrough) {
-        const proof = this.pendingTailWindows.get(ns);
-        return proof && scanThrough >= proof.windowStartSeq - 1 ? Math.max(scanThrough, proof.headSeq) : scanThrough;
+        for (const proof of this.pendingTailProofs(ns))
+            if (scanThrough >= proof.windowStartSeq - 1)
+                scanThrough = Math.max(scanThrough, proof.headSeq);
+        return scanThrough;
     }
     commitPendingTailWindow(ns, scanThrough) {
-        const proof = this.pendingTailWindows.get(ns);
-        if (proof && scanThrough >= proof.windowStartSeq - 1)
-            this.runtime.client._seqTracker.commitTailWindow(ns, proof);
+        for (const proof of this.pendingTailProofs(ns))
+            if (scanThrough >= proof.windowStartSeq - 1) {
+                this.runtime.client._seqTracker.commitTailWindow(ns, proof);
+                scanThrough = Math.max(scanThrough, proof.headSeq);
+            }
     }
     completePendingTailWindow(ns) {
         const proof = this.pendingTailWindows.get(ns);
         if (proof && this.runtime.client._seqTracker.getContiguousSeq(ns) >= proof.headSeq)
             this.pendingTailWindows.delete(ns);
+        const pages = this.deferredApplicationPages.get(ns);
+        for (const [seq, page] of pages ?? [])
+            if (page.flushed && seq <= this.runtime.client._seqTracker.getContiguousSeq(ns))
+                pages.delete(seq);
+        if (pages?.size === 0)
+            this.deferredApplicationPages.delete(ns);
     }
     beginRealtimeSync(ns) {
         if (!ns || this.realtimeSyncing?.has(ns))
@@ -326,9 +935,116 @@ export class MessageDeliveryEngine {
         if (!ns)
             return;
         this.schedulePendingPullIfNeeded(ns, 'pull-gate-idle');
+        this.requestBackgroundPullRecovery();
+    }
+    recordBackgroundPullDemand(ns, throughSeq = 0, probe = false) {
+        const demand = this.backgroundPullDemands.get(ns) ?? {
+            throughSeq: 0, hasMore: false, probe: false, afterSeq: -1, retryAt: 0,
+        };
+        demand.throughSeq = Math.max(demand.throughSeq, positiveSafeSequenceHint(throughSeq));
+        demand.probe ||= probe;
+        this.backgroundPullDemands.set(ns, demand);
+        return demand;
+    }
+    observeBackgroundPullResponse(ns, afterSeq, result, limit = 50) {
+        if (!ns || this.runtime.client._sessionOptions?.background_sync === false)
+            return;
+        const cursor = isJsonObject(result.cursor) ? result.cursor : null;
+        const rows = Array.isArray(result.messages) ? result.messages : Array.isArray(result.events) ? result.events : [];
+        let throughSeq = Math.max(positiveSafeSequenceHint(cursor?.latest_seq), positiveSafeSequenceHint(result.latest_seq), positiveSafeSequenceHint(result.latest_message_seq), positiveSafeSequenceHint(result.latest_event_seq));
+        for (const row of rows) {
+            if (!isJsonObject(row) || this.isVolatileMessage(row))
+                continue;
+            throughSeq = Math.max(throughSeq, positiveSafeSequenceHint(row.seq ?? row.event_seq));
+        }
+        const demand = this.recordBackgroundPullDemand(ns, throughSeq);
+        if (afterSeq >= demand.afterSeq) {
+            demand.afterSeq = afterSeq;
+            demand.hasMore = result.has_more === true
+                || positiveSafeSequenceHint(result.remaining) > 0
+                || (!Object.prototype.hasOwnProperty.call(result, 'has_more') && limit > 0 && rows.length >= limit);
+            demand.probe = false;
+        }
+        this.requestBackgroundPullRecovery();
+    }
+    finishBackgroundPull(ns, afterSeq, failed) {
+        const demand = this.backgroundPullDemands.get(ns);
+        if (demand) {
+            const state = this.syncState(ns);
+            const ack = state.ack;
+            if (ack < state.tail - 1)
+                demand.throughSeq = Math.max(demand.throughSeq, state.tail - 1);
+            demand.probe = failed;
+            if (!demand.probe && !demand.hasMore && ack >= demand.throughSeq)
+                this.backgroundPullDemands.delete(ns);
+            else
+                demand.retryAt = failed || ack <= afterSeq || ack <= (this.pendingPullNoProgressAcks?.get(ns) ?? -1)
+                    ? Date.now() + P2P_GAP_FILL_RETRY_BASE_MS
+                    : 0;
+        }
+        this.requestBackgroundPullRecovery();
+    }
+    requestBackgroundPullRecovery() {
+        this.requestPeerRecovery();
+        if (this.runtime.client._p2pPeerPullEnabled && this.peerDirectoryDirty)
+            this.requestPeerDirectoryRefresh();
+        if (this.backgroundPullRecoveryQueued)
+            return;
+        const generation = this.captureInlineGeneration();
+        this.backgroundPullRecoveryQueued = true;
+        void Promise.resolve().then(() => {
+            if (!this.isInlineGenerationCurrent(generation))
+                return;
+            this.backgroundPullRecoveryQueued = false;
+            const client = this.runtime.client;
+            if (!client._aid || client._sessionOptions?.background_sync === false
+                || client.state !== ConnectionState.READY || client._closing)
+                return;
+            if (this.backgroundPullTimer !== null)
+                clearTimeout(this.backgroundPullTimer);
+            this.backgroundPullTimer = null;
+            let retryAt = 0;
+            for (const [ns, demand] of this.backgroundPullDemands) {
+                if (ns.startsWith('p2p:') && ns !== `p2p:${client._aid}`)
+                    continue;
+                const dedupKey = ns.startsWith('p2p:') ? `p2p_pull:${ns}`
+                    : ns.startsWith('group_event:') ? `group_event_pull:${ns}` : `group_pull:${ns}`;
+                if (client._gapFillDone.has(dedupKey) || this.onlineUnreadHintOwners?.has(ns)
+                    || this.realtimeSyncing?.has(ns) || client._rpcPipeline?.hasPullActivity?.(ns, false))
+                    continue;
+                const ack = this.syncState(ns).ack;
+                if (!demand.probe && !demand.hasMore && ack >= demand.throughSeq) {
+                    this.backgroundPullDemands.delete(ns);
+                    continue;
+                }
+                if (demand.retryAt > Date.now()) {
+                    retryAt = retryAt === 0 ? demand.retryAt : Math.min(retryAt, demand.retryAt);
+                    continue;
+                }
+                if (ns.startsWith('p2p:'))
+                    client._safeAsync(this.fillP2pGap());
+                else if (ns.startsWith('group_event:'))
+                    client._safeAsync(this.fillGroupEventGap(ns.slice('group_event:'.length)));
+                else if (ns.startsWith('group:'))
+                    client._safeAsync(this.fillGroupGap(ns.slice('group:'.length)));
+            }
+            if (retryAt > 0) {
+                this.backgroundPullTimer = globalThis.setTimeout(() => {
+                    this.backgroundPullTimer = null;
+                    if (this.isInlineGenerationCurrent(generation))
+                        this.requestBackgroundPullRecovery();
+                }, Math.max(0, retryAt - Date.now()));
+            }
+        });
     }
     onForegroundPullsDrained() {
+        this.requestBackgroundPullRecovery();
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled) {
+            if (this.peerDirectoryDirty)
+                this.requestPeerDirectoryRefresh();
+            return;
+        }
         if (!client._aid || client._sessionOptions?.background_sync === false
             || client.state !== ConnectionState.READY || client._closing)
             return;
@@ -340,6 +1056,7 @@ export class MessageDeliveryEngine {
         client._safeAsync(this.fillP2pGap());
     }
     onPullWorkSettled() {
+        this.requestBackgroundPullRecovery();
         const pipeline = this.runtime.client._rpcPipeline;
         if (pipeline?.hasAnyPullActivity?.() === true)
             return;
@@ -537,7 +1254,12 @@ export class MessageDeliveryEngine {
             client._pushedSeqs.set(ns, new Set(keep));
         }
     }
-    markPublishedSeq(ns, seq) {
+    markPublishedSeq(ns, seq, page) {
+        if (page?.batch) {
+            page.consumed.add(seq);
+            this.deferApplicationEffect(page, () => this.markPublishedSeq(ns, seq));
+            return;
+        }
         const client = this.runtime.client;
         let pushed = client._pushedSeqs.get(ns);
         if (!pushed) {
@@ -984,12 +1706,12 @@ export class MessageDeliveryEngine {
             throw new Error(`${method} response must be an object`);
         }
         const client = this.runtime.client;
+        this.rememberCommittedSeqState(ns);
+        const namespaceGeneration = this.captureSeqNamespaceGeneration(ns);
         this.ensurePullOperationCurrent(ns);
+        const applicationPage = this.beginApplicationPage(ns);
         const response = result;
         const volatileMessages = this.volatileMessages(response.messages);
-        if (method === 'message.pull' && volatileMessages.length > 0) {
-            await this.publishPlainVolatileMessages(volatileMessages, 'pull', true);
-        }
         const messages = deduplicatePlainForwardPageMessages(response.messages, afterSeq);
         const coordinator = this.forwardCoordinator();
         const pageContigBefore = client._seqTracker.getContiguousSeq(ns);
@@ -1016,12 +1738,14 @@ export class MessageDeliveryEngine {
         let publishedCount = 0;
         let committed = false;
         try {
+            if (method === 'message.pull' && volatileMessages.length > 0)
+                await this.publishPlainVolatileMessages(volatileMessages, 'pull', true, applicationPage);
             for (const rawMessage of messages) {
                 this.ensurePullOperationCurrent(ns);
                 const seq = positiveSafeSequenceHint(rawMessage.seq);
                 if (method === 'message.pull') {
                     const appEvent = p2pAppEventFromPlainPullMessage(rawMessage);
-                    if (await this.publishPulledMessage(appEvent.event, ns, seq, appEvent.payload, false)) {
+                    if (await this.publishPulledMessage(appEvent.event, ns, seq, appEvent.payload, false, 'pull', undefined, applicationPage)) {
                         publishedCount += 1;
                     }
                     this.ensurePullOperationCurrent(ns);
@@ -1029,16 +1753,16 @@ export class MessageDeliveryEngine {
                 }
                 const message = normalizeGroupMentionMode(rawMessage);
                 if (this.recallEventFromGroupMessage(message)) {
-                    if (await this.publishGroupRecallTombstone(groupId, seq, message, 'pull')) {
+                    if (await this.publishGroupRecallTombstone(groupId, seq, message, 'pull', applicationPage)) {
                         this.ensurePullOperationCurrent(ns);
-                        this.markPublishedSeq(ns, seq);
+                        this.markPublishedSeq(ns, seq, applicationPage);
                         publishedCount += 1;
                     }
                 }
                 else if (this.isSelfSentGroupMessage(message)) {
-                    this.markPublishedSeq(ns, seq);
+                    this.markPublishedSeq(ns, seq, applicationPage);
                 }
-                else if (await this.publishPulledMessage('group.message_created', ns, seq, message, false)) {
+                else if (await this.publishPulledMessage('group.message_created', ns, seq, message, false, 'pull', undefined, applicationPage)) {
                     this.ensurePullOperationCurrent(ns);
                     publishedCount += 1;
                 }
@@ -1050,10 +1774,13 @@ export class MessageDeliveryEngine {
             const scanThrough = Math.max(pageContigBefore, contiguousSeq ?? 0, retentionFloor, visibilityFloor, deferredServerCursor, ...messages.map((message) => positiveSafeSequenceHint(message.seq)));
             const state = this.syncState(ns);
             const deliveryThrough = this.pendingTailDeliveryThrough(ns, scanThrough >= state.tail - 1 ? Math.max(scanThrough, state.head) : scanThrough);
-            await this.drainOrderedMessages(ns, undefined, false, false, undefined, 'pull', deliveryThrough);
+            await this.drainOrderedMessages(ns, undefined, false, false, undefined, 'pull', deliveryThrough, applicationPage);
+            await this.flushApplicationPage(applicationPage);
             this.ensurePullOperationCurrent(ns);
             if (!this.isInlineGenerationCurrent(pageInlineGeneration))
                 throw new Error('pull invalidated');
+            if (!this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
+                throw new Error('pull invalidated');
             pageTrackerSnapshot = client._seqTracker.snapshotNamespace(ns);
             this.commitPendingTailWindow(ns, scanThrough);
             if (contiguousSeq === undefined)
@@ -1068,14 +1795,16 @@ export class MessageDeliveryEngine {
                 this.ensurePullOperationCurrent(ns);
                 await client._commitSeqTrackerState(ns);
                 this.ensurePullOperationCurrent(ns);
-                if (!this.isInlineGenerationCurrent(pageInlineGeneration))
+                if (!this.isInlineGenerationCurrent(pageInlineGeneration) || !this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
                     throw new Error('pull invalidated');
             }
             this.completePendingTailWindow(ns);
             committed = true;
         }
         catch (exc) {
+            this.abortApplicationPage(applicationPage, exc);
             if (this.isPullOperationCurrent(ns) && this.isInlineGenerationCurrent(pageInlineGeneration)
+                && this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration)
                 && pageTrackerSnapshot !== undefined && !committed && typeof client._seqTracker.restoreNamespaceSnapshot === 'function') {
                 client._seqTracker._restoreNamespaceSnapshotPreservingPush(ns, pageTrackerSnapshot);
                 this.dropSeqTrackerPending(ns);
@@ -1138,49 +1867,73 @@ export class MessageDeliveryEngine {
     isGroupEventNamespace(ns) {
         return ns.startsWith('group_event:');
     }
-    async publishOrderedQueueItem(ns, event, seq, payload, pullResponse = false, source = 'push', batch) {
+    async publishOrderedQueueItem(ns, event, seq, payload, pullResponse = false, source = 'push', batch, page) {
         const client = this.runtime.client;
         const pullScoped = this.isPullScopedSource(source);
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
         if (event === 'group.changed' && this.isGroupEventNamespace(ns)) {
-            await this.publishOrderedGroupChanged(payload, source);
+            await this.publishOrderedGroupChanged(payload, source, page, ns);
             if (pullScoped)
                 this.ensurePullOperationCurrent(ns);
             return;
         }
         if (event === 'message.recalled') {
-            await this.publishMessageRecallTombstone(seq, payload, source);
+            await this.publishMessageRecallTombstone(seq, payload, source, page);
             if (pullScoped)
                 this.ensurePullOperationCurrent(ns);
             return;
         }
         if (pullResponse) {
-            await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
+            await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch, page));
             if (pullScoped)
                 this.ensurePullOperationCurrent(ns);
             return;
         }
-        await client._publishAppEvent(event, payload, source, ns, batch);
+        await client._publishAppEvent(event, payload, source, ns, batch, page);
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
     }
-    async publishOrderedGroupChanged(payload, source = 'ordered') {
+    async publishOrderedGroupChanged(payload, source = 'ordered', page, ns = '', owned = false) {
         const client = this.runtime.client;
+        if (!owned && isJsonObject(payload) && Number.isSafeInteger(payload.event_seq) && Number(payload.event_seq) > 0) {
+            const key = JSON.stringify([this.peerContext(), 'group.changed.action', ns || this.applicationNamespace('group.changed', payload), payload.event_seq]);
+            const batchActive = page ? page.batch : (client._dispatcher?._snapshotApplicationHandlers?.(['group.event_batch']).get('group.event_batch')?.length ?? 0) > 0;
+            if (batchActive || this.p2pDeliveryInflight.has(key)) {
+                await this.applicationOwnership(key, page, async () => {
+                    if (this.p2pDeliveryCompleted.has(key))
+                        return;
+                    await this.publishOrderedGroupChanged(payload, source, page, ns, true);
+                    this.deferApplicationEffect(page, () => {
+                        this.p2pDeliveryCompleted.set(key, { sender_aid: '', message_id: '' });
+                        if (this.p2pDeliveryCompleted.size > PUSHED_SEQS_LIMIT)
+                            this.p2pDeliveryCompleted.delete(this.p2pDeliveryCompleted.keys().next().value);
+                    });
+                });
+                return;
+            }
+        }
         const generation = this.captureInlineGeneration();
-        await client._publishAppEvent('group.changed', payload, source);
+        await client._publishAppEvent('group.changed', payload, source, ns, undefined, page);
         if (!this.isInlineGenerationCurrent(generation))
             throw new Error('pull invalidated');
-        if (isJsonObject(payload)) {
-            const eventPayload = payload;
-            client._groupState?.handleGroupChangedV2Membership?.(eventPayload);
-            if (eventPayload.action === 'dissolved') {
-                const rawGroupId = eventPayload.group_id ?? eventPayload.group_aid ?? '';
-                const groupId = String(rawGroupId).trim();
-                if (groupId)
-                    client._cleanupDissolvedGroup?.(groupId);
+        this.deferApplicationEffect(page, () => {
+            if (isJsonObject(payload)) {
+                const eventPayload = payload;
+                client._groupState?.handleGroupChangedV2Membership?.(eventPayload);
+                if (eventPayload.action === 'dissolved') {
+                    const rawGroupId = eventPayload.group_id ?? eventPayload.group_aid ?? '';
+                    const groupId = String(rawGroupId).trim();
+                    if (groupId) {
+                        if (page)
+                            page.cleanup.push(() => { if (page.flushed)
+                                client._cleanupDissolvedGroup?.(groupId); });
+                        else
+                            client._cleanupDissolvedGroup?.(groupId);
+                    }
+                }
             }
-        }
+        });
     }
     isInstanceScopedMessageEvent(event) {
         return event === 'message.received'
@@ -1297,6 +2050,7 @@ export class MessageDeliveryEngine {
         if (protectedHeaders)
             envelope.protected_headers = protectedHeaders;
         setIfPresent('payload_type', firstValue(message.payload_type, protectedHeaders?.payload_type));
+        setIfPresent('need_render', message.need_render !== false);
         setIfPresent('mention_mode', message.mention_mode);
         return envelope;
     }
@@ -1365,6 +2119,7 @@ export class MessageDeliveryEngine {
         if (protectedHeaders)
             envelope.protected_headers = protectedHeaders;
         setIfPresent('payload_type', firstValue(params.payload_type, protectedHeaders?.payload_type, body.type));
+        setIfPresent('need_render', params.need_render !== false);
         if (method === 'group.send')
             setIfPresent('mention_mode', resultObj.mention_mode);
         return envelope;
@@ -1510,7 +2265,7 @@ export class MessageDeliveryEngine {
         const sender = String(message.from_aid ?? message.from ?? '').trim();
         const messageId = String(message.message_id ?? '').trim();
         const cursor = String(message.volatile_cursor ?? '').trim();
-        return `${sender}|${messageId || cursor}`;
+        return `${sender}|${messageId}|${cursor}`;
     }
     isVolatileSeen(message) {
         this.ensureVolatileContext();
@@ -1521,7 +2276,12 @@ export class MessageDeliveryEngine {
         }
         return this.volatileSeenMessages.has(this.volatileSeenKey(message));
     }
-    markVolatileSeen(message) {
+    markVolatileSeen(message, page) {
+        if (page?.batch) {
+            page.seen.add(`volatile:${this.volatileSeenKey(message)}`);
+            this.deferApplicationEffect(page, () => this.markVolatileSeen(message));
+            return;
+        }
         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);
@@ -1533,16 +2293,37 @@ export class MessageDeliveryEngine {
             this.volatileSeenMessages.delete(oldest);
         }
     }
-    beginVolatileDelivery(message) {
+    async waitVolatileApplicationDelivery(message, page) {
+        const key = JSON.stringify([this.peerContext(), 'volatile', this.volatileSeenKey(message)]);
+        if (page?.claims.has(key))
+            return;
+        const pending = this.p2pDeliveryInflight.get(key);
+        if (pending) {
+            await pending;
+            page?.ensureCurrent();
+        }
+    }
+    beginVolatileDelivery(message, page) {
+        if (page?.seen.has(`volatile:${this.volatileSeenKey(message)}`))
+            return 'seen';
         if (this.isVolatileSeen(message))
             return 'seen';
         const key = this.volatileSeenKey(message);
         if (this.volatileInFlightMessages.has(key))
             return 'inflight';
         this.volatileInFlightMessages.add(key);
+        if (page?.batch) {
+            const ownerKey = JSON.stringify([this.peerContext(), 'volatile', key]);
+            page.claims.set(ownerKey, { sender_aid: '', message_id: '' });
+            this.p2pDeliveryInflight.set(ownerKey, page.done);
+        }
         return 'claimed';
     }
-    finishVolatileDelivery(message) {
+    finishVolatileDelivery(message, page) {
+        if (page?.batch) {
+            page.cleanup.push(() => this.finishVolatileDelivery(message));
+            return;
+        }
         this.ensureVolatileContext();
         this.volatileInFlightMessages.delete(this.volatileSeenKey(message));
     }
@@ -1551,7 +2332,11 @@ export class MessageDeliveryEngine {
         delete result.seq;
         return result;
     }
-    async ackVolatileMessages(messages, v2, advanceCursor) {
+    async ackVolatileMessages(messages, v2, advanceCursor, page) {
+        if (page?.batch) {
+            this.deferApplicationAfterDelivery(page, async () => { await this.ackVolatileMessages(messages, v2, advanceCursor); });
+            return undefined;
+        }
         const cursors = [...new Set(messages
                 .map((item) => String(item.volatile_cursor ?? '').trim())
                 .filter(Boolean))];
@@ -1565,11 +2350,12 @@ export class MessageDeliveryEngine {
         }
         return result;
     }
-    async publishPlainVolatileMessages(messages, source, advanceCursor) {
+    async publishPlainVolatileMessages(messages, source, advanceCursor, page) {
         const processed = [];
         for (const rawMessage of messages) {
             const message = this.publicVolatileMessage(rawMessage);
-            const claim = this.beginVolatileDelivery(message);
+            await this.waitVolatileApplicationDelivery(message, page);
+            const claim = this.beginVolatileDelivery(message, page);
             if (claim === 'seen') {
                 processed.push(rawMessage);
                 continue;
@@ -1578,16 +2364,16 @@ export class MessageDeliveryEngine {
                 continue;
             try {
                 const appEvent = this.p2pAppEventForMessage(message);
-                await this.runtime.client._publishAppEvent(appEvent.event, appEvent.payload, source);
-                this.markVolatileSeen(message);
+                await this.runtime.client._publishAppEvent(appEvent.event, appEvent.payload, source, page?.namespace ?? '', undefined, page);
+                this.markVolatileSeen(message, page);
             }
             finally {
-                this.finishVolatileDelivery(message);
+                this.finishVolatileDelivery(message, page);
             }
             processed.push(rawMessage);
         }
         if (processed.length > 0)
-            await this.ackVolatileMessages(processed, false, advanceCursor);
+            await this.ackVolatileMessages(processed, false, advanceCursor, page);
         return processed.map((item) => this.publicVolatileMessage(item));
     }
     messageRecallDedupKey(payload) {
@@ -1616,31 +2402,36 @@ export class MessageDeliveryEngine {
             return `p2p|tombstone:${tombstoneId}`;
         return `p2p|unknown:${Date.now()}:${Math.random()}`;
     }
-    async publishMessageRecallTombstone(seq, message, source = 'push') {
+    async publishMessageRecallTombstone(seq, message, source = 'push', page, owned = false) {
         const client = this.runtime.client;
         const generation = this.captureInlineGeneration();
         const eventPayload = this.recallEventFromMessage(message);
         if (!eventPayload)
             return false;
         const dedupKey = this.messageRecallDedupKey(eventPayload);
+        if (!owned)
+            return await this.applicationOwnership(JSON.stringify([this.peerContext(), 'message.recalled', dedupKey]), page, () => this.publishMessageRecallTombstone(seq, message, source, page, true)) ?? false;
         let seen = client._messageRecallSeen;
         if (!seen) {
             seen = new Map();
             client._messageRecallSeen = seen;
         }
-        if (seen.has(dedupKey)) {
+        if (seen.has(dedupKey) || page?.seen.has(`message.recalled:${dedupKey}`)) {
             client._clientLog.debug(`message.recalled dedup suppressed: seq=${String(seq)} key=${dedupKey}`);
             return false;
         }
-        await client._publishAppEvent('message.recalled', eventPayload, source);
+        await client._publishAppEvent('message.recalled', eventPayload, source, page?.namespace ?? '', undefined, page);
         if (!this.isInlineGenerationCurrent(generation))
             throw new Error('pull invalidated');
-        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);
-        }
+        page?.seen.add(`message.recalled:${dedupKey}`);
+        this.deferApplicationEffect(page, () => {
+            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);
+            }
+        });
         client._clientLog.debug(`message.recalled published: seq=${String(seq)} ids=${JSON.stringify(eventPayload.message_ids)}`);
         return true;
     }
@@ -1723,7 +2514,7 @@ export class MessageDeliveryEngine {
             return `${normalizedGroupId}|tombstone:${tombstoneId}`;
         return `${normalizedGroupId}|unknown:${Date.now()}:${Math.random()}`;
     }
-    async publishGroupRecallTombstone(groupId, seq, message, source = 'push') {
+    async publishGroupRecallTombstone(groupId, seq, message, source = 'push', page, owned = false) {
         const client = this.runtime.client;
         const generation = this.captureInlineGeneration();
         const eventPayload = this.recallEventFromGroupMessage(message);
@@ -1732,24 +2523,29 @@ export class MessageDeliveryEngine {
         const rawGroupId = String(eventPayload.group_id ?? groupId ?? '').trim();
         const dedupGroupId = rawGroupId;
         const dedupKey = this.groupRecallDedupKey(dedupGroupId, eventPayload);
+        if (!owned)
+            return await this.applicationOwnership(JSON.stringify([this.peerContext(), 'group.message_recalled', dedupKey]), page, () => this.publishGroupRecallTombstone(groupId, seq, message, source, page, true)) ?? false;
         let seen = client._groupRecallSeen;
         if (!seen) {
             seen = new Map();
             client._groupRecallSeen = seen;
         }
-        if (seen.has(dedupKey)) {
+        if (seen.has(dedupKey) || page?.seen.has(`group.message_recalled:${dedupKey}`)) {
             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);
+        await client._publishAppEvent('group.message_recalled', eventPayload, source, page?.namespace ?? '', undefined, page);
         if (!this.isInlineGenerationCurrent(generation))
             throw new Error('pull invalidated');
-        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);
-        }
+        page?.seen.add(`group.message_recalled:${dedupKey}`);
+        this.deferApplicationEffect(page, () => {
+            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);
+            }
+        });
         client._clientLog.debug(`group.message_recalled published: group=${groupId} seq=${String(seq)} ids=${JSON.stringify(eventPayload.message_ids)}`);
         return true;
     }
@@ -1791,9 +2587,139 @@ export class MessageDeliveryEngine {
             client._safeAsync(this.fillGroupGap(groupId));
         await this.publishGroupRecallTombstone(groupId, seq, wrapped);
     }
-    async publishAppEvent(event, payload, source = 'direct', ns = '', batch) {
+    async publishAppEvent(event, payload, source = 'direct', ns = '', batch, page) {
         const client = this.runtime.client;
+        const seq = isJsonObject(payload) ? payload.seq : undefined;
+        const groupSeq = isJsonObject(payload) && event === 'group.changed' ? payload.event_seq : seq;
+        if ((event === 'group.message_created' || event === 'group.changed') && source !== 'history'
+            && isJsonObject(payload) && !this.isVolatileMessage(payload) && Number.isSafeInteger(groupSeq) && Number(groupSeq) > 0) {
+            const groupNs = ns || this.applicationNamespace(event, payload);
+            const key = JSON.stringify([this.peerContext(), event, groupNs, groupSeq]);
+            const family = APPLICATION_EVENT_FAMILIES[event];
+            const batchActive = page ? page.batch : (client._dispatcher?._snapshotApplicationHandlers?.([family]).get(family)?.length ?? 0) > 0;
+            if (batchActive || this.p2pDeliveryInflight.has(key)) {
+                await this.applicationOwnership(key, page, async () => {
+                    if (this.p2pDeliveryCompleted.has(key))
+                        return;
+                    await this.publishAppEventInternal(event, payload, source, ns, batch, page);
+                    this.deferApplicationEffect(page, () => {
+                        this.p2pDeliveryCompleted.set(key, { sender_aid: String(payload.from ?? ''), message_id: String(payload.message_id ?? '') });
+                        if (this.p2pDeliveryCompleted.size > PUSHED_SEQS_LIMIT)
+                            this.p2pDeliveryCompleted.delete(this.p2pDeliveryCompleted.keys().next().value);
+                    });
+                });
+                return;
+            }
+        }
+        if (!client._p2pPeerPullEnabled || event !== 'message.received' || source === 'history'
+            || !isJsonObject(payload) || this.isVolatileMessage(payload) || !Number.isSafeInteger(seq) || Number(seq) <= 0) {
+            return await this.publishAppEventInternal(event, payload, source, ns, batch, page);
+        }
+        const context = this.peerContext();
+        const generation = this.captureInlineGeneration();
+        const aid = client._aid;
+        const deviceId = client._deviceId;
+        const slotId = client._slotId;
+        const ensureCurrent = () => {
+            if (client._aid !== aid || client._deviceId !== deviceId || client._slotId !== slotId
+                || this.peerContext() !== context || !this.isInlineGenerationCurrent(generation))
+                throw new StateError('delivery invalidated');
+        };
+        const sender = String(payload.sender_aid ?? payload.from_aid ?? payload.from ?? '');
+        if (!sender)
+            return await this.publishAppEventInternal(event, payload, source, ns, batch, page);
+        const key = JSON.stringify([context, event, seq]);
+        const receipt = { sender_aid: sender, message_id: String(payload.message_id ?? '') };
+        const validate = (saved, expected = receipt) => {
+            if (saved.sender_aid !== expected.sender_aid || (saved.message_id && expected.message_id && saved.message_id !== expected.message_id))
+                throw new ValidationError('delivery receipt identity conflict');
+        };
+        const local = page?.batch ? page.claims.get(key) : undefined;
+        if (local) {
+            validate(local);
+            if (!local.message_id)
+                local.message_id = receipt.message_id;
+            return;
+        }
+        for (;;) {
+            const inflight = this.p2pDeliveryInflight.get(key);
+            if (!inflight)
+                break;
+            await inflight;
+            ensureCurrent();
+            const completed = this.p2pDeliveryCompleted.get(key);
+            if (completed)
+                validate(completed);
+            if (completed?.message_id || !receipt.message_id)
+                return;
+        }
+        if (page?.batch) {
+            page.ensureCurrent();
+            if (page.closed || (ns && ns !== page.namespace))
+                throw new StateError('delivery page invalidated');
+            const completed = this.p2pDeliveryCompleted.get(key);
+            if (completed) {
+                validate(completed);
+                if (!completed.message_id && receipt.message_id)
+                    this.deferApplicationEffect(page, () => { completed.message_id = receipt.message_id; });
+                return;
+            }
+            page.claims.set(key, receipt);
+            this.p2pDeliveryInflight.set(key, page.done);
+            await this.publishAppEventInternal(event, payload, source, ns, batch, page);
+            this.deferApplicationEffect(page, () => {
+                this.p2pDeliveryCompleted.set(key, { ...receipt });
+                if (this.p2pDeliveryCompleted.size > PUSHED_SEQS_LIMIT)
+                    this.p2pDeliveryCompleted.delete(this.p2pDeliveryCompleted.keys().next().value);
+            });
+            return;
+        }
+        const task = Promise.resolve().then(async () => {
+            ensureCurrent();
+            let pending = this.p2pDeliveryCompleted.get(key);
+            if (pending)
+                validate(pending);
+            if (!pending) {
+                await this.publishAppEventInternal(event, payload, source, ns, batch, page);
+                ensureCurrent();
+                pending = { ...receipt };
+                this.p2pDeliveryCompleted.set(key, pending);
+            }
+            else if (!pending.message_id && receipt.message_id) {
+                pending = { ...receipt };
+                this.p2pDeliveryCompleted.set(key, pending);
+            }
+            if (this.p2pDeliveryCompleted.size > PUSHED_SEQS_LIMIT) {
+                const oldest = this.p2pDeliveryCompleted.keys().next().value;
+                if (oldest !== undefined)
+                    this.p2pDeliveryCompleted.delete(oldest);
+            }
+        });
+        this.p2pDeliveryInflight.set(key, task);
+        try {
+            await task;
+        }
+        finally {
+            if (this.p2pDeliveryInflight.get(key) === task)
+                this.p2pDeliveryInflight.delete(key);
+        }
+    }
+    async publishAppEventInternal(event, payload, source = 'direct', ns = '', batch, page) {
+        const client = this.runtime.client;
+        const family = APPLICATION_EVENT_FAMILIES[event];
+        const handlers = page?.handlers ?? (family ? client._dispatcher._snapshotApplicationHandlers?.([event, family]) : undefined);
         const generation = this.deliveryGeneration;
+        const runtimeGeneration = Number(client._v2RuntimeGeneration ?? 0);
+        const namespace = ns || this.applicationNamespace(event, payload);
+        const namespaceGeneration = this.captureSeqNamespaceGeneration(namespace);
+        const guard = () => {
+            page?.ensureCurrent();
+            if (generation !== this.deliveryGeneration || Number(client._v2RuntimeGeneration ?? 0) !== runtimeGeneration
+                || !this.isSeqNamespaceGenerationCurrent(namespace, namespaceGeneration)
+                || client._rpcPipeline?.isPullNamespaceCurrent?.(namespace) === false)
+                throw new StateError('delivery invalidated');
+            return true;
+        };
         if ((event === 'message.received' || event === 'group.message_created') && isJsonObject(payload)) {
             client._maybeAppendEchoTraceReceive(payload);
         }
@@ -1813,6 +2739,8 @@ export class MessageDeliveryEngine {
                 client._clientLog.debug(`agent_md etag inject skipped: ${String(exc)}`);
             }
         }
+        if (client._p2pPeerPullEnabled && generation !== this.deliveryGeneration)
+            throw new StateError('delivery invalidated');
         const canonicalSource = canonicalDeliverySource(source);
         let normalized = this.normalizePublishedMessagePayload(event, payload, source);
         if (isJsonObject(normalized)
@@ -1820,13 +2748,46 @@ export class MessageDeliveryEngine {
             && canonicalSource !== 'direct') {
             normalized = { ...normalized, source: canonicalSource };
         }
-        if (['message.received', 'group.message_created', 'message.recalled', 'group.message_recalled', 'group.changed'].includes(event)
+        if (page?.batch && family) {
+            page.ensureCurrent();
+            if (page.closed || (ns && ns !== page.namespace))
+                throw new StateError('delivery page invalidated');
+            page.items.push({ event, payload: normalized });
+        }
+        else if (family && handlers && !page) {
+            const batchHandlers = handlers.get(family) ?? [];
+            if (batchHandlers.length > 0) {
+                await client._dispatcher._publishAndWait(family, { namespace: ns || this.applicationNamespace(event, payload),
+                    items: [{ event, payload: normalized }], source: canonicalSource }, batchHandlers, undefined, guard);
+            }
+            else
+                await client._dispatcher._publishAndWait(event, normalized, undefined, undefined, guard);
+        }
+        else if (['message.received', 'group.message_created', 'message.recalled', 'group.message_recalled', 'group.changed'].includes(event)
             && typeof client._dispatcher._publishAndWait === 'function') {
-            await client._dispatcher._publishAndWait(event, normalized);
+            await client._dispatcher._publishAndWait(event, normalized, undefined, page?.reservation, guard);
         }
         else {
             client._dispatcher.enqueue(event, normalized);
         }
+        if (page?.batch) {
+            this.deferApplicationEffect(page, () => this.recordApplicationDeliveryChange(event, payload, source, ns, batch, generation));
+            return;
+        }
+        if (family)
+            guard();
+        await this.recordApplicationDeliveryChange(event, payload, source, ns, batch, generation);
+    }
+    applicationNamespace(event, payload) {
+        if (isJsonObject(payload) && event.startsWith('group.'))
+            return `${event === 'group.changed' ? 'group_event' : 'group'}:${String(payload.group_id ?? payload.group_aid ?? '')}`;
+        const client = this.runtime.client;
+        const sender = isJsonObject(payload) ? String(payload.sender_aid ?? payload.from_aid ?? payload.from ?? '') : '';
+        return client._p2pPeerPullEnabled && sender ? this.peerNamespace(sender) : `p2p:${client._aid ?? ''}`;
+    }
+    async recordApplicationDeliveryChange(event, payload, source, ns, batch, generation) {
+        const client = this.runtime.client;
+        const canonicalSource = canonicalDeliverySource(source);
         if (generation !== this.deliveryGeneration)
             return;
         if (canonicalSource !== 'pull' && canonicalSource !== 'pending_retry'
@@ -1974,6 +2935,10 @@ export class MessageDeliveryEngine {
     }
     onRawMessageReceived(data) {
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled) {
+            this.handlePeerNotification(data);
+            return;
+        }
         client._clientLog.debug(`_onRawMessageReceived enter: from=${data?.from ?? '-'} mid=${data?.message_id ?? '-'} seq=${data?.seq ?? '-'}`);
         const ns = isJsonObject(data) && client._aid && data.seq !== undefined
             ? `p2p:${client._aid}`
@@ -2001,6 +2966,11 @@ export class MessageDeliveryEngine {
             msg.type = 'message.recalled';
         if (!this.messageTargetsCurrentInstance(msg))
             return;
+        if (client._p2pPeerPullEnabled) {
+            this.handlePeerNotification(msg);
+            await this.publishMessageRecallTombstone(msg.seq, msg);
+            return;
+        }
         const seq = positiveSafeSequenceHint(msg.seq);
         if (client._aid && seq > 0) {
             const ns = `p2p:${client._aid}`;
@@ -2219,7 +3189,7 @@ export class MessageDeliveryEngine {
         if (client._v2Session) {
             try {
                 const key = client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, after_seq: afterSeq, limit: 50 });
-                await client._rpcPipeline.runPullSerialized(key, () => client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true }), true);
+                await client._rpcPipeline.runPullNamespaceSerialized(key, () => client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true, background: true }), true);
                 return;
             }
             catch (exc) {
@@ -2228,28 +3198,40 @@ export class MessageDeliveryEngine {
                 return;
             }
         }
+        const generation = this.captureInlineGeneration();
+        const dedupKey = `group_pull:${ns}`;
+        this.recordBackgroundPullDemand(ns, positiveSafeSequenceHint(notification.seq), true);
+        if (client._gapFillDone.has(dedupKey))
+            return;
+        client._gapFillDone.add(dedupKey);
         let rawCompleted = false;
+        let failed = false;
         try {
             const key = client._rpcPipeline.pullGateKeyForCall('group.pull', {
                 group_id: groupId,
                 after_message_seq: afterSeq,
                 limit: 50,
             });
-            await client._rpcPipeline.runPullSerialized(key, async () => {
-                const result = await client._rpcPipeline.rawCall('group.pull', {
+            await client._rpcPipeline.runPullNamespaceSerialized(key, async () => {
+                const result = await client._rpcPipeline.runPullSerialized(key, () => client._rpcPipeline.rawCall('group.pull', {
                     group_id: groupId,
                     after_message_seq: afterSeq,
                     device_id: client._deviceId,
                     slot_id: client._slotId,
                     limit: 50,
                     _rpc_background: true,
-                }, { background: true });
+                }, { background: true, pullGateKey: key }), true);
+                if (!this.isInlineGenerationCurrent(generation))
+                    throw new Error('pull invalidated');
                 rawCompleted = true;
+                if (isJsonObject(result))
+                    this.observeBackgroundPullResponse(ns, afterSeq, result, 50);
                 await this.commitPlainForwardPage(ns, afterSeq, 'group.pull', result, groupId);
                 this.prunePushedSeqs(ns);
             }, true);
         }
         catch (exc) {
+            failed = true;
             // 页发布或本地提交失败不能 ACK；提交后 ACK 失败则保留 pending。
             // 两种情况都不能再把原始通知当作第二条业务消息发布。
             client._clientLog.warn(`auto pull group message commit/ack failed:${String(exc)}`);
@@ -2257,6 +3239,12 @@ export class MessageDeliveryEngine {
                 await client._publishAppEvent('group.message_created', notification, 'push');
             }
         }
+        finally {
+            if (this.isInlineGenerationCurrent(generation)) {
+                client._gapFillDone.delete(dedupKey);
+                this.finishBackgroundPull(ns, afterSeq, failed);
+            }
+        }
     }
     scheduleP2pGapRetry(ns, retryAttempt) {
         const client = this.runtime.client;
@@ -2279,7 +3267,12 @@ export class MessageDeliveryEngine {
         }, delayMs);
     }
     async fillP2pGap(retryAttempt = 0) {
+        if (this.runtime.client._p2pPeerPullEnabled) {
+            this.requestPeerDirectoryRefresh();
+            return;
+        }
         const client = this.runtime.client;
+        const generation = this.captureInlineGeneration();
         if (client._sessionOptions?.background_sync === false)
             return;
         if (client.state !== ConnectionState.READY || client._closing)
@@ -2291,9 +3284,11 @@ export class MessageDeliveryEngine {
         const dedupKey = `p2p_pull:${ns}`;
         if (client._gapFillDone.has(dedupKey))
             return;
+        this.recordBackgroundPullDemand(ns, 0, true);
         client._gapFillDone.add(dedupKey);
         this.runtime.delivery.setGapFillActive(true);
         let filled = 0;
+        let failed = false;
         try {
             const key = client._rpcPipeline.pullGateKeyForCall('message.pull', { after_seq: afterSeq, limit: 50 });
             const messages = await client._rpcPipeline.runPullSerialized(key, () => client._pullV2(afterSeq, 50, { gateLocked: true }), true);
@@ -2309,22 +3304,27 @@ export class MessageDeliveryEngine {
                     client._clientLog.warn(`P2P message gap-fill V2 unavailable, used plain pull fallback:${String(formatDeliveryError(exc))}`);
                 }
                 catch (fallbackExc) {
+                    failed = true;
                     client._clientLog.warn(`P2P message gap-fill plain fallback failed:${String(formatDeliveryError(fallbackExc))}`);
-                    this.scheduleP2pGapRetry(ns, retryAttempt + 1);
                 }
             }
             else {
+                failed = true;
                 client._clientLog.warn(`P2P message gap-fill failed:${String(formatDeliveryError(exc))}`);
             }
         }
         finally {
-            client._gapFillDone.delete(dedupKey);
-            this.runtime.delivery.setGapFillActive(false);
-            this.schedulePendingPullIfNeeded(ns, 'gap-fill-complete');
+            if (this.isInlineGenerationCurrent(generation)) {
+                client._gapFillDone.delete(dedupKey);
+                this.runtime.delivery.setGapFillActive(false);
+                this.schedulePendingPullIfNeeded(ns, 'gap-fill-complete');
+                this.finishBackgroundPull(ns, afterSeq, failed);
+            }
         }
     }
     async fillP2pGapWithPlainPull(ns, afterSeq) {
         const client = this.runtime.client;
+        const generation = this.captureInlineGeneration();
         const params = {
             after_seq: afterSeq,
             limit: 50,
@@ -2333,11 +3333,16 @@ export class MessageDeliveryEngine {
             _rpc_background: true,
         };
         const raw = await client._rpcPipeline.rawCall('message.pull', params, { background: true });
+        if (!this.isInlineGenerationCurrent(generation))
+            throw new Error('pull invalidated');
+        if (isJsonObject(raw))
+            this.observeBackgroundPullResponse(ns, afterSeq, raw, 50);
         const page = await this.commitPlainForwardPage(ns, afterSeq, 'message.pull', raw);
         return page.publishedCount;
     }
     async fillGroupGap(groupId) {
         const client = this.runtime.client;
+        const generation = this.captureInlineGeneration();
         if (client._sessionOptions?.background_sync === false)
             return;
         if (client.state !== ConnectionState.READY || client._closing)
@@ -2350,25 +3355,48 @@ export class MessageDeliveryEngine {
         const dedupKey = `group_pull:${ns}`;
         if (client._gapFillDone.has(dedupKey))
             return;
+        this.recordBackgroundPullDemand(ns, 0, true);
         client._gapFillDone.add(dedupKey);
         this.runtime.delivery.setGapFillActive(true);
         let filled = 0;
+        let failed = false;
         try {
             const key = client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, after_seq: afterSeq, limit: 50 });
-            const messages = await client._rpcPipeline.runPullSerialized(key, () => client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true }), true);
+            const messages = await client._rpcPipeline.runPullNamespaceSerialized(key, async () => {
+                if (client._v2Session)
+                    return await client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true, background: true });
+                const result = await client._rpcPipeline.runPullSerialized(key, () => client._rpcPipeline.rawCall('group.pull', {
+                    group_id: groupId,
+                    after_message_seq: afterSeq,
+                    device_id: client._deviceId,
+                    slot_id: client._slotId,
+                    limit: 50,
+                    _rpc_background: true,
+                }, { background: true, pullGateKey: key }), true);
+                if (!this.isInlineGenerationCurrent(generation))
+                    throw new Error('pull invalidated');
+                if (isJsonObject(result))
+                    this.observeBackgroundPullResponse(ns, afterSeq, result, 50);
+                await this.commitPlainForwardPage(ns, afterSeq, 'group.pull', result, groupId);
+                return isJsonObject(result) && Array.isArray(result.messages) ? result.messages : [];
+            }, true);
             filled = messages.length;
             this.prunePushedSeqs(ns);
         }
         catch (exc) {
+            failed = true;
             client._clientLog.warn(`group message gap-fill failed:${String(exc)}`);
         }
         finally {
-            client._gapFillDone.delete(dedupKey);
-            this.runtime.delivery.setGapFillActive(false);
-            if (filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
-                client._safeAsync(this.fillGroupGap(groupId));
+            if (this.isInlineGenerationCurrent(generation)) {
+                client._gapFillDone.delete(dedupKey);
+                this.runtime.delivery.setGapFillActive(false);
+                if (filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
+                    this.recordBackgroundPullDemand(ns, 0, true);
+                }
+                this.schedulePendingPullIfNeeded(ns, 'gap-fill-complete');
+                this.finishBackgroundPull(ns, afterSeq, failed);
             }
-            this.schedulePendingPullIfNeeded(ns, 'gap-fill-complete');
         }
     }
     async fillGroupEventGap(groupId, options) {
@@ -2382,6 +3410,8 @@ export class MessageDeliveryEngine {
         if (!groupId)
             return;
         const ns = `group_event:${groupId}`;
+        this.rememberCommittedSeqState(ns);
+        const namespaceGeneration = this.captureSeqNamespaceGeneration(ns);
         const requestedAfterSeq = Number(options?.afterSeq ?? 0);
         const afterSeq = Number.isSafeInteger(requestedAfterSeq) && requestedAfterSeq > 0
             ? requestedAfterSeq
@@ -2390,6 +3420,7 @@ export class MessageDeliveryEngine {
         const dedupKey = `group_event_pull:${ns}`;
         if (client._gapFillDone.has(dedupKey))
             return;
+        this.recordBackgroundPullDemand(ns, 0, true);
         client._gapFillDone.add(dedupKey);
         this.runtime.delivery.setGapFillActive(true);
         let continuationAfterSeq = 0;
@@ -2409,6 +3440,10 @@ export class MessageDeliveryEngine {
                     _rpc_background: true,
                 };
                 const result = await client.call('group.pull_events', request);
+                if (!this.isInlineGenerationCurrent(generation))
+                    throw new Error('pull invalidated');
+                if (isJsonObject(result))
+                    this.observeBackgroundPullResponse(ns, nextAfterSeq, result, 50);
                 if (!isJsonObject(result))
                     return;
                 const events = result.events;
@@ -2426,47 +3461,69 @@ 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)
-                        eventSeqs.push(eventSeq);
-                    evt._from_gap_fill = true;
-                    if (evt.action === 'dissolved')
-                        hasDissolvedEvent = true;
-                    const et = String(evt.event_type ?? '');
-                    if (et === 'group.message_created')
-                        continue;
-                    const cs = evt.client_signature;
-                    if (cs && typeof cs === 'object') {
-                        if (client._shouldSkipEventSignature(evt)) {
-                            delete evt.client_signature;
+                const applicationPage = this.beginApplicationPage(ns);
+                try {
+                    for (const evt of eventObjects) {
+                        const eventSeq = Number(evt.event_seq ?? 0);
+                        if (Number.isFinite(eventSeq) && eventSeq > 0)
+                            eventSeqs.push(eventSeq);
+                        evt._from_gap_fill = true;
+                        if (evt.action === 'dissolved')
+                            hasDissolvedEvent = true;
+                        const et = String(evt.event_type ?? '');
+                        if (et === 'group.message_created')
+                            continue;
+                        const cs = evt.client_signature;
+                        if (cs && typeof cs === 'object') {
+                            if (client._shouldSkipEventSignature(evt)) {
+                                delete evt.client_signature;
+                            }
+                            else {
+                                const verified = await client._verifyEventSignature(evt, cs);
+                                evt._verified = client._isEventSignatureVerified(verified);
+                            }
                         }
-                        else {
-                            const verified = await client._verifyEventSignature(evt, cs);
-                            evt._verified = client._isEventSignatureVerified(verified);
+                        if (Number.isFinite(eventSeq) && eventSeq > 0 && !client._pushedSeqs.get(ns)?.has(eventSeq)) {
+                            this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, evt, 'pull');
+                            publishedEventCount += 1;
                         }
                     }
-                    if (Number.isFinite(eventSeq) && eventSeq > 0 && !client._pushedSeqs.get(ns)?.has(eventSeq)) {
-                        this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, evt, 'pull');
-                        publishedEventCount += 1;
-                    }
+                    const deliveryThrough = Math.max(pageContigBefore, contiguousSeq ?? 0, effectiveFloor, ...eventSeqs);
+                    await this.drainOrderedMessages(ns, undefined, false, false, undefined, 'pull', deliveryThrough, applicationPage);
+                    await this.flushApplicationPage(applicationPage);
+                }
+                catch (error) {
+                    this.abortApplicationPage(applicationPage, error);
+                    throw error;
                 }
-                const deliveryThrough = Math.max(pageContigBefore, contiguousSeq ?? 0, effectiveFloor, ...eventSeqs);
-                await this.drainOrderedMessages(ns, undefined, false, false, undefined, 'pull', deliveryThrough);
                 if (!this.isInlineGenerationCurrent(generation))
                     throw new Error('pull invalidated');
-                if (hasDissolvedEvent)
+                if (hasDissolvedEvent) {
+                    this.backgroundPullDemands.delete(ns);
                     break;
-                if (contiguousSeq === undefined)
-                    client._seqTracker.onPullResult(ns, eventObjects, nextAfterSeq);
-                else
-                    client._seqTracker.onPullResult(ns, eventObjects, nextAfterSeq, contiguousSeq);
-                if (effectiveFloor > client._seqTracker.getContiguousSeq(ns)) {
-                    client._seqTracker.forceContiguousSeq(ns, effectiveFloor);
                 }
-                const ackContig = client._seqTracker.getContiguousSeq(ns);
-                if (ackContig !== pageContigBefore && !hasDissolvedEvent) {
-                    this.persistSeq(ns);
+                if (!this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
+                    throw new Error('pull invalidated');
+                const pageSnapshot = client._seqTracker.snapshotNamespace(ns);
+                let ackContig = pageContigBefore;
+                try {
+                    if (contiguousSeq === undefined)
+                        client._seqTracker.onPullResult(ns, eventObjects, nextAfterSeq);
+                    else
+                        client._seqTracker.onPullResult(ns, eventObjects, nextAfterSeq, contiguousSeq);
+                    if (effectiveFloor > client._seqTracker.getContiguousSeq(ns))
+                        client._seqTracker.forceContiguousSeq(ns, effectiveFloor);
+                    ackContig = client._seqTracker.getContiguousSeq(ns);
+                    if (ackContig !== pageContigBefore) {
+                        await this.commitSeqTrackerState(ns);
+                        if (!this.isInlineGenerationCurrent(generation) || !this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
+                            throw new Error('pull invalidated');
+                    }
+                }
+                catch (error) {
+                    if (this.isInlineGenerationCurrent(generation) && this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
+                        client._seqTracker._restoreNamespaceSnapshotPreservingPush(ns, pageSnapshot);
+                    throw error;
                 }
                 if (eventObjects.length > 0 && ackContig > 0 && ackContig !== pageContigBefore) {
                     pendingAckSeq = Math.max(pendingAckSeq, ackContig);
@@ -2504,15 +3561,12 @@ export class MessageDeliveryEngine {
             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,
-                    _online_hint_after_event_seq: continuationAfterSeq,
-                });
+            if (this.isInlineGenerationCurrent(generation)) {
+                client._gapFillDone.delete(dedupKey);
+                this.runtime.delivery.setGapFillActive(false);
+                if (!client._rpcPipeline)
+                    this.syncStopped(failed ? 'aborted' : 'pull_drained');
+                this.finishBackgroundPull(ns, afterSeq, failed);
             }
         }
     }
@@ -2568,6 +3622,9 @@ export class MessageDeliveryEngine {
         if (!groupId)
             return;
         const ns = `group:${groupId}`;
+        const generation = this.captureInlineGeneration();
+        const afterSeq = this.syncState(ns).ack;
+        this.recordBackgroundPullDemand(ns, positiveSafeSequenceHint(data.seq), true);
         const targets = this.onlineUnreadHintTargets ?? new Map();
         const owners = this.onlineUnreadHintOwners ?? new Set();
         this.onlineUnreadHintTargets = targets;
@@ -2577,11 +3634,16 @@ export class MessageDeliveryEngine {
             return;
         owners.add(ns);
         client._safeAsync((async () => {
+            let failed = false;
+            let attemptAfterSeq = afterSeq;
             try {
                 while (true) {
                     const throughSeq = targets.get(ns) ?? 0;
                     const ackBefore = this.syncState(ns).ack;
+                    attemptAfterSeq = ackBefore;
                     await this.runGroupForwardRecovery(groupId, ns, 50, true, throughSeq);
+                    if (!this.isInlineGenerationCurrent(generation))
+                        return;
                     const ackAfter = this.syncState(ns).ack;
                     const target = targets.get(ns) ?? 0;
                     if (ackAfter >= target || ackAfter <= ackBefore)
@@ -2589,6 +3651,7 @@ export class MessageDeliveryEngine {
                 }
             }
             catch (exc) {
+                failed = true;
                 client._clientLog?.debug(`online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
             }
             finally {
@@ -2596,6 +3659,8 @@ export class MessageDeliveryEngine {
                     targets.delete(ns);
                 if (this.onlineUnreadHintOwners === owners)
                     owners.delete(ns);
+                if (this.isInlineGenerationCurrent(generation))
+                    this.finishBackgroundPull(ns, attemptAfterSeq, failed);
             }
         })());
     }
@@ -2604,6 +3669,7 @@ export class MessageDeliveryEngine {
         const groupId = String(data.group_id ?? '').trim();
         if (!groupId || client._sessionOptions?.background_sync === false)
             return;
+        this.recordBackgroundPullDemand(`group_event:${groupId}`, positiveSafeSequenceHint(data.event_seq), true);
         const rawAfter = Number(data._online_hint_after_event_seq ?? 0);
         const afterSeq = Number.isSafeInteger(rawAfter) && rawAfter > 0 ? rawAfter : 0;
         client._safeAsync(this.fillGroupEventGap(groupId, {
@@ -2639,14 +3705,14 @@ export class MessageDeliveryEngine {
             max_pages: maxPages,
         };
         const invoke = async () => {
-            const messages = await client._pullGroupV2(groupId, Number(request.after_seq), pageLimit, { gateLocked: true, maxPages });
+            const messages = await client._pullGroupV2(groupId, Number(request.after_seq), pageLimit, { gateLocked: true, background, maxPages });
             return { messages, raw_count: messages.length };
         };
         const pipeline = client._rpcPipeline;
         if (!pipeline)
             return await invoke();
         const key = pipeline.pullGateKeyForCall('group.pull', request);
-        return await pipeline.runPullSerialized(key, invoke, background);
+        return await pipeline.runPullNamespaceSerialized(key, invoke, background);
     }
     syncState(ns) {
         const tracker = this.runtime.client._seqTracker;
@@ -2953,6 +4019,8 @@ export class MessageDeliveryEngine {
     }
     async commitInlineMessage(ns, seq, event, payload, generation) {
         const client = this.runtime.client;
+        this.rememberCommittedSeqState(ns);
+        const namespaceGeneration = this.captureSeqNamespaceGeneration(ns);
         const tracker = client._seqTracker;
         let snapshot = null;
         let trackerChanged = false;
@@ -2962,7 +4030,7 @@ export class MessageDeliveryEngine {
             const published = selfSync
                 ? (this.markPublishedSeq(ns, seq), true)
                 : await this.publishPulledMessage(event, ns, seq, payload, true, 'inline_push');
-            if (!this.isInlineGenerationCurrent(generation))
+            if (!this.isInlineGenerationCurrent(generation) || !this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
                 return false;
             if (!published)
                 return false;
@@ -2976,12 +4044,13 @@ export class MessageDeliveryEngine {
             if (!this.isInlineGenerationCurrent(generation))
                 return false;
             await client._commitSeqTrackerState(ns);
-            if (!this.isInlineGenerationCurrent(generation))
+            if (!this.isInlineGenerationCurrent(generation) || !this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
                 return false;
             return true;
         }
         catch (exc) {
-            if (trackerChanged && this.isInlineGenerationCurrent(generation) && typeof tracker.restoreNamespaceSnapshot === 'function') {
+            if (trackerChanged && this.isInlineGenerationCurrent(generation) && this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration)
+                && typeof tracker.restoreNamespaceSnapshot === 'function') {
                 tracker._restoreNamespaceSnapshotPreservingPush(ns, snapshot);
             }
             client._clientLog.debug(`inline realtime consume rolled back: ns=${ns} seq=${seq} err=${formatDeliveryError(exc)}`);
@@ -3220,16 +4289,17 @@ export class MessageDeliveryEngine {
                 return { messages: [], raw_count: 0 };
             const request = { group_id: groupId, ...(tail ? { window_mode: 'tail' } : {}), after_seq: live.ack, limit: pageLimit };
             const key = client._rpcPipeline.pullGateKeyForCall('group.pull', request);
-            return await client._rpcPipeline.runPullSerialized(key, async () => {
+            return await client._rpcPipeline.runPullNamespaceSerialized(key, async () => {
                 if (tail) {
                     const tailResult = await client._v2E2EE.pullGroupV2TailInternal({
                         group_id: groupId, window_mode: 'tail', after_seq: live.ack, limit: pageLimit,
-                    }, true);
+                    }, true, true);
                     tailCompleted = true;
                     return tailResult;
                 }
                 const messages = await client._pullGroupV2(groupId, live.ack, pageLimit, {
                     gateLocked: true,
+                    background,
                     ...(maxPages ? { maxPages } : {}),
                 });
                 return { messages, raw_count: messages.length };
@@ -3378,26 +4448,38 @@ export class MessageDeliveryEngine {
             }
             return;
         }
+        if (client._sessionOptions?.background_sync !== false)
+            this.recordBackgroundPullDemand(ns, seq);
         const pullActive = client._rpcPipeline?.hasPullActivity?.(ns) === true;
         if (pullActive || !this.beginRealtimeSync(ns)) {
             this.recordPendingPull(ns, seq);
             client._clientLog?.debug(`V2 group push queued behind in-flight realtime sync: ns=${ns} seq=${seq}`);
             return;
         }
+        const generation = this.captureInlineGeneration();
+        let failed = false;
         try {
             // namespace 串行区必须覆盖 Tail 与其后至多一次 Forward 的完整周期。
             await this.runGroupRealtimeSync(groupId, ns, seq, 50, false);
         }
         catch (exc) {
+            failed = true;
             client._clientLog.warn(`V2 group push auto-sync failed: group=${groupId} err=${formatDeliveryError(exc)}`);
         }
         finally {
-            this.endRealtimeSync(ns);
-            this.schedulePendingPullIfNeeded(ns, 'push-auto-pull-complete');
+            if (this.isInlineGenerationCurrent(generation)) {
+                this.endRealtimeSync(ns);
+                this.schedulePendingPullIfNeeded(ns, 'push-auto-pull-complete');
+                this.finishBackgroundPull(ns, before.ack, failed);
+            }
         }
     }
     async onV2PushNotification(data) {
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled) {
+            this.handlePeerNotification(data);
+            return;
+        }
         const ns = client._aid ? `p2p:${client._aid}` : '';
         if (!ns)
             return;
@@ -3466,31 +4548,64 @@ export class MessageDeliveryEngine {
             }
             return;
         }
+        if (client._sessionOptions?.background_sync !== false)
+            this.recordBackgroundPullDemand(ns, pushSeq);
         const pullActive = client._rpcPipeline?.hasPullActivity?.(ns) === true;
         if (pullActive || !this.beginRealtimeSync(ns)) {
             this.recordPendingPull(ns, pushSeq);
             client._clientLog?.debug(`V2 P2P push queued behind in-flight realtime sync: ns=${ns} seq=${pushSeq}`);
             return;
         }
+        const generation = this.captureInlineGeneration();
+        let failed = false;
         try {
             await this.runP2PRealtimeSync(ns, pushSeq, 50, false);
         }
         catch (exc) {
+            failed = true;
             client._clientLog.warn(`V2 P2P push auto-sync failed: ${formatDeliveryError(exc)}`);
         }
         finally {
-            this.endRealtimeSync(ns);
-            this.schedulePendingPullIfNeeded(ns, 'push-auto-pull-complete');
+            if (this.isInlineGenerationCurrent(generation)) {
+                this.endRealtimeSync(ns);
+                this.schedulePendingPullIfNeeded(ns, 'push-auto-pull-complete');
+                this.finishBackgroundPull(ns, before.ack, failed);
+            }
         }
     }
     enqueueOnlineUnreadP2pHint(data) {
         const client = this.runtime.client;
-        if (!client._aid || !client._v2Session)
+        if (client._p2pPeerPullEnabled) {
+            this.requestPeerDirectoryRefresh();
+            return;
+        }
+        if (!client._aid || !client._v2Session || client._sessionOptions?.background_sync === false)
             return;
         const ns = `p2p:${client._aid}`;
-        client._safeAsync(this.runP2PForwardRecovery(ns, 50, true).catch((exc) => {
-            client._clientLog?.debug(`P2P online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
-        }));
+        const generation = this.captureInlineGeneration();
+        const afterSeq = this.syncState(ns).ack;
+        this.recordBackgroundPullDemand(ns, positiveSafeSequenceHint(data.seq), true);
+        const owners = this.onlineUnreadHintOwners ?? new Set();
+        this.onlineUnreadHintOwners = owners;
+        if (owners.has(ns))
+            return;
+        owners.add(ns);
+        client._safeAsync((async () => {
+            let failed = false;
+            try {
+                await this.runP2PForwardRecovery(ns, 50, true);
+            }
+            catch (exc) {
+                failed = true;
+                client._clientLog?.debug(`P2P online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
+            }
+            finally {
+                if (this.onlineUnreadHintOwners === owners)
+                    owners.delete(ns);
+                if (this.isInlineGenerationCurrent(generation))
+                    this.finishBackgroundPull(ns, afterSeq, failed);
+            }
+        })());
     }
     async restoreSeqTrackerState() {
         const client = this.runtime.client;
@@ -3511,6 +4626,7 @@ export class MessageDeliveryEngine {
                 if (state && typeof state === 'object' && Object.keys(state).length > 0) {
                     state = await this.migrateSeqStateGroupIds(state);
                     client._seqTracker.restoreSyncState(state);
+                    this.restoreCommittedSeqStates();
                     return;
                 }
             }
@@ -3522,6 +4638,7 @@ export class MessageDeliveryEngine {
                 if (state && typeof state === 'object' && Object.keys(state).length > 0) {
                     state = await this.migrateSeqStateGroupIds(state);
                     client._seqTracker.restoreState(state);
+                    this.restoreCommittedSeqStates();
                 }
                 return;
             }
@@ -3536,6 +4653,7 @@ export class MessageDeliveryEngine {
                 if (isJsonObject(state)) {
                     const migrated = await this.migrateSeqStateGroupIds(state);
                     client._seqTracker.restoreState(migrated);
+                    this.restoreCommittedSeqStates();
                 }
             }
         }
@@ -3552,6 +4670,16 @@ export class MessageDeliveryEngine {
     async migrateSeqStateGroupIds(state) {
         return state;
     }
+    restoreCommittedSeqStates() {
+        this.peerContext();
+        for (const [ns, state] of Object.entries(this.runtime.client._seqTracker.exportSyncState())) {
+            if (!this.isReliableSeqNamespace(ns))
+                continue;
+            this.committedSeqTrackerStates.set(ns, { ...state });
+            if (ns.startsWith('p2p.peer.v1/'))
+                this.peerInitialized.add(ns);
+        }
+    }
     async saveSeqTrackerState() {
         const client = this.runtime.client;
         const context = this.currentSeqTrackerContext();
@@ -3562,6 +4690,7 @@ export class MessageDeliveryEngine {
         const state = typeof client._seqTracker.exportSyncState === 'function'
             ? client._seqTracker.exportSyncState()
             : Object.fromEntries(Object.entries(client._seqTracker.exportState()).map(([ns, seq]) => [ns, { ack: Number(seq), tail: Number(seq), head: Number(seq) }]));
+        this.useCommittedSeqStates(state);
         const pending = this.seqTrackerPending();
         if (pending.size > 0 && client._seqTrackerPendingPersistContext === context) {
             const liveNamespaces = new Set(Object.keys(state));
@@ -3592,11 +4721,15 @@ export class MessageDeliveryEngine {
         const state = typeof client._seqTracker.getSyncState === 'function'
             ? client._seqTracker.getSyncState(ns)
             : { ack: seq, tail: seq, head: seq };
-        this.mergeSeqTrackerPending(context, { [ns]: state });
+        const pendingState = { [ns]: state };
+        this.useCommittedSeqStates(pendingState);
+        this.mergeSeqTrackerPending(context, pendingState);
         this.scheduleSeqTrackerFlush();
     }
     async commitSeqTrackerState(ns) {
         const client = this.runtime.client;
+        const tracker = client._seqTracker;
+        const namespaceGeneration = this.seqTrackerNamespaceGenerations.get(ns) ?? 0;
         const context = this.currentSeqTrackerContext();
         if (!context || !ns)
             return;
@@ -3609,10 +4742,18 @@ export class MessageDeliveryEngine {
         const [aid, deviceId, slotId] = JSON.parse(context);
         const pendingBeforeCommit = this.takeSeqTrackerPending(context, ns);
         try {
-            await this.writeSeqTrackerState(aid, deviceId, slotId, { [ns]: state }, true);
+            await this.enqueueSeqTrackerWrite(async () => {
+                if (client._seqTracker !== tracker)
+                    throw new StateError('seq tracker commit invalidated');
+                await this.writeSeqTrackerStateNow(aid, deviceId, slotId, { [ns]: state }, true);
+                if (client._seqTracker === tracker && (this.seqTrackerNamespaceGenerations.get(ns) ?? 0) === namespaceGeneration
+                    && this.currentSeqTrackerContext() === context && this.isReliableSeqNamespace(ns))
+                    this.committedSeqTrackerStates.set(ns, { ...state });
+            });
         }
         catch (exc) {
-            this.restoreSeqTrackerPending(context, ns, pendingBeforeCommit);
+            if (client._seqTracker === tracker && (this.seqTrackerNamespaceGenerations.get(ns) ?? 0) === namespaceGeneration)
+                this.restoreSeqTrackerPending(context, ns, pendingBeforeCommit);
             throw exc;
         }
         client._clientLog.debug(`seq_tracker atomic commit: ns=${ns} A/T/H=${JSON.stringify(state)} context=${context}`);
@@ -3719,7 +4860,25 @@ export class MessageDeliveryEngine {
         }
     }
     async writeSeqTrackerState(aid, deviceId, slotId, state, throwOnError = false) {
-        await this.enqueueSeqTrackerWrite(() => this.writeSeqTrackerStateNow(aid, deviceId, slotId, state, throwOnError));
+        await this.enqueueSeqTrackerWrite(() => {
+            if (!throwOnError && this.currentSeqTrackerContext() === JSON.stringify([aid, deviceId, slotId]))
+                this.useCommittedSeqStates(state);
+            return this.writeSeqTrackerStateNow(aid, deviceId, slotId, state, throwOnError);
+        });
+    }
+    useCommittedSeqStates(state) {
+        this.peerContext();
+        for (const ns of Object.keys(state)) {
+            if (!this.isReliableSeqNamespace(ns))
+                continue;
+            if (!ns.startsWith('p2p.peer.v1/'))
+                this.rememberCommittedSeqState(ns);
+            const durable = this.committedSeqTrackerStates.get(ns);
+            if (durable)
+                state[ns] = { ...durable };
+            else
+                delete state[ns];
+        }
     }
     enqueueSeqTrackerWrite(operation) {
         const run = this.seqTrackerWriteChain.then(operation, operation);
@@ -3773,6 +4932,11 @@ export class MessageDeliveryEngine {
         const deviceId = client._deviceId;
         const slotId = client._slotId;
         const seq = client._seqTracker.getContiguousSeq(ns);
+        if (seq <= 0) {
+            this.seqTrackerNamespaceGenerations.set(ns, (this.seqTrackerNamespaceGenerations.get(ns) ?? 0) + 1);
+            this.committedSeqTrackerStates.delete(ns);
+            this.peerInitialized.delete(ns);
+        }
         this.dropSeqTrackerPending(ns);
         const saveSeq = client._tokenStore.saveSeq;
         if (seq > 0 && typeof saveSeq === 'function') {
@@ -3830,7 +4994,9 @@ export class MessageDeliveryEngine {
         if (next < 0)
             next = 0;
         if (ns) {
-            const committedAck = client._seqTracker.getContiguousSeq(ns);
+            if (ns.startsWith('group:') || ns.startsWith('group_event:'))
+                this.rememberCommittedSeqState(ns);
+            const committedAck = this.isReliableSeqNamespace(ns) ? this.committedSeqTrackerAck(ns) : client._seqTracker.getContiguousSeq(ns);
             if (next > committedAck) {
                 client._clientLog.warn(`ack clamp: method=${method} ${field}=${original} > committed_ack=${committedAck}, clamp`);
                 next = committedAck;
@@ -3860,11 +5026,11 @@ export class MessageDeliveryEngine {
             return next === raw ? params : { ...params, [field]: next };
         };
         if (method === 'message.v2.ack') {
-            const ns = client._aid ? `p2p:${client._aid}` : '';
+            const ns = client._p2pPeerPullEnabled ? this.peerNamespace(String(params.sender_aid ?? params.peer_aid ?? '').trim()) : client._aid ? `p2p:${client._aid}` : '';
             return clampField('up_to_seq', ns);
         }
         if (method === 'message.ack') {
-            const ns = client._aid ? `p2p:${client._aid}` : '';
+            const ns = client._p2pPeerPullEnabled ? this.peerNamespace(String(params.sender_aid ?? params.peer_aid ?? '').trim()) : client._aid ? `p2p:${client._aid}` : '';
             return clampField('seq', ns);
         }
         if (method === 'group.v2.ack' || method === 'group.ack_messages' || method === 'group.ack_events') {
@@ -3879,7 +5045,18 @@ export class MessageDeliveryEngine {
         }
         return params;
     }
-    async drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true, batch, source = 'pull', throughSeq) {
+    consumeOrderedSequence(ns, seq, page) {
+        const client = this.runtime.client;
+        const queue = client._pendingOrderedMsgs.get(ns);
+        if (page?.batch)
+            page.consumed.add(seq);
+        this.deferApplicationEffect(page, () => {
+            queue?.delete(seq);
+            if (queue?.size === 0 && client._pendingOrderedMsgs.get(ns) === queue)
+                client._pendingOrderedMsgs.delete(ns);
+        });
+    }
+    async drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true, batch, source = 'pull', throughSeq, page) {
         const client = this.runtime.client;
         const pullScoped = this.isPullScopedSource(source);
         if (pullScoped)
@@ -3894,15 +5071,40 @@ export class MessageDeliveryEngine {
             .sort((a, b) => a - b);
         let delivered = false;
         const drainBatches = new Map();
+        const deferredPages = this.deferredApplicationPages.get(ns);
+        const isolatedPage = page && deferredPages && [...deferredPages.values()].includes(page);
         try {
             for (const seq of ready) {
                 if (pullScoped)
                     this.ensurePullOperationCurrent(ns);
                 const item = queue.get(seq);
-                if (!item)
+                if (!item || page?.consumed.has(seq))
+                    continue;
+                let deferredPage = deferredPages?.get(seq);
+                if (isolatedPage && deferredPage !== page)
                     continue;
+                if (deferredPage && deferredPage !== page) {
+                    if ([...deferredPages].some(([pendingSeq, pendingPage]) => pendingPage === deferredPage && !ready.includes(pendingSeq)))
+                        continue;
+                    await this.flushApplicationPage(page);
+                    deferredPage.ensureCurrent();
+                    if (deferredPage.closed) {
+                        const retry = this.beginApplicationPage(ns, deferredPage.source);
+                        retry.handlers = deferredPage.handlers;
+                        retry.batch = deferredPage.batch;
+                        retry.tailProof = deferredPage.tailProof;
+                        for (const [pendingSeq, pendingPage] of deferredPages)
+                            if (pendingPage === deferredPage)
+                                deferredPages.set(pendingSeq, retry);
+                        deferredPage = retry;
+                    }
+                    deferredPage.deferred = false;
+                    await this.drainOrderedMessages(ns, beforeSeq, pullResponse, false, batch, source, throughSeq, deferredPage);
+                    await this.flushApplicationPage(deferredPage);
+                    continue;
+                }
                 if (client._pushedSeqs.get(ns)?.has(seq)) {
-                    queue.delete(seq);
+                    this.consumeOrderedSequence(ns, seq, page);
                     continue;
                 }
                 const itemSource = item.source ?? source;
@@ -3915,15 +5117,16 @@ export class MessageDeliveryEngine {
                         drainBatches.set(itemSource, itemBatch);
                     }
                 }
-                await this.publishOrderedQueueItem(ns, item.event, seq, item.payload, pullResponse, itemSource, itemBatch);
+                if (!page?.seen.has(`ordered:${seq}`))
+                    await this.publishOrderedQueueItem(ns, item.event, seq, item.payload, pullResponse, itemSource, itemBatch, page);
                 if (!this.isInlineGenerationCurrent(generation))
                     throw new Error('pull invalidated');
                 if (pullScoped)
                     this.ensurePullOperationCurrent(ns);
-                queue.delete(seq);
+                this.consumeOrderedSequence(ns, seq, page);
                 if (item.event === 'group.changed' && isJsonObject(item.payload) && item.payload.action === 'dissolved')
                     continue;
-                this.markPublishedSeq(ns, seq);
+                this.markPublishedSeq(ns, seq, page);
                 delivered = true;
             }
         }
@@ -3932,7 +5135,7 @@ export class MessageDeliveryEngine {
                 await this.flushRealtimeDeliveryChanges(drainBatch);
             }
         }
-        if (queue.size === 0) {
+        if (!page?.batch && queue.size === 0) {
             client._pendingOrderedMsgs.delete(ns);
             if (delivered && persist) {
                 if (pullScoped)
@@ -3941,7 +5144,7 @@ export class MessageDeliveryEngine {
             }
         }
     }
-    async publishOrderedMessage(event, ns, seq, payload, source = 'push', operationBatch) {
+    async publishOrderedMessage(event, ns, seq, payload, source = 'push', operationBatch, page) {
         const client = this.runtime.client;
         const generation = this.captureInlineGeneration();
         const ownsBatch = !operationBatch && (source === 'push' || source === 'inline_push');
@@ -3949,39 +5152,55 @@ export class MessageDeliveryEngine {
         try {
             const seqNum = Number(seq);
             if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0) {
-                await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch);
+                await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch, page);
                 return true;
             }
-            if (client._pushedSeqs.get(ns)?.has(seqNum)) {
+            if (page?.consumed.has(seqNum) || client._pushedSeqs.get(ns)?.has(seqNum)) {
                 const queue = client._pendingOrderedMsgs.get(ns);
-                queue?.delete(seqNum);
-                if (queue && queue.size === 0)
+                this.consumeOrderedSequence(ns, seqNum, page);
+                if (!page?.batch && queue && queue.size === 0)
                     client._pendingOrderedMsgs.delete(ns);
                 return false;
             }
             if (event === 'message.received' && this.isSelfSentP2PMessage(payload)) {
-                this.markPublishedSeq(ns, seqNum);
+                this.markPublishedSeq(ns, seqNum, page);
                 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) {
+                const owner = this.deferredApplicationPages.get(ns)?.get(seqNum);
+                if (page && source === 'tail' && owner && owner !== page)
+                    return false;
                 this.enqueueOrderedMessage(ns, event, seqNum, payload, source);
+                if (page && source === 'tail') {
+                    let pages = this.deferredApplicationPages.get(ns);
+                    if (!pages) {
+                        pages = new Map();
+                        this.deferredApplicationPages.set(ns, pages);
+                    }
+                    pages.set(seqNum, page);
+                    page.deferred = true;
+                    if (page.batch) {
+                        await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch, page);
+                        page.seen.add(`ordered:${seqNum}`);
+                    }
+                }
                 return false;
             }
-            await this.drainOrderedMessages(ns, seqNum, true, true, batch, source);
-            if (client._pushedSeqs.get(ns)?.has(seqNum))
+            await this.drainOrderedMessages(ns, seqNum, true, true, batch, source, undefined, page);
+            if (page?.consumed.has(seqNum) || client._pushedSeqs.get(ns)?.has(seqNum))
                 return false;
             const queue = client._pendingOrderedMsgs.get(ns);
-            await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch);
+            await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch, page);
             if (!this.isInlineGenerationCurrent(generation))
                 throw new Error('pull invalidated');
-            queue?.delete(seqNum);
-            if (queue && queue.size === 0)
+            this.consumeOrderedSequence(ns, seqNum, page);
+            if (!page?.batch && queue && queue.size === 0)
                 client._pendingOrderedMsgs.delete(ns);
-            this.markPublishedSeq(ns, seqNum);
-            await this.drainOrderedMessages(ns, undefined, false, true, batch, source);
-            if (!client._pendingOrderedMsgs.get(ns))
+            this.markPublishedSeq(ns, seqNum, page);
+            await this.drainOrderedMessages(ns, undefined, false, true, batch, source, undefined, page);
+            if (!page?.batch && !client._pendingOrderedMsgs.get(ns))
                 await this.saveSeqTrackerState();
             return true;
         }
@@ -3990,8 +5209,16 @@ export class MessageDeliveryEngine {
                 await this.flushRealtimeDeliveryChanges(batch);
         }
     }
-    async publishPulledMessage(event, ns, seq, payload, persist = true, source = 'pull', operationBatch) {
+    async publishPulledMessage(event, ns, seq, payload, persist = true, source = 'pull', operationBatch, page) {
         const client = this.runtime.client;
+        const deferredPage = this.deferredApplicationPages.get(ns)?.get(Number(seq));
+        if (deferredPage && deferredPage !== page && !deferredPage.flushed)
+            return false;
+        if (client._p2pPeerPullEnabled && event === 'message.received' && ns.startsWith('p2p.peer.v1/')) {
+            await client._publishAppEvent(event, payload, source, ns, operationBatch, page);
+            this.markPublishedSeq(ns, Number(seq), page);
+            return true;
+        }
         const generation = this.captureInlineGeneration();
         const ownsBatch = !operationBatch && (source === 'push' || source === 'inline_push');
         const batch = operationBatch ?? (ownsBatch ? this.createDeliveryChangeBatch(source) : undefined);
@@ -4002,52 +5229,52 @@ export class MessageDeliveryEngine {
             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));
+                    const published = await client._withPullResponseProcessing(ns, () => this.publishMessageRecallTombstone(seq, payload, source, page));
                     if (pullScoped)
                         this.ensurePullOperationCurrent(ns);
                     return published;
                 }
-                await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
+                await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch, page));
                 if (pullScoped)
                     this.ensurePullOperationCurrent(ns);
                 return true;
             }
             const queue = client._pendingOrderedMsgs.get(ns);
-            if (client._pushedSeqs.get(ns)?.has(seqNum)) {
-                queue?.delete(seqNum);
-                if (queue && queue.size === 0)
+            if (page?.consumed.has(seqNum) || client._pushedSeqs.get(ns)?.has(seqNum)) {
+                this.consumeOrderedSequence(ns, seqNum, page);
+                if (!page?.batch && queue && queue.size === 0)
                     client._pendingOrderedMsgs.delete(ns);
                 return false;
             }
             if (event === 'message.received' && this.isSelfSentP2PMessage(payload)) {
-                this.markPublishedSeq(ns, seqNum);
+                this.markPublishedSeq(ns, seqNum, page);
                 client._clientLog.debug(`publish pulled skipped current-device self-sync: ns=${ns}, seq=${seqNum}`);
                 return source === 'inline_push';
             }
-            await this.drainOrderedMessages(ns, seqNum, false, persist, batch, source);
+            await this.drainOrderedMessages(ns, seqNum, false, persist, batch, source, undefined, page);
             if (pullScoped)
                 this.ensurePullOperationCurrent(ns);
             if (event === 'message.recalled') {
-                const published = await client._withPullResponseProcessing(ns, () => this.publishMessageRecallTombstone(seqNum, payload, source));
+                const published = await client._withPullResponseProcessing(ns, () => this.publishMessageRecallTombstone(seqNum, payload, source, page));
                 if (!this.isInlineGenerationCurrent(generation))
                     throw new Error('pull invalidated');
                 if (pullScoped)
                     this.ensurePullOperationCurrent(ns);
-                queue?.delete(seqNum);
-                if (queue && queue.size === 0)
+                this.consumeOrderedSequence(ns, seqNum, page);
+                if (!page?.batch && queue && queue.size === 0)
                     client._pendingOrderedMsgs.delete(ns);
-                this.markPublishedSeq(ns, seqNum);
+                this.markPublishedSeq(ns, seqNum, page);
                 return published;
             }
-            await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
+            await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch, page));
             if (!this.isInlineGenerationCurrent(generation))
                 throw new Error('pull invalidated');
             if (pullScoped)
                 this.ensurePullOperationCurrent(ns);
-            queue?.delete(seqNum);
-            if (queue && queue.size === 0)
+            this.consumeOrderedSequence(ns, seqNum, page);
+            if (!page?.batch && queue && queue.size === 0)
                 client._pendingOrderedMsgs.delete(ns);
-            this.markPublishedSeq(ns, seqNum);
+            this.markPublishedSeq(ns, seqNum, page);
             return true;
         }
         finally {