@agentunion/fastaun 0.5.19 → 0.5.21

package/dist/client/delivery.js

@@ -1,4 +1,6 @@
-import { slotIsolationKey } from '../config.js';
+import { _INTERNAL_MESSAGE_FLOW_LIMITS, slotIsolationKey } from '../config.js';
+import { parseFileFrontmatter } from '../agent-md-schema.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { trafficLogContext, withLogContext } from '../logger.js';
 import { ConnectionState, isJsonObject } from '../types.js';
 import { validateGroupAIDFormat } from '../validators.js';
@@ -9,16 +11,18 @@ const MESSAGE_RECALL_SEEN_LIMIT = 10_000;
 const GROUP_RECALL_SEEN_LIMIT = 10_000;
 const VOLATILE_SEEN_LIMIT = 10_000;
 const SEQ_TRACKER_PERSIST_FLUSH_DELAY_MS = 200;
+const BACKGROUND_PULL_RETRY_DELAY_MS = 250;
 const DELIVERY_CHANGED_MESSAGE_EVENTS = new Set([
     'message.received',
     'group.message_created',
 ]);
+const APPLICATION_DELIVERY_EVENTS = new Set(['message.received', 'message.recalled', 'group.message_created', 'group.message_recalled', 'group.changed']);
 const MAX_INLINE_PENDING_ACK_NAMESPACES = 4096;
 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',
@@ -80,6 +84,11 @@ export class MessageDeliveryEngine {
     pendingGroupPullUpper = null;
     onlineUnreadHintTargets = null;
     onlineUnreadHintTasks = null;
+    backgroundPullNeeds = new Map();
+    backgroundPullTasks = new Set();
+    backgroundPullCheckQueued = false;
+    backgroundPullTimer = null;
+    backgroundPullTimerAt = 0;
     pendingP2PInlineAcks = null;
     pendingGroupInlineAcks = null;
     pendingGroupInlineAckNamespaces = null;
@@ -94,9 +103,488 @@ export class MessageDeliveryEngine {
     volatileInFlightMessages = new Set();
     // 同一实例的 tracker 写入必须串行，避免旧的延迟 flush 覆盖新的 Forward 提交。
     seqTrackerWriteChain = Promise.resolve();
+    peerCatalogTask = null;
+    peerCatalogDirty = false;
+    peerCatalogQueries = new Map();
+    peerContext = '';
+    peerTracker = null;
+    peerContextGeneration = 0;
+    peerBootstrap = null;
+    initializedPeers = new Set();
+    committedSeqTrackerStates = new Map();
+    seqTrackerNamespaceGenerations = new Map();
+    peerRecoveryTasks = new Map();
+    peerRecoveryNeeds = new Map();
+    peerPullHints = new Map();
+    peerPullConfirmedThrough = new Map();
+    peerVolatileCursors = new Map();
+    settledDeliveries = new Map();
+    deliveryInflight = new Map();
+    applicationPage = new AsyncLocalStorage();
+    applicationClaims = new Map();
+    volatileCompletions = new Map();
+    peerPageChains = new Map();
     constructor(runtime) {
         this.runtime = runtime;
     }
+    currentApplicationPage() {
+        const page = this.applicationPage.getStore();
+        return page?.collecting && page.batching ? page : undefined;
+    }
+    isApplicationPageCurrent(page) {
+        return page.context === this.ensurePeerContext() && page.generation === this.captureInlineAckGeneration()
+            && this.isSeqNamespaceGenerationCurrent(page.namespace, page.namespaceGeneration)
+            && (!this.isPullScopedSource(page.source) || this.isPullOperationCurrent(page.namespace));
+    }
+    ensureApplicationPageCurrent(page) {
+        if (!this.isApplicationPageCurrent(page))
+            throw new Error(this.isPullScopedSource(page.source) ? 'pull invalidated' : 'delivery invalidated');
+    }
+    snapshotApplicationHandlers() {
+        return this.runtime.client._dispatcher._snapshotApplicationHandlers?.(['message.batch', 'group.message_batch', 'group.event_batch']);
+    }
+    async runApplicationPage(namespace, source, operation, reservation, snapshot) {
+        const dispatcher = this.runtime.client._dispatcher;
+        if (typeof dispatcher._snapshotApplicationHandlers !== 'function')
+            return await operation();
+        const previous = this.applicationPage.getStore();
+        if (previous?.collecting && previous.namespace === namespace)
+            return await operation();
+        let resolve, reject;
+        const completion = new Promise((done, fail) => { resolve = done; reject = fail; });
+        void completion.catch(() => { });
+        const handlers = snapshot ?? this.snapshotApplicationHandlers(), batchEvent = namespace.startsWith('group_event:') ? 'group.event_batch'
+            : namespace.startsWith('group:') ? 'group.message_batch' : 'message.batch';
+        const page = { namespace, source, context: this.ensurePeerContext(), generation: this.captureInlineAckGeneration(),
+            namespaceGeneration: this.captureSeqNamespaceGeneration(namespace),
+            collecting: true, batching: (handlers.get(batchEvent)?.length ?? 0) > 0, handlers, reservation,
+            items: [], commits: [], afterDelivery: [], cleanup: [], claims: new Set(), bindings: new Map(), volatileSeen: new Set(), consumed: new Set(),
+            completion, resolve, reject };
+        return await this.applicationPage.run(page, async () => {
+            try {
+                const result = await operation();
+                page.collecting = false;
+                this.ensureApplicationPageCurrent(page);
+                if (page.items.length > 0) {
+                    const batchHandlers = page.handlers.get(batchEvent) ?? [];
+                    await dispatcher._publishAndWait(batchEvent, { namespace, items: page.items, source }, batchHandlers, reservation, () => this.isApplicationPageCurrent(page));
+                }
+                this.ensureApplicationPageCurrent(page);
+                for (const commit of page.commits)
+                    commit();
+                for (const action of page.afterDelivery) {
+                    await action();
+                    this.ensureApplicationPageCurrent(page);
+                }
+                for (const cleanup of page.cleanup)
+                    cleanup();
+                page.resolve();
+                return result;
+            }
+            catch (error) {
+                page.reject(error);
+                throw error;
+            }
+            finally {
+                page.collecting = false;
+                for (const key of page.claims)
+                    if (this.applicationClaims.get(key) === page)
+                        this.applicationClaims.delete(key);
+            }
+        });
+    }
+    completeApplicationDelivery(operation) {
+        const page = this.currentApplicationPage();
+        if (page)
+            page.commits.push(operation);
+        else
+            operation();
+    }
+    applicationNamespace(event, payload) {
+        const value = payload && typeof payload === 'object' ? payload : {};
+        if (event === 'group.changed')
+            return `group_event:${String(value.group_id ?? value.group_aid ?? '')}`;
+        if (event.startsWith('group.'))
+            return `group:${String(value.group_id ?? value.group_aid ?? '')}`;
+        const sender = String(value.sender_aid ?? value.from_aid ?? value.from ?? '');
+        return this.runtime.client._p2pPeerPullEnabled && sender ? this.peerNamespace(sender) : `p2p:${this.runtime.client._aid ?? ''}`;
+    }
+    applicationClaimKey(event, payload, namespace, context) {
+        const value = payload && typeof payload === 'object' ? payload : {};
+        const seq = Number(event === 'group.changed' ? value.event_seq : value.seq);
+        const identity = event === 'message.recalled' ? this.messageRecallDedupKey(value)
+            : event === 'group.message_recalled' ? this.groupRecallDedupKey(String(value.group_id ?? ''), value)
+                : Number.isSafeInteger(seq) && seq > 0 ? seq : value.volatile_cursor ?? value.message_id;
+        return identity === undefined ? '' : JSON.stringify([context, event, event.startsWith('message.') ? 'p2p' : namespace,
+            value.storage === 'volatile' ? String(value.sender_aid ?? value.from_aid ?? value.from ?? '') : '', identity]);
+    }
+    async waitForApplicationOwner(owner) {
+        if (this.runtime.client._dispatcher._isApplicationHandler?.())
+            throw new Error('delivery cannot wait inside an application handler');
+        await owner.completion;
+    }
+    async collectApplicationEvent(page, event, payload, completed) {
+        this.ensureApplicationPageCurrent(page);
+        const key = this.applicationClaimKey(event, payload, page.namespace, page.context);
+        if (key) {
+            if (page.claims.has(key))
+                return;
+            const owner = this.applicationClaims.get(key);
+            if (owner) {
+                await this.waitForApplicationOwner(owner);
+                this.ensureApplicationPageCurrent(page);
+                return;
+            }
+            this.applicationClaims.set(key, page);
+            page.claims.add(key);
+        }
+        page.items.push({ event, payload });
+        page.commits.push(completed);
+    }
+    peerNamespace(senderAid) {
+        if (!senderAid.trim())
+            throw new Error('sender_aid is required');
+        return `p2p.peer.v1/${Buffer.from(senderAid, 'utf8').toString('base64url')}`;
+    }
+    async runPeerPageSerialized(namespace, operation) {
+        const previous = this.peerPageChains.get(namespace) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(operation);
+        this.peerPageChains.set(namespace, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (this.peerPageChains.get(namespace) === current)
+                this.peerPageChains.delete(namespace);
+            if (this.peerCatalogDirty && this.peerPageChains.size === 0 && this.peerRecoveryTasks.size === 0)
+                this.refreshPendingPeers();
+        }
+    }
+    hasPeerPageActivity(namespace) {
+        return this.peerPageChains.has(namespace);
+    }
+    peerAckChanged() {
+        this.requestBackgroundPullRecovery();
+    }
+    peerPullPriority(namespace) {
+        this.ensurePeerContext();
+        return this.peerPullHints.get(namespace) ?? Math.max(this.peerPullConfirmedThrough.get(namespace) ?? 0, this.syncState(namespace).ack);
+    }
+    consumePeerPullHint(namespace, coveredThroughSeq, nextPendingSeq) {
+        const hint = this.peerPullPriority(namespace);
+        if (coveredThroughSeq < (this.peerPullConfirmedThrough.get(namespace) ?? 0))
+            return;
+        this.peerPullConfirmedThrough.set(namespace, coveredThroughSeq);
+        if (hint !== null && hint <= coveredThroughSeq)
+            this.peerPullHints.delete(namespace);
+        if (nextPendingSeq !== undefined && nextPendingSeq > coveredThroughSeq) {
+            this.peerPullHints.set(namespace, Math.max(this.peerPullHints.get(namespace) ?? 0, nextPendingSeq));
+        }
+    }
+    peerSender(namespace) {
+        return namespace.startsWith('p2p.peer.v1/') ? Buffer.from(namespace.slice(12), 'base64url').toString('utf8') : '';
+    }
+    ensurePeerContext() {
+        const client = this.runtime.client;
+        const context = JSON.stringify([client._aid ?? '', client._deviceId ?? '', slotIsolationKey(client._slotId)]);
+        if (context !== this.peerContext || client._seqTracker !== this.peerTracker) {
+            this.peerContext = context;
+            this.peerTracker = client._seqTracker;
+            this.peerContextGeneration += 1;
+            this.peerBootstrap = null;
+            this.initializedPeers.clear();
+            this.committedSeqTrackerStates.clear();
+            this.seqTrackerNamespaceGenerations.clear();
+            this.peerVolatileCursors.clear();
+            this.peerRecoveryNeeds.clear();
+            this.peerPullHints.clear();
+            this.peerPullConfirmedThrough.clear();
+            this.peerRecoveryTasks.clear();
+            this.settledDeliveries.clear();
+            this.deliveryInflight.clear();
+            this.peerCatalogTask = null;
+            this.peerCatalogDirty = false;
+            this.peerCatalogQueries.clear();
+        }
+        return `${context}/${this.peerContextGeneration}`;
+    }
+    peerOwnType() {
+        const client = this.runtime.client;
+        try {
+            const current = client._currentAid;
+            if (!current?.isCertValid() || current.aid.toLowerCase() !== String(client._aid ?? '').toLowerCase())
+                return '';
+            const content = client._agentMdManager?.readContent?.(client._aid);
+            if (typeof content !== 'string' || !content)
+                return '';
+            const verified = current.verifyAgentMd(content);
+            if (!verified.ok || verified.data.status !== 'verified')
+                return '';
+            const type = parseFileFrontmatter(verified.data.payload).type;
+            return typeof type === 'string' ? type.trim() : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    async initializePeer(senderAid, initialAfterSeq) {
+        const client = this.runtime.client;
+        const context = this.ensurePeerContext();
+        const ns = this.peerNamespace(senderAid);
+        if (this.initializedPeers.has(ns)) {
+            if (client._seqTracker.snapshotNamespace(ns) !== null)
+                return ns;
+            this.initializedPeers.delete(ns);
+            this.committedSeqTrackerStates.delete(ns);
+        }
+        const hadState = client._seqTracker.snapshotNamespace(ns) !== null;
+        if (this.peerBootstrap === null)
+            await this.peers({}, true);
+        if (context !== this.ensurePeerContext())
+            throw new Error('peer initialization invalidated');
+        if (this.initializedPeers.has(ns))
+            return ns;
+        if (!hadState) {
+            if (initialAfterSeq === undefined) {
+                let pageToken;
+                do {
+                    const catalog = await this.peers({ filter: 'all', ...(pageToken ? { page_token: pageToken } : {}) }, true);
+                    if (context !== this.ensurePeerContext())
+                        throw new Error('peer initialization invalidated');
+                    if (this.initializedPeers.has(ns))
+                        return ns;
+                    pageToken = catalog.has_more === true ? String(catalog.next_page_token ?? '') : undefined;
+                    if (catalog.has_more === true && !pageToken)
+                        throw new Error('all peer catalog is incomplete');
+                } while (pageToken);
+            }
+            const initial = initialAfterSeq ?? this.peerBootstrap ?? 0;
+            if (!Number.isSafeInteger(initial) || initial < 0)
+                throw new Error('invalid peer initialization baseline');
+            client._seqTracker.forceContiguousSeq(ns, initial);
+        }
+        const state = { ...client._seqTracker.getSyncState(ns) };
+        await this.writeSeqTrackerState(client._aid, client._deviceId, client._slotId, { [ns]: state }, true);
+        if (context !== this.ensurePeerContext())
+            throw new Error('peer initialization invalidated');
+        this.committedSeqTrackerStates.set(ns, state);
+        this.initializedPeers.add(ns);
+        return ns;
+    }
+    peerCommittedAck(namespace) {
+        this.ensurePeerContext();
+        return Math.min(this.committedSeqTrackerStates.get(namespace)?.ack ?? 0, this.syncState(namespace).ack);
+    }
+    rememberCommittedSeqState(namespace) {
+        this.ensurePeerContext();
+        if (this.isReliableSeqNamespace(namespace) && !this.committedSeqTrackerStates.has(namespace)) {
+            this.committedSeqTrackerStates.set(namespace, { ...this.syncState(namespace) });
+        }
+    }
+    isReliableSeqNamespace(namespace) {
+        return namespace.startsWith('p2p.peer.v1/') || namespace.startsWith('group:') || namespace.startsWith('group_event:');
+    }
+    captureSeqNamespaceGeneration(namespace) {
+        return JSON.stringify([this.ensurePeerContext(), this.seqTrackerNamespaceGenerations.get(namespace) ?? 0]);
+    }
+    isSeqNamespaceGenerationCurrent(namespace, generation) {
+        return this.captureSeqNamespaceGeneration(namespace) === generation;
+    }
+    async peers(params = {}, background = false) {
+        const context = this.ensurePeerContext();
+        const key = JSON.stringify([context, params.filter ?? 'pending', params.limit ?? null, params.page_token ?? null]);
+        const existing = this.peerCatalogQueries.get(key);
+        if (existing) {
+            existing.application ||= !background;
+            return await existing.promise;
+        }
+        const query = { application: !background, promise: Promise.resolve({}) };
+        query.promise = this.queryPeers(params, () => !query.application);
+        this.peerCatalogQueries.set(key, query);
+        try {
+            return await query.promise;
+        }
+        finally {
+            if (this.peerCatalogQueries.get(key) === query)
+                this.peerCatalogQueries.delete(key);
+        }
+    }
+    async queryPeers(params, isBackground) {
+        const client = this.runtime.client;
+        const context = this.ensurePeerContext();
+        const generation = this.captureInlineAckGeneration();
+        const aid = client._aid;
+        const deviceId = client._deviceId;
+        const slotId = client._slotId;
+        const filter = String(params.filter ?? 'pending');
+        if (filter !== 'pending' && filter !== 'all')
+            throw new Error('invalid peers filter');
+        if (filter === 'pending' && ('limit' in params || 'page_token' in params))
+            throw new Error('pending peers cannot be paginated');
+        const raw = await client._rpcPipeline.rawCall('message.peers', {
+            ...params, filter, device_id: deviceId, slot_id: slotId,
+        }, { background: isBackground() });
+        if (context !== this.ensurePeerContext() || generation !== this.captureInlineAckGeneration())
+            throw new Error('peer catalog invalidated');
+        if (!raw || raw.cursor_scope !== 'peer' || raw.catalog_ready !== true || !Array.isArray(raw.peers))
+            throw new Error('peer catalog is not ready');
+        if (filter === 'pending' && (raw.has_more === true || raw.next_page_token))
+            throw new Error('pending peer catalog is incomplete');
+        const baseline = nonNegativeSafeSequenceHint(raw.bootstrap_floor_seq);
+        if (baseline === null)
+            throw new Error('invalid peer bootstrap_floor_seq');
+        if (this.peerBootstrap !== null && this.peerBootstrap !== baseline)
+            throw new Error('peer bootstrap changed');
+        if (this.peerBootstrap === null) {
+            const store = client._tokenStore;
+            const existing = await store.loadInstanceState?.(aid, deviceId, slotId);
+            if (context !== this.ensurePeerContext() || generation !== this.captureInlineAckGeneration())
+                throw new Error('peer catalog invalidated');
+            const saved = existing?.p2p_peer_bootstrap_floor_seq;
+            if (saved !== undefined && saved !== baseline)
+                throw new Error('persisted peer bootstrap changed');
+            if (typeof store.updateInstanceState !== 'function')
+                throw new Error('peer bootstrap persistence is unavailable');
+            await store.updateInstanceState(aid, deviceId, slotId, (state) => ({ ...state, p2p_peer_bootstrap_floor_seq: baseline }));
+            if (context !== this.ensurePeerContext() || generation !== this.captureInlineAckGeneration())
+                throw new Error('peer catalog invalidated');
+            this.peerBootstrap = baseline;
+        }
+        const rows = [];
+        for (const entry of raw.peers) {
+            if (!entry || typeof entry.sender_aid !== 'string' || !entry.sender_aid.trim())
+                throw new Error('peer catalog sender is invalid');
+            await this.initializePeer(entry.sender_aid, nonNegativeSafeSequenceHint(entry.initial_after_seq) ?? baseline);
+            if (context !== this.ensurePeerContext() || generation !== this.captureInlineAckGeneration())
+                throw new Error('peer catalog invalidated');
+            rows.push({ ...entry });
+        }
+        for (const row of rows) {
+            const ns = this.peerNamespace(String(row.sender_aid));
+            const hint = nonNegativeSafeSequenceHint(row.next_pending_seq);
+            const confirmed = Math.max(this.peerPullConfirmedThrough.get(ns) ?? 0, nonNegativeSafeSequenceHint(row.server_ack_seq) ?? nonNegativeSafeSequenceHint(row.initial_after_seq) ?? 0);
+            this.peerPullConfirmedThrough.set(ns, confirmed);
+            const current = this.peerPullHints.get(ns);
+            if (current !== undefined && current <= confirmed)
+                this.peerPullHints.delete(ns);
+            if (hint !== null && hint >= confirmed)
+                this.peerPullHints.set(ns, Math.max(this.peerPullHints.get(ns) ?? 0, hint));
+        }
+        const snapshot = {
+            ...raw, filter, peers: rows, aid, device_id: deviceId, slot_id: slotId,
+            trigger: isBackground() ? 'background' : 'application', peer_count: rows.length,
+        };
+        if (!isBackground() || rows.length > 0)
+            client._dispatcher.enqueue('message.peers_snapshot', snapshot, () => context === this.ensurePeerContext() && generation === this.captureInlineAckGeneration());
+        return snapshot;
+    }
+    async pullPeers(params = {}, background = false) {
+        const client = this.runtime.client;
+        const sender = String(params.sender_aid ?? '').trim();
+        if (!sender && ('after_seq' in params || 'after_volatile_cursor' in params || 'window_mode' in params || params.force === true))
+            throw new Error('explicit peer is required for after_seq, after_volatile_cursor, window_mode or force');
+        const snapshot = sender ? null : await this.peers({}, background);
+        const rows = sender ? [{ sender_aid: sender }] : snapshot.peers;
+        const budget = { remaining: Math.max(1, Math.trunc(Number(params.max_pages ?? 100) || 100)) };
+        const results = await Promise.all(rows.map(async (row) => {
+            const peer = String(row.sender_aid);
+            const ns = await this.initializePeer(peer);
+            try {
+                const state = this.syncState(ns);
+                if (!params.window_mode && params.force !== true && this.peerOwnType() === 'human' && state.head <= state.ack && budget.remaining > 0) {
+                    const tail = await client._v2E2EE.pullPeerV2(peer, { ...params, window_mode: 'tail', budget, background });
+                    if (!budget.remaining) {
+                        if (row.volatile_has_more)
+                            this.schedulePeerRecovery(peer, Number(tail.head_seq ?? 0), true);
+                        return { ...tail, complete: tail.complete && !row.volatile_has_more };
+                    }
+                    const forward = await client._v2E2EE.pullPeerV2(peer, { ...params, budget, background });
+                    const messages = [...new Map([...tail.messages, ...forward.messages].map((message) => [message.seq ?? message.volatile_cursor, message])).values()];
+                    return { ...forward, messages };
+                }
+                return await client._v2E2EE.pullPeerV2(peer, { ...params, budget, background });
+            }
+            catch (error) {
+                this.schedulePeerRecovery(peer, Number(row.head_seq ?? 0), Boolean(row.volatile_has_more));
+                return { sender_aid: peer, messages: [], complete: false, ack_seq: this.syncState(ns).ack, error: error instanceof Error ? error.message : String(error) };
+            }
+        }));
+        return { cursor_scope: 'peer', peers: results, messages: results.flatMap((row) => row.messages), partial: results.some((row) => !row.complete) };
+    }
+    refreshPendingPeers() {
+        const client = this.runtime.client;
+        if (client._sessionOptions?.background_sync === false || !client._aid || client._closing || client.state !== ConnectionState.READY)
+            return;
+        this.ensurePeerContext();
+        this.peerCatalogDirty = true;
+        if (this.peerCatalogTask)
+            return;
+        const generation = this.captureInlineAckGeneration();
+        const task = (async () => {
+            while (this.peerCatalogDirty && generation === this.captureInlineAckGeneration()) {
+                this.peerCatalogDirty = false;
+                const result = await this.peers({}, true);
+                const rows = [...result.peers];
+                const hint = (row) => this.peerPullPriority(this.peerNamespace(String(row.sender_aid)));
+                rows.sort((left, right) => hint(left) - hint(right));
+                for (const row of rows)
+                    this.schedulePeerRecovery(String(row.sender_aid), Number(row.head_seq ?? 0), Boolean(row.volatile_has_more));
+            }
+        })();
+        this.peerCatalogTask = task.then(() => ({}), () => ({}));
+        client._safeAsync(task.catch(() => {
+            if (generation !== this.captureInlineAckGeneration())
+                return;
+            const timer = setTimeout(() => { if (generation === this.captureInlineAckGeneration())
+                this.refreshPendingPeers(); }, BACKGROUND_PULL_RETRY_DELAY_MS);
+            timer.unref?.();
+        }).finally(() => { if (generation === this.captureInlineAckGeneration())
+            this.peerCatalogTask = null; }));
+    }
+    schedulePeerRecovery(sender, head = 0, volatile = false) {
+        const client = this.runtime.client;
+        if (client._sessionOptions?.background_sync === false || !sender || client._closing)
+            return;
+        this.ensurePeerContext();
+        const need = this.peerRecoveryNeeds.get(sender) ?? { head: 0, volatile: false, pending: false };
+        need.head = Math.max(need.head, head);
+        need.volatile ||= volatile;
+        need.pending = true;
+        this.peerRecoveryNeeds.set(sender, need);
+        if (this.peerRecoveryTasks.has(sender))
+            return;
+        const generation = this.captureInlineAckGeneration();
+        const task = (async () => {
+            await this.initializePeer(sender);
+            const state = this.syncState(this.peerNamespace(sender));
+            if (this.peerOwnType() === 'human' && need.head > state.head && state.ack >= state.tail - 1) {
+                await client._v2E2EE.pullPeerV2(sender, { window_mode: 'tail', background: true, retainMessages: false, budget: { remaining: 1 } });
+            }
+            while (generation === this.captureInlineAckGeneration() && this.peerRecoveryNeeds.has(sender)) {
+                need.pending = false;
+                const result = await client._v2E2EE.pullPeerV2(sender, { background: true, retainMessages: false, budget: { remaining: 100 } });
+                if (result.complete && result.ack_seq >= need.head && !need.pending) {
+                    this.peerRecoveryNeeds.delete(sender);
+                    break;
+                }
+                await new Promise((resolve) => setTimeout(resolve, BACKGROUND_PULL_RETRY_DELAY_MS));
+            }
+        })();
+        this.peerRecoveryTasks.set(sender, task);
+        client._safeAsync(task.catch(() => {
+            if (generation !== this.captureInlineAckGeneration())
+                return;
+            const timer = setTimeout(() => { if (generation === this.captureInlineAckGeneration())
+                this.schedulePeerRecovery(sender, need.head, need.volatile); }, BACKGROUND_PULL_RETRY_DELAY_MS);
+            timer.unref?.();
+        }).finally(() => {
+            if (generation === this.captureInlineAckGeneration()) {
+                this.peerRecoveryTasks.delete(sender);
+                if (this.peerCatalogDirty && this.peerRecoveryTasks.size === 0)
+                    this.refreshPendingPeers();
+            }
+        }));
+    }
     isPullOperationCurrent(namespace = '') {
         const pipeline = this.runtime.client._rpcPipeline;
         return typeof pipeline?.isPullNamespaceCurrent === 'function'
@@ -164,15 +652,13 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         const response = result;
         const volatileMessages = method === 'message.pull' ? this.volatileMessages(response.messages) : [];
-        if (volatileMessages.length > 0) {
-            await this.publishPlainVolatileMessages(volatileMessages, 'pull', true);
-        }
         this.ensurePullOperationCurrent(ns);
         this.syncStarted(ns);
         const messages = deduplicatePlainForwardPageMessages(response.messages, afterSeq);
         const coordinator = this.forwardCoordinator();
         const pageContigBefore = client._seqTracker.getContiguousSeq(ns);
         const pageInlineGeneration = this.captureInlineAckGeneration();
+        const namespaceGeneration = this.captureSeqNamespaceGeneration(ns);
         const deferredServerCursor = Number(coordinator.pendingForwardCursor(ns, pageContigBefore) ?? 0);
         const deferredForwardAck = Number(coordinator.pendingForwardAck(ns, pageContigBefore) ?? 0);
         let pageTrackerSnapshot = null;
@@ -196,44 +682,51 @@ export class MessageDeliveryEngine {
         let publishedCount = 0;
         let committed = false;
         try {
-            for (const rawMessage of messages) {
-                this.ensurePullOperationCurrent(ns);
-                const seq = positiveSafeSequenceHint(rawMessage.seq);
-                if (method === 'message.pull') {
-                    const appEvent = this.p2pAppEventForMessage(rawMessage);
-                    if (await this.publishPulledMessage(appEvent.event, ns, seq, appEvent.payload, false)) {
-                        publishedCount += 1;
-                    }
+            await this.runApplicationPage(ns, 'pull', async () => {
+                if (volatileMessages.length > 0)
+                    await this.publishPlainVolatileMessages(volatileMessages, 'pull', true);
+                for (const rawMessage of messages) {
                     this.ensurePullOperationCurrent(ns);
-                    continue;
-                }
-                const message = normalizeGroupMentionMode(rawMessage);
-                if (this.recallEventFromGroupMessage(message)) {
-                    if (await this.publishGroupRecallTombstone(groupId, seq, message, 'pull')) {
+                    const seq = positiveSafeSequenceHint(rawMessage.seq);
+                    if (method === 'message.pull') {
+                        const appEvent = this.p2pAppEventForMessage(rawMessage);
+                        if (await this.publishPulledMessage(appEvent.event, ns, seq, appEvent.payload, false)) {
+                            publishedCount += 1;
+                        }
                         this.ensurePullOperationCurrent(ns);
+                        continue;
+                    }
+                    const message = normalizeGroupMentionMode(rawMessage);
+                    if (this.recallEventFromGroupMessage(message)) {
+                        if (await this.publishGroupRecallTombstone(groupId, seq, message, 'pull')) {
+                            this.ensurePullOperationCurrent(ns);
+                            this.markPublishedSeq(ns, seq);
+                            publishedCount += 1;
+                        }
+                    }
+                    else if (this.isSelfSentGroupMessage(message)) {
                         this.markPublishedSeq(ns, seq);
+                    }
+                    else if (await this.publishPulledMessage('group.message_created', ns, seq, message, false)) {
+                        this.ensurePullOperationCurrent(ns);
                         publishedCount += 1;
                     }
                 }
-                else if (this.isSelfSentGroupMessage(message)) {
-                    this.markPublishedSeq(ns, seq);
-                }
-                else if (await this.publishPulledMessage('group.message_created', ns, seq, message, false)) {
-                    this.ensurePullOperationCurrent(ns);
-                    publishedCount += 1;
-                }
-            }
+                this.ensurePullOperationCurrent(ns);
+                if (pageInlineGeneration !== this.captureInlineAckGeneration())
+                    throw new Error('pull invalidated');
+                const previousWindow = client._seqTracker.getSyncState(ns);
+                const scanTarget = Math.max(pageContigBefore, ...messages.map((message) => positiveSafeSequenceHint(message.seq)), positiveSafeSequenceHint(response.contiguous_seq), retentionFloor, visibilityFloor, deferredServerCursor);
+                const deliveryTarget = scanTarget >= previousWindow.tail - 1
+                    ? Math.max(scanTarget, previousWindow.head) : scanTarget;
+                await this.drainOrderedMessages(ns, undefined, false, false, 'pull', undefined, deliveryTarget);
+            });
             this.ensurePullOperationCurrent(ns);
             if (pageInlineGeneration !== this.captureInlineAckGeneration())
                 throw new Error('pull invalidated');
-            const previousWindow = client._seqTracker.getSyncState(ns);
-            const scanTarget = Math.max(pageContigBefore, ...messages.map((message) => positiveSafeSequenceHint(message.seq)), positiveSafeSequenceHint(response.contiguous_seq), retentionFloor, visibilityFloor, deferredServerCursor);
-            const deliveryTarget = scanTarget >= previousWindow.tail - 1
-                ? Math.max(scanTarget, previousWindow.head) : scanTarget;
-            await this.drainOrderedMessages(ns, undefined, false, false, 'pull', undefined, deliveryTarget);
-            this.ensurePullOperationCurrent(ns);
-            if (pageInlineGeneration !== this.captureInlineAckGeneration())
+            if (!this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
                 throw new Error('pull invalidated');
+            this.rememberCommittedSeqState(ns);
             pageTrackerSnapshot = client._seqTracker.snapshotNamespace?.(ns) ?? null;
             trackerMutated = true;
             client._seqTracker.onPullResult(ns, messages, afterSeq, Number.isSafeInteger(result.contiguous_seq)
@@ -249,11 +742,14 @@ export class MessageDeliveryEngine {
                 this.ensurePullOperationCurrent(ns);
                 if (pageInlineGeneration !== this.captureInlineAckGeneration())
                     throw new Error('pull invalidated');
+                if (!this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
+                    throw new Error('pull invalidated');
             }
             committed = true;
         }
         catch (exc) {
             if (trackerMutated && pageInlineGeneration === this.captureInlineAckGeneration() && this.isPullOperationCurrent(ns)
+                && this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration)
                 && !committed && typeof client._seqTracker.restoreNamespaceSnapshot === 'function') {
                 (client._seqTracker._restoreNamespaceSnapshotPreservingPush ?? client._seqTracker.restoreNamespaceSnapshot)
                     .call(client._seqTracker, ns, pageTrackerSnapshot);
@@ -324,23 +820,39 @@ export class MessageDeliveryEngine {
         this.volatileCursor = '';
         this.volatileSeenMessages.clear();
         this.volatileInFlightMessages.clear();
+        for (const completion of this.volatileCompletions.values())
+            completion.reject(new Error('delivery invalidated'));
+        this.volatileCompletions.clear();
     }
     volatilePullCursor() {
         this.ensureVolatileContext();
         return this.volatileCursor;
     }
+    peerVolatilePullCursor(sender) {
+        this.ensurePeerContext();
+        return this.peerVolatileCursors.get(sender) ?? '';
+    }
+    setPeerVolatilePullCursor(sender, cursor) {
+        this.ensurePeerContext();
+        if (cursor)
+            this.peerVolatileCursors.set(sender, cursor);
+        else
+            this.peerVolatileCursors.delete(sender);
+    }
     resetVolatilePullCursor() {
         this.ensureVolatileContext();
         this.volatileCursor = '';
     }
     volatileSeenKey(message) {
         const messageId = String(message.message_id ?? '').trim();
-        const sender = String(message.from_aid ?? message.from ?? '').trim();
+        const sender = String(message.sender_aid ?? message.from_aid ?? message.from ?? '').trim();
         const cursor = String(message.volatile_cursor ?? '').trim();
-        return `${sender}|${messageId || cursor}`;
+        return JSON.stringify([sender, messageId, cursor]);
     }
     isVolatileSeen(message) {
         this.ensureVolatileContext();
+        if (this.currentApplicationPage()?.volatileSeen.has(this.volatileSeenKey(message)))
+            return true;
         const now = Date.now();
         for (const [key, expiresAt] of this.volatileSeenMessages) {
             if (expiresAt <= now)
@@ -350,6 +862,12 @@ export class MessageDeliveryEngine {
     }
     markVolatileSeen(message) {
         this.ensureVolatileContext();
+        const page = this.currentApplicationPage();
+        if (page) {
+            page.volatileSeen.add(this.volatileSeenKey(message));
+            page.commits.push(() => this.markVolatileSeen(message));
+            return;
+        }
         const now = Date.now();
         const expiresAt = Math.max(now + 60_000, Number(message.expires_at ?? now + 1_800_000) || now + 1_800_000);
         this.volatileSeenMessages.set(this.volatileSeenKey(message), expiresAt);
@@ -367,11 +885,38 @@ export class MessageDeliveryEngine {
         if (this.volatileInFlightMessages.has(key))
             return 'inflight';
         this.volatileInFlightMessages.add(key);
+        let resolve, reject;
+        const promise = new Promise((done, fail) => { resolve = done; reject = fail; });
+        void promise.catch(() => { });
+        const page = this.currentApplicationPage();
+        const completion = { page, promise, resolve, reject };
+        this.volatileCompletions.set(key, completion);
+        if (page)
+            void page.completion.then(resolve, reject).finally(() => {
+                if (this.volatileCompletions.get(key) === completion) {
+                    this.volatileCompletions.delete(key);
+                    this.volatileInFlightMessages.delete(key);
+                }
+            });
         return 'claimed';
     }
+    async waitVolatileDelivery(message) {
+        const completion = this.volatileCompletions.get(this.volatileSeenKey(message));
+        if (!completion || completion.page === this.currentApplicationPage())
+            return;
+        if (this.runtime.client._dispatcher._isApplicationHandler?.())
+            throw new Error('delivery cannot wait inside an application handler');
+        await completion.promise;
+    }
     finishVolatileDelivery(message) {
         this.ensureVolatileContext();
-        this.volatileInFlightMessages.delete(this.volatileSeenKey(message));
+        const key = this.volatileSeenKey(message);
+        const completion = this.volatileCompletions.get(key);
+        if (completion?.page)
+            return;
+        completion?.resolve();
+        this.volatileCompletions.delete(key);
+        this.volatileInFlightMessages.delete(key);
     }
     publicVolatileMessage(message) {
         const result = this.stripInternalSenderDeviceFields(message);
@@ -379,15 +924,27 @@ export class MessageDeliveryEngine {
         return result;
     }
     async ackVolatileMessages(messages, v2, advanceCursor) {
+        const page = this.currentApplicationPage();
+        if (page) {
+            page.afterDelivery.push(() => this.ackVolatileMessages(messages, v2, advanceCursor));
+            return undefined;
+        }
         const cursors = [...new Set(messages
                 .map((message) => String(message.volatile_cursor ?? '').trim())
                 .filter(Boolean))];
         if (cursors.length === 0)
             return undefined;
-        const result = await this.runtime.client._callRawV2Rpc(v2 ? 'message.v2.ack' : 'message.ack', { volatile_cursors: cursors, _rpc_background: true });
+        const client = this.runtime.client;
+        const sender = client._p2pPeerPullEnabled ? String(messages[0]?.sender_aid ?? messages[0]?.from_aid ?? messages[0]?.from ?? '') : '';
+        const result = sender
+            ? await client._v2E2EE.ackPeerV2(sender, 0, cursors)
+            : await client._callRawV2Rpc(v2 ? 'message.v2.ack' : 'message.ack', { volatile_cursors: cursors, _rpc_background: true });
         if (advanceCursor) {
             this.ensureVolatileContext();
-            this.volatileCursor = cursors[cursors.length - 1] ?? '';
+            if (sender)
+                this.setPeerVolatilePullCursor(sender, cursors[cursors.length - 1] ?? '');
+            else
+                this.volatileCursor = cursors[cursors.length - 1] ?? '';
         }
         return result;
     }
@@ -400,8 +957,12 @@ export class MessageDeliveryEngine {
                 processed.push(rawMessage);
                 continue;
             }
-            if (claim === 'inflight')
+            if (claim === 'inflight') {
+                await this.waitVolatileDelivery(message);
+                if (this.isVolatileSeen(message))
+                    processed.push(rawMessage);
                 continue;
+            }
             try {
                 const appEvent = this.p2pAppEventForMessage(message);
                 await this.runtime.client._publishAppEvent(appEvent.event, appEvent.payload, source);
@@ -422,6 +983,13 @@ export class MessageDeliveryEngine {
         this.deliveryChangedGeneration += 1;
         this.pendingDeliveryChanges = null;
         this.inlineAckGeneration += 1;
+        if (this.backgroundPullTimer)
+            clearTimeout(this.backgroundPullTimer);
+        this.backgroundPullTimer = null;
+        this.backgroundPullTimerAt = 0;
+        this.backgroundPullNeeds.clear();
+        this.backgroundPullTasks.clear();
+        this.backgroundPullCheckQueued = false;
         void this.runtime.client._rpcPipeline?.invalidatePulls?.();
         this.pendingP2PInlineAcks = null;
         this.pendingGroupInlineAcks = null;
@@ -432,6 +1000,12 @@ export class MessageDeliveryEngine {
         this.onlineUnreadHintTasks = null;
         this.realtimeTailHeads = null;
         this.syncSessions = null;
+        this.peerCatalogTask = null;
+        this.peerCatalogDirty = false;
+        this.peerRecoveryNeeds.clear();
+        this.peerPullHints.clear();
+        this.peerPullConfirmedThrough.clear();
+        this.peerRecoveryTasks.clear();
     }
     deliveryChangedNamespace(event, payload) {
         if (event === 'group.message_created' && isJsonObject(payload)) {
@@ -693,6 +1267,7 @@ export class MessageDeliveryEngine {
     }
     endRealtimeSync(ns) {
         this.realtimeSyncing?.delete(ns);
+        this.requestBackgroundPullRecovery();
         this.runtime.client._rpcPipeline?.requestPullDrainedCheck?.();
     }
     hasPendingPull(ns) {
@@ -702,7 +1277,9 @@ export class MessageDeliveryEngine {
         return this.pendingGroupPullUpper?.get(ns) ?? 0;
     }
     hasAnyPendingPull() {
-        return [...(this.pendingGroupPullUpper?.values() ?? [])].some((seq) => seq > 0)
+        return this.peerCatalogDirty || this.peerRecoveryNeeds.size > 0 || this.peerRecoveryTasks.size > 0 || Boolean(this.peerCatalogTask)
+            || [...(this.pendingGroupPullUpper?.values() ?? [])].some((seq) => seq > 0)
+            || this.backgroundPullNeeds.size > 0
             || Boolean(this.onlineUnreadHintTasks?.size)
             || Boolean(this.realtimeSyncing?.size)
             || Boolean(this.runtime.client._v2E2EE?.hasPendingSenderIKWork?.());
@@ -710,14 +1287,136 @@ export class MessageDeliveryEngine {
     onPullGateIdle(ns) {
         if (!ns)
             return;
+        this.requestBackgroundPullRecovery();
         if (ns.startsWith('p2p:')) {
             this.runtime.client._schedulePendingP2pPullIfNeeded?.(ns, 'pull-gate-idle');
             return;
         }
         this.schedulePendingGroupPullIfNeeded(ns, 'pull-gate-idle');
     }
+    recordBackgroundPullNeed(ns, throughSeq = 0, probe = false) {
+        const client = this.runtime.client;
+        if (client._sessionOptions?.background_sync === false || !client._aid
+            || !(ns === `p2p:${client._aid}` || ns.startsWith('group:') || ns.startsWith('group_event:')))
+            return;
+        const need = this.backgroundPullNeeds.get(ns) ?? {
+            throughSeq: 0, hasMore: false, probe, lastAfter: -1, retryAt: 0,
+        };
+        need.throughSeq = Math.max(need.throughSeq, throughSeq);
+        need.probe ||= probe;
+        this.backgroundPullNeeds.set(ns, need);
+    }
+    observeBackgroundPullResponse(ns, afterSeq, result, limit = 50) {
+        if (!isJsonObject(result))
+            return;
+        const response = result;
+        const rows = ns.startsWith('group_event:') ? response.events : response.messages;
+        if (!Array.isArray(rows))
+            return;
+        const cursor = isJsonObject(response.cursor)
+            ? response.cursor : null;
+        const throughSeq = Math.max(positiveSafeSequenceHint(cursor?.latest_seq), positiveSafeSequenceHint(response.latest_seq), positiveSafeSequenceHint(response.latest_message_seq), positiveSafeSequenceHint(response.latest_event_seq), ...rows.map((row) => row && typeof row === 'object' && row.storage !== 'volatile'
+            ? positiveSafeSequenceHint(row.seq ?? row.event_seq) : 0));
+        this.recordBackgroundPullNeed(ns, throughSeq);
+        const need = this.backgroundPullNeeds.get(ns);
+        if (!need || afterSeq < need.lastAfter)
+            return;
+        need.lastAfter = afterSeq;
+        need.hasMore = response.has_more === true || positiveSafeSequenceHint(response.remaining) > 0
+            || (!('has_more' in response) && limit > 0 && rows.length >= limit);
+        need.probe = false;
+    }
+    finishBackgroundPull(ns, generation, afterSeq, failed) {
+        if (generation !== this.captureInlineAckGeneration())
+            return;
+        const need = this.backgroundPullNeeds.get(ns);
+        if (need) {
+            if (failed)
+                need.probe = true;
+            else
+                need.probe = false;
+            need.retryAt = failed || this.syncState(ns).ack <= afterSeq
+                ? Date.now() + BACKGROUND_PULL_RETRY_DELAY_MS : 0;
+        }
+        this.requestBackgroundPullRecovery();
+    }
+    requestBackgroundPullRecovery() {
+        if (this.backgroundPullCheckQueued || (this.backgroundPullNeeds.size === 0 && !this.peerCatalogDirty && this.peerRecoveryNeeds.size === 0))
+            return;
+        this.backgroundPullCheckQueued = true;
+        const generation = this.captureInlineAckGeneration();
+        queueMicrotask(() => {
+            this.backgroundPullCheckQueued = false;
+            if (generation !== this.captureInlineAckGeneration())
+                return;
+            const client = this.runtime.client;
+            if (client._sessionOptions?.background_sync === false || client.state !== ConnectionState.READY || client._closing)
+                return;
+            if (client._p2pPeerPullEnabled) {
+                if (this.peerCatalogDirty && !this.peerCatalogTask)
+                    this.refreshPendingPeers();
+                for (const [sender, need] of this.peerRecoveryNeeds) {
+                    if (!this.peerRecoveryTasks.has(sender))
+                        this.schedulePeerRecovery(sender, need.head, need.volatile);
+                }
+            }
+            let retryAt = Infinity;
+            for (const [ns, need] of this.backgroundPullNeeds) {
+                if (this.backgroundPullTasks.has(ns) || this.realtimeSyncing?.has(ns) || this.onlineUnreadHintTasks?.has(ns))
+                    continue;
+                const eventScope = ns.startsWith('group_event:');
+                const filling = [...(client._gapFillDone?.keys?.() ?? [])].some((key) => eventScope
+                    ? String(key) === `group_event_pull:${ns}`
+                    : ns.startsWith('p2p:') ? String(key).startsWith('p2p:') : String(key).startsWith(`group_msg:${ns.slice(6)}:`));
+                if (filling || (!eventScope && client._rpcPipeline?.hasPullActivity?.(ns, false))
+                    || (eventScope && ['pulling', 'processing', 'pulled'].includes(client._rpcPipeline?.getPullLifecycle?.(ns))))
+                    continue;
+                if (this.syncState(ns).ack >= need.throughSeq && !need.hasMore && !need.probe) {
+                    this.backgroundPullNeeds.delete(ns);
+                    continue;
+                }
+                if (need.retryAt > Date.now()) {
+                    retryAt = Math.min(retryAt, need.retryAt);
+                    continue;
+                }
+                this.backgroundPullTasks.add(ns);
+                const task = Promise.resolve().then(() => {
+                    if (generation !== this.captureInlineAckGeneration())
+                        return;
+                    return eventScope ? this.fillGroupEventGap(ns.slice('group_event:'.length))
+                        : ns.startsWith('group:') ? this.fillGroupGap(ns.slice(6)) : this.fillP2pGap();
+                }).finally(() => {
+                    if (generation !== this.captureInlineAckGeneration())
+                        return;
+                    this.backgroundPullTasks.delete(ns);
+                    this.requestBackgroundPullRecovery();
+                });
+                client._safeAsync(task);
+            }
+            if (this.backgroundPullNeeds.size === 0) {
+                if (this.backgroundPullTimer)
+                    clearTimeout(this.backgroundPullTimer);
+                this.backgroundPullTimer = null;
+                this.backgroundPullTimerAt = 0;
+                client._rpcPipeline?.requestPullDrainedCheck?.();
+            }
+            if (Number.isFinite(retryAt) && (!this.backgroundPullTimer || retryAt < this.backgroundPullTimerAt)) {
+                if (this.backgroundPullTimer)
+                    clearTimeout(this.backgroundPullTimer);
+                this.backgroundPullTimerAt = retryAt;
+                this.backgroundPullTimer = setTimeout(() => {
+                    this.backgroundPullTimer = null;
+                    this.backgroundPullTimerAt = 0;
+                    this.requestBackgroundPullRecovery();
+                }, Math.max(0, retryAt - Date.now()));
+                this.backgroundPullTimer.unref?.();
+            }
+        });
+    }
     onForegroundPullsDrained() {
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled)
+            return;
         if (!client._aid || client._sessionOptions?.background_sync === false
             || client.state !== ConnectionState.READY || client._closing)
             return;
@@ -771,6 +1470,12 @@ export class MessageDeliveryEngine {
         }
     }
     markPublishedSeq(ns, seq) {
+        const page = this.currentApplicationPage();
+        if (page) {
+            page.consumed.add(JSON.stringify(['published', ns, seq]));
+            page.commits.push(() => this.markPublishedSeq(ns, seq));
+            return;
+        }
         const client = this.runtime.client;
         let pushed = client._pushedSeqs.get(ns);
         if (!pushed) {
@@ -783,6 +1488,18 @@ export class MessageDeliveryEngine {
             client._pushedSeqs.set(ns, new Set(keep));
         }
     }
+    hasPublishedSeq(ns, seq) {
+        return this.runtime.client._pushedSeqs.get(ns)?.has(seq) === true
+            || this.currentApplicationPage()?.consumed.has(JSON.stringify(['published', ns, seq])) === true;
+    }
+    consumeOrderedMessage(ns, seq, queue) {
+        this.currentApplicationPage()?.consumed.add(JSON.stringify(['ordered', ns, seq]));
+        this.completeApplicationDelivery(() => {
+            queue?.delete(seq);
+            if (queue?.size === 0)
+                this.runtime.client._pendingOrderedMsgs.delete(ns);
+        });
+    }
     enqueueOrderedMessage(ns, event, seq, payload, source = 'push') {
         const client = this.runtime.client;
         let queue = client._pendingOrderedMsgs.get(ns);
@@ -833,21 +1550,38 @@ export class MessageDeliveryEngine {
     async publishOrderedGroupChanged(payload, source = 'ordered') {
         const client = this.runtime.client;
         const generation = this.captureInlineAckGeneration();
+        const scope = this.applicationPage.getStore();
+        const page = scope?.collecting ? scope : undefined;
+        const owner = this.applicationClaims.get(this.applicationClaimKey('group.changed', payload, this.applicationNamespace('group.changed', payload), this.ensurePeerContext()));
+        if (owner) {
+            if (owner !== this.currentApplicationPage())
+                await this.waitForApplicationOwner(owner);
+            if (generation !== this.captureInlineAckGeneration())
+                throw new Error('pull invalidated');
+            return;
+        }
         const published = client._publishAppEvent('group.changed', payload, source);
         if (isPromiseLike(published))
             await published;
         if (generation !== this.captureInlineAckGeneration())
             throw new Error('pull invalidated');
-        if (isJsonObject(payload)) {
-            const eventPayload = payload;
-            client._groupState?.handleGroupChangedV2Membership?.(eventPayload);
-            if (eventPayload.action === 'dissolved') {
-                const rawGroupId = eventPayload.group_id ?? eventPayload.group_aid ?? '';
-                const groupId = String(rawGroupId).trim();
-                if (groupId)
-                    client._cleanupDissolvedGroup?.(groupId);
+        this.completeApplicationDelivery(() => {
+            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) {
+                        const cleanup = () => { client._cleanupDissolvedGroup?.(groupId); };
+                        if (page)
+                            page.cleanup.push(cleanup);
+                        else
+                            cleanup();
+                    }
+                }
             }
-        }
+        });
     }
     isInstanceScopedMessageEvent(event) {
         return event === 'message.received'
@@ -951,6 +1685,7 @@ export class MessageDeliveryEngine {
         setIfPresent('timestamp', firstValue(message.timestamp, message.created_at, message.t_server));
         if ('encrypted' in message)
             envelope.encrypted = Boolean(message.encrypted);
+        envelope.need_render = message.need_render !== false;
         const context = this.envelopeMetadata(message.context);
         if (context)
             envelope.context = context;
@@ -1018,6 +1753,7 @@ export class MessageDeliveryEngine {
         setIfPresent('version', firstValue(body.version, params.version));
         setIfPresent('timestamp', firstValue(params.timestamp, resultObj.timestamp, resultObj.created_at, resultObj.t_server, Date.now()));
         envelope.encrypted = Boolean(encrypted);
+        envelope.need_render = params.need_render !== false;
         const context = this.envelopeMetadata(params.context);
         if (context)
             envelope.context = context;
@@ -1179,12 +1915,14 @@ export class MessageDeliveryEngine {
             throw new Error('pull invalidated');
         if (this.isPullScopedSource(source))
             this.ensurePullOperationCurrent(`p2p:${client._aid ?? ''}`);
-        seen.set(dedupKey, Date.now());
-        if (seen.size > MESSAGE_RECALL_SEEN_LIMIT) {
-            const drop = [...seen.entries()].sort((a, b) => a[1] - b[1]).slice(0, seen.size - MESSAGE_RECALL_SEEN_LIMIT);
-            for (const [oldKey] of drop)
-                seen.delete(oldKey);
-        }
+        this.completeApplicationDelivery(() => {
+            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;
     }
@@ -1290,12 +2028,14 @@ export class MessageDeliveryEngine {
             throw new Error('pull invalidated');
         if (this.isPullScopedSource(source))
             this.ensurePullOperationCurrent(`group:${groupId}`);
-        seen.set(dedupKey, Date.now());
-        if (seen.size > GROUP_RECALL_SEEN_LIMIT) {
-            const drop = [...seen.entries()].sort((a, b) => a[1] - b[1]).slice(0, seen.size - GROUP_RECALL_SEEN_LIMIT);
-            for (const [oldKey] of drop)
-                seen.delete(oldKey);
-        }
+        this.completeApplicationDelivery(() => {
+            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;
     }
@@ -1340,9 +2080,18 @@ export class MessageDeliveryEngine {
         if (seqNum > client._seqTracker.getContiguousSeq(ns) && client._sessionOptions?.background_sync !== false) {
             this.fillGroupGap(groupId).catch((exc) => client._clientLog.warn(`background recall gap fill failed: ${formatDeliveryError(exc)}`));
         }
+        await this.publishGroupRecallTombstone(groupId, seq, wrapped);
     }
     publishAppEvent(event, payload, source = 'direct', deliveryContext) {
         const client = this.runtime.client;
+        const scope = this.applicationPage.getStore();
+        const page = scope?.collecting ? scope : undefined;
+        if (APPLICATION_DELIVERY_EVENTS.has(event) && typeof client._dispatcher._snapshotApplicationHandlers === 'function') {
+            const namespace = this.applicationNamespace(event, payload);
+            if (!page || (page.namespace !== namespace && !(page.namespace.startsWith('p2p:') && event.startsWith('message.')))) {
+                return this.runApplicationPage(namespace, source, async () => { await this.publishAppEvent(event, payload, source, deliveryContext); });
+            }
+        }
         if ((event === 'message.received' || event === 'group.message_created') && isJsonObject(payload)) {
             client._maybeAppendEchoTraceReceive(payload);
         }
@@ -1363,22 +2112,33 @@ export class MessageDeliveryEngine {
         }
         const generation = this.deliveryChangedGeneration;
         const normalized = this.normalizePublishedMessagePayload(event, payload, source);
+        const note = () => {
+            if (generation === this.deliveryChangedGeneration) {
+                this.noteDeliveryChanged(event, payload, source, deliveryContext);
+            }
+        };
+        if (page && APPLICATION_DELIVERY_EVENTS.has(event)) {
+            if (page.batching)
+                return this.collectApplicationEvent(page, event, normalized, note);
+            const owner = this.applicationClaims.get(this.applicationClaimKey(event, normalized, page.namespace, page.context));
+            if (owner)
+                return this.waitForApplicationOwner(owner).then(() => this.ensureApplicationPageCurrent(page));
+        }
         const dispatcher = client._dispatcher;
         const result = ['message.received', 'group.message_created', 'message.recalled', 'group.message_recalled', 'group.changed'].includes(event)
             && typeof dispatcher._publishAndWait === 'function'
-            ? dispatcher._publishAndWait(event, normalized)
+            ? dispatcher._publishAndWait(event, normalized, undefined, page?.reservation, page ? () => this.isApplicationPageCurrent(page) : undefined)
             : typeof dispatcher.enqueue === 'function'
                 ? (dispatcher.enqueue(event, normalized), undefined)
                 : typeof dispatcher.publishSyncAware === 'function'
                     ? dispatcher.publishSyncAware(event, normalized)
                     : dispatcher.publish?.(event, normalized);
-        const note = () => {
-            if (generation === this.deliveryChangedGeneration) {
-                this.noteDeliveryChanged(event, payload, source, deliveryContext);
-            }
-        };
         if (isPromiseLike(result))
-            return Promise.resolve(result).then(note);
+            return Promise.resolve(result).then(() => {
+                if (page && APPLICATION_DELIVERY_EVENTS.has(event))
+                    this.ensureApplicationPageCurrent(page);
+                note();
+            });
         note();
         return result;
     }
@@ -1575,6 +2335,10 @@ export class MessageDeliveryEngine {
     }
     async onRawMessageReceived(data) {
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled) {
+            await this.onPeerPush(data);
+            return;
+        }
         const tStart = Date.now();
         if (isJsonObject(data)) {
             client._logMessageDebug('server-push', '_raw.message.received', 'message.received', data);
@@ -1617,6 +2381,11 @@ export class MessageDeliveryEngine {
         if (!this.messageTargetsCurrentInstance(msg))
             return;
         const seq = msg.seq;
+        if (client._p2pPeerPullEnabled) {
+            await this.onPeerPush(msg);
+            await this.publishMessageRecallTombstone(seq, msg);
+            return;
+        }
         if (seq !== undefined && seq !== null && client._aid) {
             const ns = `p2p:${client._aid}`;
             const seqNum = Number(seq);
@@ -1625,7 +2394,6 @@ export class MessageDeliveryEngine {
             if (Number(seq) > client._seqTracker.getContiguousSeq(ns) && client._sessionOptions?.background_sync !== false) {
                 this.fillP2pGap().catch((exc) => client._clientLog.warn(`background recall gap fill failed: ${formatDeliveryError(exc)}`));
             }
-            return;
         }
         await this.publishMessageRecallTombstone(seq, msg);
     }
@@ -1806,13 +2574,13 @@ export class MessageDeliveryEngine {
         const afterSeq = client._seqTracker.getContiguousSeq(ns);
         client._clientLog.debug(`auto pull group messages start: group=${groupId}, after_seq=${afterSeq}, seq=${String(notification.seq ?? '')}`);
         const operation = async () => {
-            const messages = await client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true });
+            const messages = await client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true, background: true });
             this.prunePushedSeqs(ns);
             return messages.length;
         };
         if (client._rpcPipeline) {
             const key = client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, after_seq: afterSeq, limit: 50 });
-            await client._rpcPipeline.runPullSerialized(key, operation, true);
+            await client._rpcPipeline.runPullNamespaceSerialized(key, operation, true);
         }
         else {
             await client._withBackgroundRpc(operation);
@@ -1820,18 +2588,25 @@ export class MessageDeliveryEngine {
     }
     async fillP2pGap() {
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled) {
+            this.refreshPendingPeers();
+            return;
+        }
         if (client._sessionOptions?.background_sync === false)
             return;
         if (!client._aid)
             return;
         const ns = `p2p:${client._aid}`;
         const afterSeq = client._seqTracker.getContiguousSeq(ns);
+        const generation = this.captureInlineAckGeneration();
         const dedupKey = `p2p:${afterSeq}`;
         if (client._gapFillDone.has(dedupKey))
             return;
         client._gapFillDone.set(dedupKey, Date.now());
+        this.recordBackgroundPullNeed(ns, 0, true);
         client._clientLog.debug(`P2P message gap fill start: after_seq=${afterSeq}`);
         let filled = 0;
+        let failed = false;
         try {
             // Gap Fill 本身就是 Forward Pull，必须沿用协调器的完整事务：
             // 原始页提交成功后由协调器负责 Piggyback/终端 ACK。
@@ -1844,11 +2619,15 @@ export class MessageDeliveryEngine {
             client._clientLog.debug(`P2P message gap fill done: after_seq=${afterSeq}, filled=${filled}`);
         }
         catch (exc) {
+            failed = true;
             client._clientLog.warn(`P2P message gap fill failed: ${formatDeliveryError(exc)}`);
         }
         finally {
+            if (generation !== this.captureInlineAckGeneration())
+                return;
             client._gapFillDone.delete(dedupKey);
             client._schedulePendingP2pPullIfNeeded?.(ns, 'gap-fill-complete');
+            this.finishBackgroundPull(ns, generation, afterSeq, failed);
         }
     }
     async fillGroupGap(groupId) {
@@ -1860,30 +2639,34 @@ export class MessageDeliveryEngine {
             return;
         const ns = `group:${groupId}`;
         const afterSeq = client._seqTracker.getContiguousSeq(ns);
+        const generation = this.captureInlineAckGeneration();
         const dedupKey = `group_msg:${groupId}:${afterSeq}`;
         if (client._gapFillDone.has(dedupKey))
             return;
         client._gapFillDone.set(dedupKey, Date.now());
+        this.recordBackgroundPullNeed(ns, 0, true);
         client._clientLog.debug(`group message gap fill start: group=${groupId}, after_seq=${afterSeq}`);
         let filled = 0;
+        let failed = false;
         try {
-            const operation = () => client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true });
+            const operation = () => client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true, background: true });
             const messages = client._rpcPipeline
-                ? await client._rpcPipeline.runPullSerialized(client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, after_seq: afterSeq, limit: 50 }), operation, true)
+                ? await client._rpcPipeline.runPullNamespaceSerialized(client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, after_seq: afterSeq, limit: 50 }), operation, true)
                 : await client._withBackgroundRpc(operation);
             filled = messages.length;
             this.prunePushedSeqs(ns);
             client._clientLog.debug(`group message gap fill done: group=${groupId}, after_seq=${afterSeq}, filled=${filled}`);
         }
         catch (exc) {
+            failed = true;
             client._clientLog.warn(`group message gap fill failed: ${formatDeliveryError(exc)}`);
         }
         finally {
+            if (generation !== this.captureInlineAckGeneration())
+                return;
             client._gapFillDone.delete(dedupKey);
-            if (filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
-                void this.fillGroupGap(groupId);
-            }
             this.schedulePendingGroupPullIfNeeded(ns, 'gap-fill-complete');
+            this.finishBackgroundPull(ns, generation, afterSeq, failed);
         }
     }
     scheduleRealtimeWindowForward(ns, groupId = '') {
@@ -1944,6 +2727,7 @@ export class MessageDeliveryEngine {
             }
         }
         client._gapFillDone.set(dedupKey, Date.now());
+        this.recordBackgroundPullNeed(ns, client._seqTracker.getMaxSeenSeq(ns), true);
         this.syncStarted(ns);
         let filled = 0;
         let continuationAfterSeq = 0;
@@ -1974,10 +2758,14 @@ export class MessageDeliveryEngine {
                 }
                 if (!isJsonObject(result))
                     return;
+                if (generation !== this.captureInlineAckGeneration())
+                    return;
+                this.observeBackgroundPullResponse(ns, nextAfterSeq, result);
                 const events = result.events;
                 if (!Array.isArray(events))
                     return;
                 const pageContigBefore = client._seqTracker.getContiguousSeq(ns);
+                const namespaceGeneration = this.captureSeqNamespaceGeneration(ns);
                 let pageTrackerSnapshot = null;
                 let trackerMutated = false;
                 const eventObjects = events.filter((evt) => isJsonObject(evt));
@@ -1993,35 +2781,37 @@ 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') {
-                        const cs = evt.client_signature;
-                        if (cs && isJsonObject(cs)) {
-                            if (client._shouldSkipEventSignature(evt)) {
-                                delete evt.client_signature;
-                            }
-                            else {
-                                evt._verified = await client._verifyEventSignatureAsync(evt, cs);
+                try {
+                    await this.runApplicationPage(ns, 'pull', async () => {
+                        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') {
+                                const cs = evt.client_signature;
+                                if (cs && isJsonObject(cs)) {
+                                    if (client._shouldSkipEventSignature(evt)) {
+                                        delete evt.client_signature;
+                                    }
+                                    else {
+                                        evt._verified = await client._verifyEventSignatureAsync(evt, cs);
+                                    }
+                                }
+                                if (Number.isFinite(eventSeq) && eventSeq > 0 && !client._pushedSeqs.get(ns)?.has(eventSeq)) {
+                                    this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, evt, 'pull');
+                                    publishedEventCount += 1;
+                                }
                             }
+                            if (et !== 'group.message_created')
+                                filled += 1;
                         }
-                        if (Number.isFinite(eventSeq) && eventSeq > 0 && !client._pushedSeqs.get(ns)?.has(eventSeq)) {
-                            this.enqueueOrderedMessage(ns, 'group.changed', eventSeq, evt, 'pull');
-                            publishedEventCount += 1;
-                        }
-                    }
-                    if (et !== 'group.message_created')
-                        filled += 1;
-                }
-                try {
-                    const scanTarget = Math.max(pageContigBefore, effectiveFloor, positiveSafeSequenceHint(result.contiguous_seq), ...eventSeqs);
-                    await this.drainOrderedMessages(ns, undefined, false, false, 'pull', undefined, scanTarget);
+                        const scanTarget = Math.max(pageContigBefore, effectiveFloor, positiveSafeSequenceHint(result.contiguous_seq), ...eventSeqs);
+                        await this.drainOrderedMessages(ns, undefined, false, false, 'pull', undefined, scanTarget);
+                    });
                     if (generation !== this.captureInlineAckGeneration())
                         throw new Error('pull invalidated');
                     this.ensurePullOperationCurrent(ns);
@@ -2029,6 +2819,9 @@ export class MessageDeliveryEngine {
                         dissolved = true;
                         break;
                     }
+                    if (!this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
+                        throw new Error('pull invalidated');
+                    this.rememberCommittedSeqState(ns);
                     pageTrackerSnapshot = client._seqTracker.snapshotNamespace?.(ns) ?? null;
                     trackerMutated = true;
                     client._seqTracker.onPullResult(ns, eventObjects, nextAfterSeq, Number.isSafeInteger(result.contiguous_seq)
@@ -2041,10 +2834,13 @@ export class MessageDeliveryEngine {
                         this.ensurePullOperationCurrent(ns);
                         if (generation !== this.captureInlineAckGeneration())
                             throw new Error('pull invalidated');
+                        if (!this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
+                            throw new Error('pull invalidated');
                     }
                 }
                 catch (exc) {
                     if (trackerMutated && generation === this.captureInlineAckGeneration() && this.isPullOperationCurrent(ns)
+                        && this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration)
                         && typeof client._seqTracker.restoreNamespaceSnapshot === 'function') {
                         (client._seqTracker._restoreNamespaceSnapshotPreservingPush ?? client._seqTracker.restoreNamespaceSnapshot)
                             .call(client._seqTracker, ns, pageTrackerSnapshot);
@@ -2085,6 +2881,7 @@ export class MessageDeliveryEngine {
                 const nextAfter = Math.max(eventSeqs.length > 0 ? Math.max(...eventSeqs) : nextAfterSeq, nextAfterSeq);
                 const pageAdvanced = eventObjects.length > 0 && nextAfter > nextAfterSeq;
                 const needsMore = result.has_more === true
+                    || positiveSafeSequenceHint(result.remaining) > 0
                     || client._seqTracker.getMaxSeenSeq(ns) > nextAfter;
                 if (singlePage && pageAdvanced && needsMore) {
                     continuationAfterSeq = nextAfter;
@@ -2103,19 +2900,22 @@ export class MessageDeliveryEngine {
             client._clientLog.warn(`group event gap fill failed: ${formatDeliveryError(exc)}`);
         }
         finally {
-            client._gapFillDone.delete(dedupKey);
+            if (generation === this.captureInlineAckGeneration())
+                client._gapFillDone.delete(dedupKey);
             if (legacyGateToken !== null && typeof client._releasePullGate === 'function') {
                 client._releasePullGate(ns, legacyGateToken);
             }
+            if (generation !== this.captureInlineAckGeneration())
+                return;
+            if (dissolved)
+                this.backgroundPullNeeds.delete(ns);
             if (!dissolved && singlePage && continuationAfterSeq > afterSeq) {
                 this.enqueueOnlineUnreadEventHint({
                     group_id: groupId,
                     _online_hint_after_event_seq: continuationAfterSeq,
                 });
             }
-            else if (!dissolved && !singlePage && filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
-                void this.fillGroupEventGap(groupId);
-            }
+            this.finishBackgroundPull(ns, generation, afterSeq, failed);
             if (!client._rpcPipeline)
                 this.syncStopped(failed ? 'aborted' : 'pull_drained');
         }
@@ -2125,6 +2925,7 @@ export class MessageDeliveryEngine {
         const groupId = String(data.group_id ?? '').trim();
         if (!groupId || client._sessionOptions?.background_sync === false)
             return;
+        this.recordBackgroundPullNeed(`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, {
@@ -2518,11 +3319,11 @@ export class MessageDeliveryEngine {
                         window_mode: 'tail',
                         after_seq: after,
                         limit: pageLimit,
-                    }, true);
+                    }, true, true);
                     tailHead = this.syncState(ns).head;
                     return tailResult;
                 }
-                const opts = { gateLocked: true };
+                const opts = { gateLocked: true, background };
                 if (request.max_pages !== undefined)
                     opts.maxPages = request.max_pages;
                 const messages = await client._pullGroupV2(groupId, after, pageLimit, opts);
@@ -2531,7 +3332,7 @@ export class MessageDeliveryEngine {
             if (!client._rpcPipeline)
                 return await invoke();
             const key = client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, ...request });
-            return await client._rpcPipeline.runPullSerialized(key, invoke, background);
+            return await client._rpcPipeline.runPullNamespaceSerialized(key, invoke, background);
         };
         if (order.length === 1 && order[0] === 'tail') {
             result = await run({ window_mode: 'tail', after_seq: this.syncState(ns).ack, limit: pageLimit }, false);
@@ -2582,13 +3383,13 @@ export class MessageDeliveryEngine {
         const maxPages = Math.max(1, Math.ceil(Math.max(0, throughSeq - ack) / pageLimit));
         const request = { group_id: groupId, after_seq: ack, limit: pageLimit, 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, maxPages, background });
             return { messages, raw_count: messages.length };
         };
         if (!client._rpcPipeline)
             return await invoke();
         const key = client._rpcPipeline.pullGateKeyForCall('group.pull', request);
-        return await client._rpcPipeline.runPullSerialized(key, invoke, background);
+        return await client._rpcPipeline.runPullNamespaceSerialized(key, invoke, background);
     }
     syncState(ns) {
         const tracker = this.runtime.client._seqTracker;
@@ -2929,6 +3730,7 @@ export class MessageDeliveryEngine {
             return false;
         const client = this.runtime.client;
         const tracker = client._seqTracker;
+        const namespaceGeneration = this.captureSeqNamespaceGeneration(ns);
         let snapshot = null;
         let trackerMutated = false;
         let delivered = false;
@@ -2945,6 +3747,9 @@ export class MessageDeliveryEngine {
             delivered = true;
             if (!this.inlineGenerationIsCurrent(generation))
                 return false;
+            if (!this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
+                return false;
+            this.rememberCommittedSeqState(ns);
             snapshot = typeof tracker.snapshotNamespace === 'function' ? tracker.snapshotNamespace(ns) : null;
             trackerMutated = true;
             const needsPull = Boolean(tracker.onMessageSeq(ns, seq));
@@ -2963,13 +3768,14 @@ export class MessageDeliveryEngine {
             if (!this.inlineGenerationIsCurrent(generation))
                 return false;
             await client._commitSeqTrackerState(ns);
-            if (!this.inlineGenerationIsCurrent(generation))
+            if (!this.inlineGenerationIsCurrent(generation) || !this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration))
                 return false;
             this.markPublishedSeq(ns, seq);
             return true;
         }
         catch (exc) {
             if (trackerMutated && this.inlineGenerationIsCurrent(generation)
+                && this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration)
                 && typeof tracker.restoreNamespaceSnapshot === 'function') {
                 (tracker._restoreNamespaceSnapshotPreservingPush ?? tracker.restoreNamespaceSnapshot).call(tracker, ns, snapshot);
             }
@@ -2984,6 +3790,8 @@ export class MessageDeliveryEngine {
         const tracker = client._seqTracker;
         if (!this.inlineGenerationIsCurrent(generation) || !this.inlineStateIsCaughtUp(ns, seq))
             return false;
+        const namespaceGeneration = this.captureSeqNamespaceGeneration(ns);
+        this.rememberCommittedSeqState(ns);
         const snapshot = typeof tracker.snapshotNamespace === 'function' ? tracker.snapshotNamespace(ns) : null;
         try {
             const needsPull = Boolean(tracker.onMessageSeq(ns, seq));
@@ -2998,10 +3806,11 @@ export class MessageDeliveryEngine {
                 throw new Error('inline realtime terminal cursor did not collapse after consume');
             }
             await client._commitSeqTrackerState(ns);
-            return this.inlineGenerationIsCurrent(generation);
+            return this.inlineGenerationIsCurrent(generation) && this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration);
         }
         catch (exc) {
             if (this.inlineGenerationIsCurrent(generation)
+                && this.isSeqNamespaceGenerationCurrent(ns, namespaceGeneration)
                 && typeof tracker.restoreNamespaceSnapshot === 'function') {
                 (tracker._restoreNamespaceSnapshotPreservingPush ?? tracker.restoreNamespaceSnapshot).call(tracker, ns, snapshot);
             }
@@ -3195,8 +4004,84 @@ export class MessageDeliveryEngine {
         }
         return 0;
     }
+    async onPeerPush(data, expectedVersion) {
+        const client = this.runtime.client;
+        if (!isJsonObject(data) || !client._aid || !this.messageTargetsCurrentInstance(data))
+            return;
+        const head = data;
+        if (String(head.kind ?? '') === 'message.online_unread_hint' || !head.sender_aid) {
+            this.refreshPendingPeers();
+            return;
+        }
+        if (head.cursor_scope !== 'peer') {
+            this.refreshPendingPeers();
+            return;
+        }
+        const sender = String(head.sender_aid);
+        const ns = await this.initializePeer(sender);
+        const generation = this.captureInlineAckGeneration();
+        const seq = positiveSafeSequenceHint(head.seq);
+        if (this.isVolatileMessage(head)) {
+            await client._v2E2EE.publishV2VolatileMessages([head], 'push', false);
+            return;
+        }
+        if (!seq) {
+            this.refreshPendingPeers();
+            return;
+        }
+        client._seqTracker.updateMaxSeen(ns, seq);
+        const row = isJsonObject(head.inline_message) ? head.inline_message : null;
+        const prev = nonNegativeSafeSequenceHint(head.prev_peer_seq);
+        if (row && prev !== null && prev < seq && prev <= this.syncState(ns).ack
+            && (!expectedVersion || this.inlineRowKind(row) === expectedVersion) && this.inlineHeadMatches(head, row, seq)) {
+            const consumed = await client._tryRunInlineRealtime(ns, seq, () => this.runPeerPageSerialized(ns, async () => {
+                if (generation !== this.captureInlineAckGeneration() || prev > this.syncState(ns).ack)
+                    return false;
+                const decoded = await this.decodeInlineP2P(row);
+                if (!decoded || !this.decodedInlineMatches(head, decoded, seq))
+                    return false;
+                decoded.sender_aid = sender;
+                decoded.need_render = typeof row.need_render === 'boolean' ? row.need_render : decoded.need_render !== false;
+                const event = this.p2pAppEventForMessage(decoded);
+                await this.publishPulledMessage(event.event, ns, seq, event.payload, false, 'inline_push');
+                if (generation !== this.captureInlineAckGeneration())
+                    throw new Error('inline invalidated');
+                const snapshot = client._seqTracker.snapshotNamespace(ns);
+                try {
+                    client._seqTracker.onPullResult(ns, [{ seq }], this.syncState(ns).ack, seq);
+                    await this.commitSeqTrackerState(ns);
+                }
+                catch (error) {
+                    client._seqTracker._restoreNamespaceSnapshotPreservingPush(ns, snapshot);
+                    throw error;
+                }
+                await client._v2E2EE.ackPeerV2(sender, this.syncState(ns).ack);
+                return true;
+            })).catch((error) => {
+                if (generation === this.captureInlineAckGeneration())
+                    this.schedulePeerRecovery(sender, seq);
+                throw error;
+            });
+            if (consumed?.acquired && consumed.value)
+                return;
+        }
+        if (seq <= this.syncState(ns).ack)
+            return;
+        if (client._sessionOptions?.background_sync !== false) {
+            this.schedulePeerRecovery(sender, seq);
+        }
+        else {
+            await client._v2E2EE.pullPeerV2(sender, { limit: _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize, budget: { remaining: 1 },
+                ...(this.peerOwnType() === 'human' ? { window_mode: 'tail' } : {}) });
+        }
+    }
     async onV2PushNotification(data, expectedVersion, inlineGeneration) {
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled) {
+            await this.onPeerPush(data, expectedVersion);
+            return;
+        }
+        const syncGeneration = this.captureInlineAckGeneration();
         if (inlineGeneration !== undefined && !this.inlineGenerationIsCurrent(inlineGeneration))
             return;
         const pushData = isJsonObject(data) ? data : null;
@@ -3251,6 +4136,7 @@ export class MessageDeliveryEngine {
                 this.retryPendingP2PInlineAck(ns, pushSeq, 'covered inline push');
             return;
         }
+        this.recordBackgroundPullNeed(ns, pushSeq);
         const pullActive = client._rpcPipeline?.hasPullActivity?.(ns) === true;
         if (pullActive || !this.beginRealtimeSync(ns)) {
             client._recordPendingP2pPull(ns, pushSeq);
@@ -3267,7 +4153,9 @@ export class MessageDeliveryEngine {
             client._clientLog.warn(`V2 P2P push auto-sync failed: ${formatDeliveryError(exc)}`);
         }
         finally {
-            if (inlineGeneration === undefined || this.inlineGenerationIsCurrent(inlineGeneration)) {
+            if (syncGeneration === this.captureInlineAckGeneration()
+                && (inlineGeneration === undefined || this.inlineGenerationIsCurrent(inlineGeneration))) {
+                this.finishBackgroundPull(ns, syncGeneration, this.syncState(ns).ack, false);
                 this.endRealtimeSync(ns);
                 client._schedulePendingP2pPullIfNeeded?.(ns, 'push-auto-pull-complete');
             }
@@ -3279,6 +4167,9 @@ export class MessageDeliveryEngine {
         if (!groupId)
             return;
         const ns = `group:${groupId}`;
+        const generation = this.captureInlineAckGeneration();
+        const afterSeq = this.syncState(ns).ack;
+        this.recordBackgroundPullNeed(ns, positiveSafeSequenceHint(data.seq));
         const targets = this.onlineUnreadHintTargets ?? new Map();
         const tasks = this.onlineUnreadHintTasks ?? new Map();
         this.onlineUnreadHintTargets = targets;
@@ -3286,10 +4177,13 @@ export class MessageDeliveryEngine {
         targets.set(ns, Math.max(targets.get(ns) ?? 0, positiveSafeSequenceHint(data.seq)));
         if (tasks.has(ns))
             return;
+        let attemptAfterSeq = afterSeq;
         const task = Promise.resolve().then(async () => {
+            let failed = false;
             try {
                 while (true) {
                     const ackBefore = this.syncState(ns).ack;
+                    attemptAfterSeq = ackBefore;
                     await this.runGroupForwardRecovery(groupId, ns, 50, true, targets.get(ns) ?? 0);
                     const ackAfter = this.syncState(ns).ack;
                     if (ackAfter >= (targets.get(ns) ?? 0) || ackAfter <= ackBefore)
@@ -3297,12 +4191,14 @@ export class MessageDeliveryEngine {
                 }
             }
             catch (exc) {
+                failed = true;
                 client._clientLog.debug(`online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
             }
             finally {
                 targets.delete(ns);
                 if (tasks.get(ns) === task)
                     tasks.delete(ns);
+                this.finishBackgroundPull(ns, generation, attemptAfterSeq, failed);
                 client._rpcPipeline?.requestPullDrainedCheck?.();
             }
         });
@@ -3311,6 +4207,7 @@ export class MessageDeliveryEngine {
     }
     async onRawGroupV2MessageCreated(data, expectedVersion, inlineGeneration) {
         const client = this.runtime.client;
+        const syncGeneration = this.captureInlineAckGeneration();
         if (inlineGeneration !== undefined && !this.inlineGenerationIsCurrent(inlineGeneration))
             return;
         if (!isJsonObject(data)) {
@@ -3373,6 +4270,7 @@ export class MessageDeliveryEngine {
             }
             return;
         }
+        this.recordBackgroundPullNeed(ns, seq);
         const pullActive = client._rpcPipeline?.hasPullActivity?.(ns) === true;
         if (pullActive || !this.beginRealtimeSync(ns)) {
             this.recordPendingGroupPull(ns, seq);
@@ -3388,7 +4286,9 @@ export class MessageDeliveryEngine {
                 return;
             client._clientLog.warn(`V2 group push auto-sync failed: group=${groupId} err=${formatDeliveryError(exc)}`);
         }).finally(() => {
-            if (inlineGeneration === undefined || this.inlineGenerationIsCurrent(inlineGeneration)) {
+            if (syncGeneration === this.captureInlineAckGeneration()
+                && (inlineGeneration === undefined || this.inlineGenerationIsCurrent(inlineGeneration))) {
+                this.finishBackgroundPull(ns, syncGeneration, this.syncState(ns).ack, false);
                 this.endRealtimeSync(ns);
                 this.schedulePendingGroupPullIfNeeded(ns, 'push-auto-pull-complete');
             }
@@ -3398,6 +4298,14 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         if (!client._aid)
             return;
+        this.ensurePeerContext();
+        const rememberPeers = () => {
+            const state = client._seqTracker.exportSyncState?.() ?? {};
+            for (const [ns, triplet] of Object.entries(state)) {
+                if (this.isReliableSeqNamespace(ns))
+                    this.committedSeqTrackerStates.set(ns, { ...triplet });
+            }
+        };
         try {
             const loadSync = client._tokenStore.loadAllSyncStates;
             if (typeof loadSync === 'function' && typeof client._seqTracker.restoreSyncState === 'function') {
@@ -3405,6 +4313,7 @@ export class MessageDeliveryEngine {
                 if (state && Object.keys(state).length > 0) {
                     state = this.migrateSeqStateGroupIds(state);
                     client._seqTracker.restoreSyncState(state);
+                    rememberPeers();
                     return;
                 }
             }
@@ -3414,6 +4323,7 @@ export class MessageDeliveryEngine {
                 if (state && Object.keys(state).length > 0) {
                     state = this.migrateSeqStateGroupIds(state);
                     client._seqTracker.restoreState(state);
+                    rememberPeers();
                     return;
                 }
             }
@@ -3427,6 +4337,7 @@ export class MessageDeliveryEngine {
                         client._seqTracker.restoreSyncState(state);
                     else
                         client._seqTracker.restoreState(state);
+                    rememberPeers();
                 }
             }
         }
@@ -3447,12 +4358,21 @@ export class MessageDeliveryEngine {
     }
     enqueueOnlineUnreadP2pHint(data) {
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled) {
+            this.refreshPendingPeers();
+            return;
+        }
         if (!client._aid || !client._v2Session)
             return;
         const ns = `p2p:${client._aid}`;
+        const generation = this.captureInlineAckGeneration();
+        const afterSeq = this.syncState(ns).ack;
+        this.recordBackgroundPullNeed(ns, positiveSafeSequenceHint(data.seq), true);
+        let failed = false;
         client._safeAsync(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(() => this.finishBackgroundPull(ns, generation, afterSeq, failed)));
     }
     async saveSeqTrackerState() {
         const client = this.runtime.client;
@@ -3464,6 +4384,16 @@ 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.ensurePeerContext();
+        for (const ns of Object.keys(state)) {
+            if (!this.isReliableSeqNamespace(ns))
+                continue;
+            const committed = this.committedSeqTrackerStates.get(ns);
+            if (committed)
+                state[ns] = { ...committed };
+            else if (ns.startsWith('p2p.peer.v1/'))
+                delete state[ns];
+        }
         const pending = this.seqTrackerPending();
         if (pending.size > 0 && client._seqTrackerPendingPersistContext === context) {
             const liveNamespaces = new Set(Object.keys(state));
@@ -3491,9 +4421,12 @@ export class MessageDeliveryEngine {
         if (forceSeq !== undefined) {
             client._seqTracker.forceContiguousSeq(ns, seq);
         }
-        const state = typeof client._seqTracker.getSyncState === 'function'
-            ? client._seqTracker.getSyncState(ns)
-            : { ack: seq, tail: seq, head: seq };
+        const state = this.committedSeqTrackerStates.get(ns) ?? (ns.startsWith('p2p.peer.v1/') ? undefined
+            : typeof client._seqTracker.getSyncState === 'function'
+                ? client._seqTracker.getSyncState(ns)
+                : { ack: seq, tail: seq, head: seq });
+        if (!state)
+            return;
         this.mergeSeqTrackerPending(context, { [ns]: state });
         this.scheduleSeqTrackerFlush();
     }
@@ -3508,12 +4441,16 @@ export class MessageDeliveryEngine {
         if (![state.ack, state.tail, state.head].some((value) => Number(value) > 0))
             return;
         const [aid, deviceId, slotId] = JSON.parse(context);
+        const tracker = client._seqTracker;
+        const namespaceGeneration = this.seqTrackerNamespaceGenerations.get(ns) ?? 0;
         const pendingBeforeCommit = this.takeSeqTrackerPending(context, ns);
         try {
             await this.writeSeqTrackerState(aid, deviceId, slotId, { [ns]: state }, true);
         }
         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}`);
@@ -3620,7 +4557,37 @@ export class MessageDeliveryEngine {
         }
     }
     async writeSeqTrackerState(aid, deviceId, slotId, state, throwOnError = false) {
-        await this.enqueueSeqTrackerWrite(() => this.writeSeqTrackerStateNow(aid, deviceId, slotId, state, throwOnError));
+        const context = JSON.stringify([aid, deviceId, slotId]);
+        const tracker = this.runtime.client._seqTracker;
+        const namespaceGenerations = new Map(Object.keys(state).map((ns) => [ns, this.seqTrackerNamespaceGenerations.get(ns) ?? 0]));
+        await this.enqueueSeqTrackerWrite(async () => {
+            const current = context === this.currentSeqTrackerContext() && tracker === this.runtime.client._seqTracker;
+            if (throwOnError && !current)
+                throw new Error('seq tracker commit invalidated');
+            if (current)
+                this.ensurePeerContext();
+            const writing = { ...state };
+            if (!throwOnError && current) {
+                for (const ns of Object.keys(writing)) {
+                    if (!this.isReliableSeqNamespace(ns))
+                        continue;
+                    const committed = this.committedSeqTrackerStates.get(ns);
+                    if (committed)
+                        writing[ns] = { ...committed };
+                    else if (ns.startsWith('p2p.peer.v1/'))
+                        delete writing[ns];
+                }
+            }
+            await this.writeSeqTrackerStateNow(aid, deviceId, slotId, writing, throwOnError);
+            if (throwOnError && context === this.currentSeqTrackerContext() && tracker === this.runtime.client._seqTracker) {
+                for (const [ns, triplet] of Object.entries(writing)) {
+                    if (this.isReliableSeqNamespace(ns)
+                        && (this.seqTrackerNamespaceGenerations.get(ns) ?? 0) === namespaceGenerations.get(ns)) {
+                        this.committedSeqTrackerStates.set(ns, { ...triplet });
+                    }
+                }
+            }
+        });
     }
     enqueueSeqTrackerWrite(operation) {
         const run = this.seqTrackerWriteChain.then(operation, operation);
@@ -3673,10 +4640,16 @@ export class MessageDeliveryEngine {
         const client = this.runtime.client;
         if (!client._aid || !ns)
             return;
+        this.ensurePeerContext();
         const aid = client._aid;
         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.initializedPeers.delete(ns);
+        }
         this.dropSeqTrackerPending(ns);
         const saveSeq = client._tokenStore.saveSeq;
         if (seq > 0 && typeof saveSeq === 'function') {
@@ -3734,7 +4707,9 @@ export class MessageDeliveryEngine {
         if (next < 0)
             next = 0;
         if (ns) {
-            const committedAck = client._seqTracker.getContiguousSeq(ns);
+            this.ensurePeerContext();
+            const localAck = client._seqTracker.getContiguousSeq(ns);
+            const committedAck = Math.min(localAck, this.committedSeqTrackerStates.get(ns)?.ack ?? localAck);
             if (next > committedAck) {
                 client._clientLog.warn(`ack clamp: method=${method} ${field}=${original} > committed_ack=${committedAck}, clamp`);
                 next = committedAck;
@@ -3791,6 +4766,8 @@ export class MessageDeliveryEngine {
         const queue = client._pendingOrderedMsgs.get(ns);
         if (!queue || queue.size === 0)
             return;
+        const page = this.currentApplicationPage();
+        let deliveredThrough = client._seqTracker.getContiguousSeq(ns);
         let delivered = false;
         const rootTrigger = this.deliveryChangedTrigger(source);
         const drainContexts = new Map();
@@ -3798,16 +4775,17 @@ export class MessageDeliveryEngine {
             while (true) {
                 if (pullScoped)
                     this.ensurePullOperationCurrent(ns);
-                const contig = client._seqTracker.getContiguousSeq(ns);
+                const contig = page ? Math.max(deliveredThrough, client._seqTracker.getContiguousSeq(ns)) : client._seqTracker.getContiguousSeq(ns);
                 const ready = [...queue.keys()]
-                    .filter((seq) => seq <= Math.max(contig, throughSeq ?? contig) && (beforeSeq === undefined || seq < beforeSeq))
+                    .filter((seq) => !page?.consumed.has(JSON.stringify(['ordered', ns, seq]))
+                    && seq <= Math.max(contig, throughSeq ?? contig) && (beforeSeq === undefined || seq < beforeSeq))
                     .sort((a, b) => a - b);
                 let seq = ready[0];
                 if (seq === undefined) {
                     const nextSeq = Math.max(contig, throughSeq ?? contig) + 1;
                     if (beforeSeq !== undefined && nextSeq >= beforeSeq)
                         break;
-                    if (!queue.has(nextSeq))
+                    if (!queue.has(nextSeq) || page?.consumed.has(JSON.stringify(['ordered', ns, nextSeq])))
                         break;
                     seq = nextSeq;
                 }
@@ -3816,10 +4794,11 @@ export class MessageDeliveryEngine {
                 const item = queue.get(seq);
                 if (!item)
                     continue;
-                if (client._pushedSeqs.get(ns)?.has(seq)) {
-                    queue.delete(seq);
+                if (this.hasPublishedSeq(ns, seq)) {
+                    this.consumeOrderedMessage(ns, seq, queue);
                     client._clientLog.debug(`publish ordered drain skipped duplicate: ns=${ns}, seq=${seq}, event=${item.event}`);
-                    client._markOrderedSeqDelivered(ns, seq);
+                    this.completeApplicationDelivery(() => client._markOrderedSeqDelivered(ns, seq));
+                    deliveredThrough = Math.max(deliveredThrough, seq);
                     continue;
                 }
                 const itemSource = item.source ?? source;
@@ -3839,12 +4818,13 @@ export class MessageDeliveryEngine {
                     throw new Error('pull invalidated');
                 if (pullScoped)
                     this.ensurePullOperationCurrent(ns);
-                queue.delete(seq);
+                this.consumeOrderedMessage(ns, seq, queue);
                 if (item.event === 'group.changed' && isJsonObject(item.payload)
                     && item.payload.action === 'dissolved')
                     break;
                 this.markPublishedSeq(ns, seq);
-                client._markOrderedSeqDelivered(ns, seq);
+                this.completeApplicationDelivery(() => client._markOrderedSeqDelivered(ns, seq));
+                deliveredThrough = Math.max(deliveredThrough, seq);
                 if (throughSeq !== undefined)
                     throughSeq = Math.max(throughSeq, seq);
                 delivered = true;
@@ -3954,6 +4934,87 @@ export class MessageDeliveryEngine {
         return true;
     }
     async publishPulledMessage(event, ns, seq, payload, persist = true, source = 'pull') {
+        const client = this.runtime.client;
+        const seqNum = Number(seq);
+        if (!client._p2pPeerPullEnabled || event !== 'message.received' || source === 'history'
+            || !Number.isSafeInteger(seqNum) || seqNum <= 0 || !payload || typeof payload !== 'object'
+            || payload.storage === 'volatile') {
+            return this.publishPulledMessageInternal(event, ns, seq, payload, persist, source);
+        }
+        const context = this.ensurePeerContext();
+        const generation = this.captureInlineAckGeneration();
+        const ensureCurrent = () => {
+            if (context !== this.ensurePeerContext() || generation !== this.captureInlineAckGeneration())
+                throw new Error('delivery invalidated');
+            if (this.isPullScopedSource(source))
+                this.ensurePullOperationCurrent(ns);
+        };
+        const value = payload;
+        const sender = String(value.sender_aid ?? value.from_aid ?? value.from ?? this.peerSender(ns));
+        if (!sender)
+            return this.publishPulledMessageInternal(event, ns, seq, payload, persist, source);
+        const messageId = String(value.message_id ?? '');
+        const key = JSON.stringify([context, event, seqNum]);
+        const page = this.currentApplicationPage();
+        const bindingMatches = (receipt) => receipt.sender_aid === sender
+            && (!receipt.message_id || !messageId || receipt.message_id === messageId);
+        const local = page?.bindings.get(key);
+        if (local) {
+            if (!bindingMatches(local))
+                throw new Error('P2P delivery receipt binding conflict');
+            if (messageId && !local.message_id)
+                local.message_id = messageId;
+            return false;
+        }
+        const pending = this.deliveryInflight.get(key);
+        if (pending) {
+            if (client._dispatcher._isApplicationHandler?.())
+                throw new Error('delivery cannot wait inside an application handler');
+            await pending;
+            ensureCurrent();
+            const settled = this.settledDeliveries.get(key);
+            if (settled && !bindingMatches(settled))
+                throw new Error('P2P delivery receipt binding conflict');
+            if (!messageId || settled?.message_id)
+                return false;
+        }
+        const operation = Promise.resolve().then(async () => {
+            ensureCurrent();
+            let settled = this.settledDeliveries.get(key);
+            if (settled && !bindingMatches(settled))
+                throw new Error('P2P delivery receipt binding conflict');
+            if (settled && messageId && !settled.message_id) {
+                settled = { ...settled, message_id: messageId };
+            }
+            let published = false;
+            if (!settled) {
+                if (!this.isSelfSentP2PMessage(payload)) {
+                    await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source));
+                    published = true;
+                }
+                ensureCurrent();
+                settled = { sender_aid: sender, ...(messageId ? { message_id: messageId } : {}) };
+            }
+            ensureCurrent();
+            const binding = settled;
+            page?.bindings.set(key, binding);
+            this.completeApplicationDelivery(() => {
+                this.settledDeliveries.set(key, binding);
+                while (this.settledDeliveries.size > PUSHED_SEQS_LIMIT) {
+                    const first = this.settledDeliveries.keys().next().value;
+                    this.settledDeliveries.delete(first);
+                }
+            });
+            this.markPublishedSeq(ns, seqNum);
+            return published;
+        });
+        const completion = page ? operation.then(async (result) => { await page.completion; return result; }) : operation;
+        this.deliveryInflight.set(key, completion);
+        void completion.finally(() => { if (this.deliveryInflight.get(key) === completion)
+            this.deliveryInflight.delete(key); }).catch(() => { });
+        return await operation;
+    }
+    async publishPulledMessageInternal(event, ns, seq, payload, persist = true, source = 'pull') {
         const client = this.runtime.client;
         const generation = this.captureInlineAckGeneration();
         const pullScoped = this.isPullScopedSource(source);
@@ -3976,9 +5037,9 @@ export class MessageDeliveryEngine {
             return true;
         }
         const queue = client._pendingOrderedMsgs.get(ns);
-        if (client._pushedSeqs.get(ns)?.has(seqNum)) {
+        if (this.hasPublishedSeq(ns, seqNum)) {
             client._clientLog.debug(`publish pulled skipped duplicate: event=${event}, ns=${ns}, seq=${seqNum}`);
-            queue?.delete(seqNum);
+            this.consumeOrderedMessage(ns, seqNum, queue);
             if (queue && queue.size === 0)
                 client._pendingOrderedMsgs.delete(ns);
             return false;
@@ -3997,7 +5058,7 @@ export class MessageDeliveryEngine {
                 throw new Error('pull invalidated');
             if (pullScoped)
                 this.ensurePullOperationCurrent(ns);
-            queue?.delete(seqNum);
+            this.consumeOrderedMessage(ns, seqNum, queue);
             if (queue && queue.size === 0)
                 client._pendingOrderedMsgs.delete(ns);
             this.markPublishedSeq(ns, seqNum);
@@ -4014,7 +5075,7 @@ export class MessageDeliveryEngine {
             throw new Error('pull invalidated');
         if (pullScoped)
             this.ensurePullOperationCurrent(ns);
-        queue?.delete(seqNum);
+        this.consumeOrderedMessage(ns, seqNum, queue);
         if (queue && queue.size === 0)
             client._pendingOrderedMsgs.delete(ns);
         this.markPublishedSeq(ns, seqNum);