@agentunion/fastaun 0.5.20 → 0.5.22

package/dist/client/delivery.js

@@ -1,5 +1,8 @@
-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 { normalizeGroupAid } from '../group-id.js';
 import { ConnectionState, isJsonObject } from '../types.js';
 import { validateGroupAIDFormat } from '../validators.js';
 import { hasGroupMentionModeField, normalizeGroupMentionMode } from './mention-mode.js';
@@ -10,16 +13,35 @@ 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;
+function isTerminalGroupPullError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const failure = error;
+    if (typeof failure.data?.retryable === 'boolean')
+        return !failure.data.retryable;
+    if (failure.retryable === true)
+        return false;
+    const message = String(failure.message ?? '').trim().toLowerCase();
+    if (['timeout', 'deadline exceeded', 'gateway service degraded', 'certificate not loaded',
+        'long_connection_already_exists', 'long connection already exists'].some((text) => message.includes(text)))
+        return false;
+    return [-32001, -32003, -32004, -32600, -32601, -32602].includes(failure.code ?? 0)
+        || (typeof failure.code === 'number' && failure.code >= -33009 && failure.code <= -33001)
+        || ['banned members', 'blocked members', 'member is banned', 'member is blocked',
+            'group is not active', 'group is dissolved', 'group is suspended',
+            'group not found', 'member not found', 'not a member'].some((text) => message.includes(text));
+}
 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',
@@ -100,9 +122,774 @@ 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();
+    peerForwardNeeds = new Map();
+    peerPushVersions = new Map();
+    peerCatalogVersion = null;
+    peerPullHints = new Map();
+    peerPullConfirmedThrough = new Map();
+    peerServerConfirmedAcks = new Map();
+    peerVolatileCursors = new Map();
+    settledDeliveries = new Map();
+    deliveryInflight = new Map();
+    applicationPage = new AsyncLocalStorage();
+    applicationClaims = new Map();
+    volatileCompletions = new Map();
+    peerPageChains = new Map();
+    automaticPullFailures = new Map();
+    terminalGroupPulls = new Map();
+    automaticPullOperations = new WeakSet();
+    automaticPullContext = new AsyncLocalStorage();
+    automaticPullAbort = new AbortController();
     constructor(runtime) {
         this.runtime = runtime;
     }
+    resetAutomaticPullBackoff() {
+        this.automaticPullAbort.abort();
+        this.automaticPullAbort = new AbortController();
+        this.automaticPullFailures.clear();
+        this.terminalGroupPulls.clear();
+    }
+    groupPullNamespace(namespace) {
+        const groupId = namespace.startsWith('group_event:') ? namespace.slice('group_event:'.length)
+            : namespace.startsWith('group:') ? namespace.slice('group:'.length) : '';
+        return groupId ? `group:${normalizeGroupAid(groupId)}` : '';
+    }
+    automaticGroupPullStopped(namespace) {
+        return this.terminalGroupPulls.has(this.groupPullNamespace(namespace));
+    }
+    observeSuccessfulGroupPull(namespace) {
+        if (!this.automaticPullContext.getStore())
+            this.terminalGroupPulls.delete(this.groupPullNamespace(namespace));
+    }
+    stopAutomaticGroupPull(namespace, error) {
+        const canonical = this.groupPullNamespace(namespace);
+        if (!canonical)
+            return;
+        this.terminalGroupPulls.set(canonical, error);
+        for (const pending of [this.automaticPullFailures, this.backgroundPullNeeds, this.pendingGroupPullUpper, this.onlineUnreadHintTargets]) {
+            for (const ns of pending?.keys() ?? []) {
+                if (this.groupPullNamespace(ns) === canonical)
+                    pending.delete(ns);
+            }
+        }
+    }
+    automaticPullRetryAt(namespace, operation) {
+        return this.automaticPullOperations.has(operation) ? this.automaticPullFailures.get(namespace)?.retryAt ?? 0 : 0;
+    }
+    runPeerPullAttempt(namespace, operation, schedule) {
+        return this.automaticPullContext.getStore() ? this.runAutomaticPull(namespace, operation, schedule) : schedule(operation);
+    }
+    async runAutomaticPull(namespace, operation, schedule) {
+        this.ensurePeerContext();
+        if (this.automaticGroupPullStopped(namespace))
+            throw this.terminalGroupPulls.get(this.groupPullNamespace(namespace));
+        const nested = this.automaticPullContext.getStore() === namespace;
+        const generation = this.captureInlineAckGeneration();
+        const signal = this.automaticPullAbort.signal;
+        const client = this.runtime.client;
+        while ((this.automaticPullFailures.get(namespace)?.retryAt ?? 0) > Date.now()) {
+            const delay = this.automaticPullFailures.get(namespace).retryAt - Date.now();
+            await new Promise((resolve, reject) => {
+                const abort = () => {
+                    clearTimeout(timer);
+                    reject(new Error('pull invalidated'));
+                };
+                const timer = setTimeout(() => { signal.removeEventListener('abort', abort); resolve(); }, delay);
+                signal.addEventListener('abort', abort, { once: true });
+            });
+        }
+        if (signal.aborted || generation !== this.captureInlineAckGeneration() || client._closing || client.state !== ConnectionState.READY) {
+            throw new Error('pull invalidated');
+        }
+        const attempt = async () => {
+            if (this.automaticGroupPullStopped(namespace))
+                throw this.terminalGroupPulls.get(this.groupPullNamespace(namespace));
+            const previousFailure = this.automaticPullFailures.get(namespace);
+            try {
+                const result = await this.automaticPullContext.run(namespace, operation);
+                if (!nested && !signal.aborted && generation === this.captureInlineAckGeneration())
+                    this.automaticPullFailures.delete(namespace);
+                return result;
+            }
+            catch (error) {
+                if (!signal.aborted && generation === this.captureInlineAckGeneration()
+                    && this.groupPullNamespace(namespace) && isTerminalGroupPullError(error)) {
+                    this.stopAutomaticGroupPull(namespace, error);
+                    throw error;
+                }
+                const currentFailure = this.automaticPullFailures.get(namespace);
+                if ((!currentFailure || currentFailure === previousFailure)
+                    && !signal.aborted && generation === this.captureInlineAckGeneration() && !client._closing && client.state === ConnectionState.READY) {
+                    const delay = Math.min(30_000, (this.automaticPullFailures.get(namespace)?.delay ?? 500) * 2);
+                    this.automaticPullFailures.set(namespace, { delay, retryAt: Date.now() + delay });
+                }
+                throw error;
+            }
+        };
+        this.automaticPullOperations.add(attempt);
+        return await (schedule ? schedule(attempt) : attempt());
+    }
+    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']);
+    }
+    hasP2pApplicationSubscription() {
+        const handlers = this.runtime.client._dispatcher._snapshotApplicationHandlers?.(['message.received', 'message.recalled', 'message.batch']);
+        return !handlers || [...handlers.values()].some((selected) => selected.length > 0);
+    }
+    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.resetAutomaticPullBackoff();
+            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.peerForwardNeeds.clear();
+            this.peerPushVersions.clear();
+            this.peerCatalogVersion = null;
+            this.peerPullHints.clear();
+            this.peerPullConfirmedThrough.clear();
+            this.peerServerConfirmedAcks.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();
+        const committed = this.committedSeqTrackerStates.get(namespace);
+        return committed ? Math.min(committed.ack, this.syncState(namespace).ack) : 0;
+    }
+    observePeerServerAck(namespace, sequence) {
+        this.ensurePeerContext();
+        if (!namespace.startsWith('p2p.peer.v1/') || !Number.isSafeInteger(sequence) || sequence < 0)
+            return;
+        this.peerServerConfirmedAcks.set(namespace, Math.max(this.peerServerConfirmedAcks.get(namespace) ?? 0, sequence));
+    }
+    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));
+            if (row.volatile_has_more === true || (nonNegativeSafeSequenceHint(row.head_seq) ?? 0) > Math.max(this.syncState(ns).head, client._seqTracker.getMaxSeenSeq(ns))) {
+                this.peerPushVersions.set(ns, {});
+            }
+            const head = nonNegativeSafeSequenceHint(row.head_seq);
+            if (head !== null)
+                client._seqTracker.updateMaxSeen(ns, head);
+            const hint = nonNegativeSafeSequenceHint(row.next_pending_seq);
+            const serverAck = nonNegativeSafeSequenceHint(row.server_ack_seq);
+            if (serverAck !== null)
+                this.observePeerServerAck(ns, serverAck);
+            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;
+    }
+    capturePeerTailVersion(senderAid) {
+        const context = this.ensurePeerContext();
+        return { context, push: this.peerPushVersions.get(this.peerNamespace(senderAid)), catalog: this.peerCatalogVersion };
+    }
+    isPeerTailCurrent(senderAid, version, committedAck) {
+        const namespace = this.peerNamespace(senderAid);
+        return version.context === this.ensurePeerContext() && this.peerPushVersions.get(namespace) === version.push
+            && this.peerCatalogVersion === version.catalog && this.runtime.client._seqTracker.getMaxSeenSeq(namespace) <= committedAck
+            && this.peerPullPriority(namespace) <= committedAck && this.syncState(namespace).head <= committedAck;
+    }
+    shouldTailPeer(namespace, head, limit, expectedForwardNeed) {
+        const state = this.syncState(namespace);
+        const knownHead = Math.max(head, state.head, this.runtime.client._seqTracker.getMaxSeenSeq(namespace), this.peerPullPriority(namespace));
+        return this.peerOwnType() === 'human' && (!this.peerForwardNeeds.has(namespace) || this.peerForwardNeeds.get(namespace) === expectedForwardNeed) && state.ack >= state.head
+            && Number.isSafeInteger(limit) && limit > 0 && knownHead - this.peerCommittedAck(namespace) > limit;
+    }
+    canClosePeerTail(namespace, tail, pushVersion, catalogVersion, expectedNeed) {
+        const head = nonNegativeSafeSequenceHint(tail.head_seq);
+        const committedAck = this.peerCommittedAck(namespace);
+        const need = this.peerRecoveryNeeds.get(this.peerSender(namespace));
+        return tail.complete === true && tail.volatile_has_more === false && tail.pending_ack_seq === 0
+            && head !== null && committedAck >= head && this.syncState(namespace).head <= committedAck
+            && (this.peerServerConfirmedAcks.get(namespace) ?? 0) >= committedAck
+            && this.runtime.client._seqTracker.getMaxSeenSeq(namespace) <= committedAck
+            && this.peerPullPriority(namespace) <= committedAck
+            && this.peerPushVersions.get(namespace) === pushVersion
+            && this.peerCatalogVersion === catalogVersion
+            && (!need || (need === expectedNeed && !need.pending && need.head <= committedAck));
+    }
+    async pullPeers(params = {}, background = false) {
+        const client = this.runtime.client;
+        const context = this.ensurePeerContext();
+        const generation = this.captureInlineAckGeneration();
+        const isCurrent = () => context === this.ensurePeerContext() && generation === this.captureInlineAckGeneration();
+        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 peerPullVersion = this.capturePeerTailVersion(peer);
+            const ns = await this.initializePeer(peer);
+            try {
+                if (!isCurrent())
+                    throw new Error('pull invalidated');
+                let forwardNeed = this.peerForwardNeeds.get(ns);
+                if (!params.window_mode && params.force !== true && this.shouldTailPeer(ns, Number(row.head_seq ?? 0), Number(params.limit ?? _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize)) && budget.remaining > 0) {
+                    forwardNeed = {};
+                    this.peerForwardNeeds.set(ns, forwardNeed);
+                    const pushVersion = this.peerPushVersions.get(ns);
+                    const catalogVersion = this.peerCatalogVersion;
+                    const autoTail = { head: Number(row.head_seq ?? 0), forwardNeed, forward: false };
+                    const tail = await client._v2E2EE.pullPeerV2(peer, { ...params, window_mode: 'tail', budget, background, peerPullVersion, autoTail });
+                    if (!isCurrent())
+                        throw new Error('pull invalidated');
+                    if (autoTail.forward) {
+                        const notified = this.peerPushVersions.get(ns) !== pushVersion || this.peerCatalogVersion !== catalogVersion;
+                        if (notified)
+                            this.peerForwardNeeds.set(ns, {});
+                        else if (tail.complete === true && this.peerForwardNeeds.get(ns) === forwardNeed)
+                            this.peerForwardNeeds.delete(ns);
+                        return { ...tail, complete: tail.complete === true && !notified };
+                    }
+                    if (this.canClosePeerTail(ns, tail, pushVersion, catalogVersion)) {
+                        if (this.peerForwardNeeds.get(ns) === forwardNeed)
+                            this.peerForwardNeeds.delete(ns);
+                        return tail;
+                    }
+                    if (!budget.remaining) {
+                        this.schedulePeerRecovery(peer, Number(tail.head_seq ?? 0), true);
+                        return { ...tail, complete: false };
+                    }
+                    forwardNeed = this.peerForwardNeeds.get(ns);
+                    const forwardPushVersion = this.peerPushVersions.get(ns);
+                    const forwardCatalogVersion = this.peerCatalogVersion;
+                    const forward = await client._v2E2EE.pullPeerV2(peer, { ...params, budget, background });
+                    if (!isCurrent())
+                        throw new Error('pull invalidated');
+                    const notified = this.peerPushVersions.get(ns) !== forwardPushVersion || this.peerCatalogVersion !== forwardCatalogVersion;
+                    if (notified)
+                        this.peerForwardNeeds.set(ns, {});
+                    else if (forward.complete === true && this.peerForwardNeeds.get(ns) === forwardNeed)
+                        this.peerForwardNeeds.delete(ns);
+                    const messages = [...new Map([...tail.messages, ...forward.messages].map((message) => [message.seq ?? message.volatile_cursor, message])).values()];
+                    return { ...forward, messages, complete: forward.complete === true && !notified };
+                }
+                const pushVersion = this.peerPushVersions.get(ns);
+                const catalogVersion = this.peerCatalogVersion;
+                const result = await client._v2E2EE.pullPeerV2(peer, { ...params, budget, background, peerPullVersion });
+                if (!isCurrent())
+                    throw new Error('pull invalidated');
+                if (params.window_mode === 'tail') {
+                    const complete = this.canClosePeerTail(ns, result, pushVersion, catalogVersion);
+                    if (!complete) {
+                        this.peerForwardNeeds.set(ns, {});
+                        this.schedulePeerRecovery(peer, Number(result.head_seq ?? 0), true);
+                    }
+                    else if (this.peerForwardNeeds.get(ns) === forwardNeed)
+                        this.peerForwardNeeds.delete(ns);
+                    return { ...result, complete };
+                }
+                if (params.force !== true && (this.peerPushVersions.get(ns) !== pushVersion || this.peerCatalogVersion !== catalogVersion)) {
+                    this.peerForwardNeeds.set(ns, {});
+                    return { ...result, complete: false };
+                }
+                if (params.force !== true && result.complete === true && this.peerForwardNeeds.get(ns) === forwardNeed)
+                    this.peerForwardNeeds.delete(ns);
+                return result;
+            }
+            catch (error) {
+                if (isCurrent())
+                    this.schedulePeerRecovery(peer, Number(row.head_seq ?? 0), Boolean(row.volatile_has_more));
+                return { sender_aid: peer, messages: [], complete: false, ack_seq: isCurrent() ? this.syncState(ns).ack : 0, 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() {
+        this.ensurePeerContext();
+        this.peerCatalogVersion = {};
+        if (!this.hasP2pApplicationSubscription())
+            return;
+        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.hasP2pApplicationSubscription()) {
+                this.peerCatalogDirty = false;
+                const result = await this.runAutomaticPull('message.peers', () => this.peers({}, true));
+                if (!this.hasP2pApplicationSubscription()) {
+                    this.peerCatalogDirty = true;
+                    return;
+                }
+                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 (!sender || client._closing)
+            return;
+        this.ensurePeerContext();
+        if (Number.isSafeInteger(head) && head > 0 && !volatile) {
+            const namespace = this.peerNamespace(sender);
+            const committedAck = this.peerCommittedAck(namespace);
+            const serverAck = this.peerServerConfirmedAcks.get(namespace) ?? 0;
+            if (head <= committedAck && serverAck >= committedAck) {
+                const existing = this.peerRecoveryNeeds.get(sender);
+                if (!existing || this.peerRecoveryTasks.has(sender))
+                    return;
+                if (Number.isSafeInteger(existing.head) && existing.head > 0 && !existing.volatile && existing.head <= committedAck) {
+                    this.peerRecoveryNeeds.delete(sender);
+                    return;
+                }
+            }
+        }
+        const namespace = this.peerNamespace(sender);
+        this.peerPushVersions.set(namespace, {});
+        if (!this.hasP2pApplicationSubscription() || client._sessionOptions?.background_sync === false) {
+            this.peerForwardNeeds.set(namespace, {});
+            return;
+        }
+        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.runAutomaticPull(`peer-init:${sender}`, () => this.initializePeer(sender));
+            if (!this.hasP2pApplicationSubscription())
+                return;
+            const namespace = this.peerNamespace(sender);
+            if (this.shouldTailPeer(namespace, need.head, _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize)) {
+                const forwardNeed = {};
+                this.peerForwardNeeds.set(namespace, forwardNeed);
+                need.pending = false;
+                const pushVersion = this.peerPushVersions.get(namespace);
+                const catalogVersion = this.peerCatalogVersion;
+                const autoTail = { head: need.head, forwardNeed, forward: false };
+                const tail = await this.runAutomaticPull(namespace, async () => {
+                    const beforeAck = this.peerCommittedAck(namespace);
+                    const beforeVolatile = this.peerVolatilePullCursor(sender);
+                    const result = await client._v2E2EE.pullPeerV2(sender, { window_mode: 'tail', background: true, retainMessages: false, budget: { remaining: 1 }, autoTail });
+                    if (autoTail.forward && !result.complete && this.peerCommittedAck(namespace) <= beforeAck && this.peerVolatilePullCursor(sender) === beforeVolatile) {
+                        throw new Error('peer recovery made no progress');
+                    }
+                    return result;
+                });
+                if (generation !== this.captureInlineAckGeneration() || this.peerRecoveryNeeds.get(sender) !== need)
+                    return;
+                if (autoTail.forward) {
+                    if (tail.complete && this.peerForwardNeeds.get(namespace) === forwardNeed
+                        && this.peerPushVersions.get(namespace) === pushVersion && this.peerCatalogVersion === catalogVersion)
+                        this.peerForwardNeeds.delete(namespace);
+                    if (tail.complete && Number(tail.ack_seq) >= need.head && !need.pending
+                        && this.peerPushVersions.get(namespace) === pushVersion && this.peerCatalogVersion === catalogVersion) {
+                        this.peerRecoveryNeeds.delete(sender);
+                        return;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, BACKGROUND_PULL_RETRY_DELAY_MS));
+                }
+                else if (this.canClosePeerTail(namespace, tail, pushVersion, catalogVersion, need)) {
+                    this.peerRecoveryNeeds.delete(sender);
+                    if (this.peerForwardNeeds.get(namespace) === forwardNeed)
+                        this.peerForwardNeeds.delete(namespace);
+                    return;
+                }
+            }
+            while (generation === this.captureInlineAckGeneration() && this.peerRecoveryNeeds.has(sender) && this.hasP2pApplicationSubscription()) {
+                need.pending = false;
+                const forwardNeed = this.peerForwardNeeds.get(namespace);
+                const pushVersion = this.peerPushVersions.get(namespace);
+                const catalogVersion = this.peerCatalogVersion;
+                const result = await this.runAutomaticPull(namespace, async () => {
+                    const beforeAck = this.peerCommittedAck(namespace);
+                    const beforeVolatile = this.peerVolatilePullCursor(sender);
+                    const result = await client._v2E2EE.pullPeerV2(sender, { background: true, retainMessages: false, budget: { remaining: 100 } });
+                    if (!result.complete && this.peerCommittedAck(namespace) <= beforeAck && this.peerVolatilePullCursor(sender) === beforeVolatile) {
+                        throw new Error('peer recovery made no progress');
+                    }
+                    return result;
+                });
+                if (generation !== this.captureInlineAckGeneration() || this.peerRecoveryNeeds.get(sender) !== need)
+                    return;
+                if (result.complete && this.peerForwardNeeds.get(namespace) === forwardNeed
+                    && this.peerPushVersions.get(namespace) === pushVersion && this.peerCatalogVersion === catalogVersion)
+                    this.peerForwardNeeds.delete(namespace);
+                if (result.complete && result.ack_seq >= need.head && !need.pending
+                    && this.peerPushVersions.get(namespace) === pushVersion && this.peerCatalogVersion === catalogVersion) {
+                    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'
@@ -170,15 +957,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;
@@ -202,44 +987,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)
@@ -255,11 +1047,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);
@@ -330,23 +1125,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)
@@ -356,6 +1167,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);
@@ -373,11 +1190,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);
@@ -385,15 +1229,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;
     }
@@ -406,8 +1262,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);
@@ -424,6 +1284,7 @@ export class MessageDeliveryEngine {
         return processed.map((message) => this.publicVolatileMessage(message));
     }
     resetInlineAckState() {
+        this.resetAutomaticPullBackoff();
         this.syncStopped('aborted');
         this.deliveryChangedGeneration += 1;
         this.pendingDeliveryChanges = null;
@@ -445,6 +1306,16 @@ export class MessageDeliveryEngine {
         this.onlineUnreadHintTasks = null;
         this.realtimeTailHeads = null;
         this.syncSessions = null;
+        this.peerCatalogTask = null;
+        this.peerCatalogDirty = false;
+        this.peerRecoveryNeeds.clear();
+        this.peerForwardNeeds.clear();
+        this.peerPushVersions.clear();
+        this.peerCatalogVersion = null;
+        this.peerPullHints.clear();
+        this.peerPullConfirmedThrough.clear();
+        this.peerServerConfirmedAcks.clear();
+        this.peerRecoveryTasks.clear();
     }
     deliveryChangedNamespace(event, payload) {
         if (event === 'group.message_created' && isJsonObject(payload)) {
@@ -716,7 +1587,8 @@ 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)
@@ -733,6 +1605,8 @@ export class MessageDeliveryEngine {
         this.schedulePendingGroupPullIfNeeded(ns, 'pull-gate-idle');
     }
     recordBackgroundPullNeed(ns, throughSeq = 0, probe = false) {
+        if (this.automaticGroupPullStopped(ns))
+            return;
         const client = this.runtime.client;
         if (client._sessionOptions?.background_sync === false || !client._aid
             || !(ns === `p2p:${client._aid}` || ns.startsWith('group:') || ns.startsWith('group_event:')))
@@ -767,6 +1641,8 @@ export class MessageDeliveryEngine {
     finishBackgroundPull(ns, generation, afterSeq, failed) {
         if (generation !== this.captureInlineAckGeneration())
             return;
+        if (this.automaticGroupPullStopped(ns))
+            return;
         const need = this.backgroundPullNeeds.get(ns);
         if (need) {
             if (failed)
@@ -779,7 +1655,7 @@ export class MessageDeliveryEngine {
         this.requestBackgroundPullRecovery();
     }
     requestBackgroundPullRecovery() {
-        if (this.backgroundPullCheckQueued || this.backgroundPullNeeds.size === 0)
+        if (this.backgroundPullCheckQueued || (this.backgroundPullNeeds.size === 0 && !this.peerCatalogDirty && this.peerRecoveryNeeds.size === 0))
             return;
         this.backgroundPullCheckQueued = true;
         const generation = this.captureInlineAckGeneration();
@@ -790,8 +1666,22 @@ export class MessageDeliveryEngine {
             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.automaticGroupPullStopped(ns)) {
+                    this.backgroundPullNeeds.delete(ns);
+                    continue;
+                }
+                if (ns.startsWith('p2p:') && !this.hasP2pApplicationSubscription())
+                    continue;
                 if (this.backgroundPullTasks.has(ns) || this.realtimeSyncing?.has(ns) || this.onlineUnreadHintTasks?.has(ns))
                     continue;
                 const eventScope = ns.startsWith('group_event:');
@@ -845,6 +1735,8 @@ export class MessageDeliveryEngine {
     }
     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;
@@ -856,6 +1748,8 @@ export class MessageDeliveryEngine {
         client._safeAsync(this.fillP2pGap());
     }
     recordPendingGroupPull(ns, seq) {
+        if (this.automaticGroupPullStopped(ns))
+            return;
         if (!ns || !Number.isSafeInteger(seq) || seq <= 0)
             return;
         const pending = this.pendingGroupPullUpper ?? new Map();
@@ -863,6 +1757,8 @@ export class MessageDeliveryEngine {
         pending.set(ns, Math.max(pending.get(ns) ?? 0, seq));
     }
     schedulePendingGroupPullIfNeeded(ns, reason) {
+        if (this.automaticGroupPullStopped(ns))
+            return false;
         const pending = this.pendingGroupPullUpper;
         if (!pending)
             return false;
@@ -898,6 +1794,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) {
@@ -910,6 +1812,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);
@@ -960,21 +1874,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'
@@ -1078,6 +2009,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;
@@ -1145,6 +2077,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;
@@ -1306,12 +2239,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;
     }
@@ -1417,12 +2352,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;
     }
@@ -1471,6 +2408,14 @@ export class MessageDeliveryEngine {
     }
     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);
         }
@@ -1491,22 +2436,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;
     }
@@ -1703,6 +2659,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);
@@ -1745,6 +2705,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);
@@ -1933,20 +2898,26 @@ 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 this.runAutomaticPull(ns, operation, (attempt) => client._rpcPipeline.runPullNamespaceSerialized(key, attempt, true));
         }
         else {
-            await client._withBackgroundRpc(operation);
+            await this.runAutomaticPull(ns, operation, (attempt) => client._withBackgroundRpc(attempt));
         }
     }
     async fillP2pGap() {
+        if (!this.hasP2pApplicationSubscription())
+            return;
         const client = this.runtime.client;
+        if (client._p2pPeerPullEnabled) {
+            this.refreshPendingPeers();
+            return;
+        }
         if (client._sessionOptions?.background_sync === false)
             return;
         if (!client._aid)
@@ -1966,9 +2937,9 @@ export class MessageDeliveryEngine {
             // Gap Fill 本身就是 Forward Pull，必须沿用协调器的完整事务：
             // 原始页提交成功后由协调器负责 Piggyback/终端 ACK。
             const operation = () => client._pullV2(afterSeq, 50, { gateLocked: true });
-            const messages = client._rpcPipeline
-                ? await client._rpcPipeline.runPullSerialized(client._rpcPipeline.pullGateKeyForCall('message.pull', { after_seq: afterSeq, limit: 50 }), operation, true)
-                : await client._withBackgroundRpc(operation);
+            const messages = await this.runAutomaticPull(ns, operation, (attempt) => client._rpcPipeline
+                ? client._rpcPipeline.runPullSerialized(client._rpcPipeline.pullGateKeyForCall('message.pull', { after_seq: afterSeq, limit: 50 }), attempt, true)
+                : client._withBackgroundRpc(attempt));
             filled = messages.length;
             this.prunePushedSeqs(ns);
             client._clientLog.debug(`P2P message gap fill done: after_seq=${afterSeq}, filled=${filled}`);
@@ -1993,6 +2964,8 @@ export class MessageDeliveryEngine {
         if (!groupId)
             return;
         const ns = `group:${groupId}`;
+        if (this.automaticGroupPullStopped(ns))
+            return;
         const afterSeq = client._seqTracker.getContiguousSeq(ns);
         const generation = this.captureInlineAckGeneration();
         const dedupKey = `group_msg:${groupId}:${afterSeq}`;
@@ -2004,10 +2977,10 @@ export class MessageDeliveryEngine {
         let filled = 0;
         let failed = false;
         try {
-            const operation = () => client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: 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._withBackgroundRpc(operation);
+            const operation = () => client._pullGroupV2(groupId, afterSeq, 50, { gateLocked: true, background: true });
+            const messages = await this.runAutomaticPull(ns, operation, (attempt) => client._rpcPipeline
+                ? client._rpcPipeline.runPullNamespaceSerialized(client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, after_seq: afterSeq, limit: 50 }), attempt, true)
+                : client._withBackgroundRpc(attempt));
             filled = messages.length;
             this.prunePushedSeqs(ns);
             client._clientLog.debug(`group message gap fill done: group=${groupId}, after_seq=${afterSeq}, filled=${filled}`);
@@ -2063,6 +3036,8 @@ export class MessageDeliveryEngine {
         if (!groupId)
             return;
         const ns = `group_event:${groupId}`;
+        if (this.automaticGroupPullStopped(ns))
+            return;
         const generation = this.captureInlineAckGeneration();
         const requestedAfterSeq = Number(options.afterSeq ?? 0);
         const afterSeq = Number.isSafeInteger(requestedAfterSeq) && requestedAfterSeq > 0
@@ -2106,10 +3081,10 @@ export class MessageDeliveryEngine {
                 let result;
                 if (client._rpcPipeline) {
                     const pullKey = client._rpcPipeline.pullGateKeyForCall('group.pull_events', request);
-                    result = await client._rpcPipeline.runPullSerialized(pullKey, () => client.call('group.pull_events', request), true);
+                    result = await this.runAutomaticPull(ns, () => client.call('group.pull_events', request), (attempt) => client._rpcPipeline.runPullSerialized(pullKey, attempt, true));
                 }
                 else {
-                    result = await client.call('group.pull_events', request);
+                    result = await this.runAutomaticPull(ns, () => client.call('group.pull_events', request));
                 }
                 if (!isJsonObject(result))
                     return;
@@ -2120,6 +3095,7 @@ export class MessageDeliveryEngine {
                 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));
@@ -2135,35 +3111,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);
@@ -2171,6 +3149,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)
@@ -2183,10 +3164,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);
@@ -2269,6 +3253,8 @@ export class MessageDeliveryEngine {
     enqueueOnlineUnreadEventHint(data) {
         const client = this.runtime.client;
         const groupId = String(data.group_id ?? '').trim();
+        if (this.automaticGroupPullStopped(`group_event:${groupId}`))
+            return;
         if (!groupId || client._sessionOptions?.background_sync === false)
             return;
         this.recordBackgroundPullNeed(`group_event:${groupId}`, positiveSafeSequenceHint(data.event_seq), true);
@@ -2598,9 +3584,9 @@ export class MessageDeliveryEngine {
                 return { messages, raw_count: messages.length };
             };
             if (!client._rpcPipeline)
-                return await invoke();
+                return await this.runAutomaticPull(ns, invoke);
             const key = client._rpcPipeline.pullGateKeyForCall('message.pull', request);
-            return await client._rpcPipeline.runPullSerialized(key, invoke, background);
+            return await this.runAutomaticPull(ns, invoke, (attempt) => client._rpcPipeline.runPullSerialized(key, attempt, background));
         };
         if (order.length === 1 && order[0] === 'tail') {
             result = await run({ window_mode: 'tail', after_seq: this.syncState(ns).ack, limit: pageLimit }, false);
@@ -2665,20 +3651,20 @@ 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);
                 return { messages, raw_count: messages.length };
             };
             if (!client._rpcPipeline)
-                return await invoke();
+                return await this.runAutomaticPull(ns, invoke);
             const key = client._rpcPipeline.pullGateKeyForCall('group.pull', { group_id: groupId, ...request });
-            return await client._rpcPipeline.runPullSerialized(key, invoke, background);
+            return await this.runAutomaticPull(ns, invoke, (attempt) => client._rpcPipeline.runPullNamespaceSerialized(key, attempt, background));
         };
         if (order.length === 1 && order[0] === 'tail') {
             result = await run({ window_mode: 'tail', after_seq: this.syncState(ns).ack, limit: pageLimit }, false);
@@ -2719,9 +3705,9 @@ export class MessageDeliveryEngine {
             return { messages, raw_count: messages.length };
         };
         if (!client._rpcPipeline)
-            return await invoke();
+            return await this.runAutomaticPull(ns, invoke);
         const key = client._rpcPipeline.pullGateKeyForCall('message.pull', request);
-        return await client._rpcPipeline.runPullSerialized(key, invoke, background);
+        return await this.runAutomaticPull(ns, invoke, (attempt) => client._rpcPipeline.runPullSerialized(key, attempt, background));
     }
     async runGroupForwardRecovery(groupId, ns, pageLimit, background = false, throughSeq = 0) {
         const client = this.runtime.client;
@@ -2729,13 +3715,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();
+            return await this.runAutomaticPull(ns, invoke);
         const key = client._rpcPipeline.pullGateKeyForCall('group.pull', request);
-        return await client._rpcPipeline.runPullSerialized(key, invoke, background);
+        return await this.runAutomaticPull(ns, invoke, (attempt) => client._rpcPipeline.runPullNamespaceSerialized(key, attempt, background));
     }
     syncState(ns) {
         const tracker = this.runtime.client._seqTracker;
@@ -3076,6 +4062,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;
@@ -3092,6 +4079,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));
@@ -3110,13 +4100,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);
             }
@@ -3131,6 +4122,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));
@@ -3145,10 +4138,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);
             }
@@ -3342,8 +4336,99 @@ 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);
+        this.ensurePeerContext();
+        this.peerPushVersions.set(this.peerNamespace(sender), {});
+        if (!hasNonEmptyInlineMessage(head.inline_message) && !this.isVolatileMessage(head) && !this.hasP2pApplicationSubscription())
+            return;
+        const generation = this.captureInlineAckGeneration();
+        let ns;
+        try {
+            ns = await this.runAutomaticPull(`peer-init:${sender}`, () => this.initializePeer(sender));
+        }
+        catch (error) {
+            if (generation === this.captureInlineAckGeneration())
+                this.schedulePeerRecovery(sender, positiveSafeSequenceHint(head.seq) ?? 0, this.isVolatileMessage(head));
+            throw error;
+        }
+        const seq = positiveSafeSequenceHint(head.seq);
+        if (this.isVolatileMessage(head)) {
+            await client._v2E2EE.publishV2VolatileMessages([head], 'push', false);
+            return;
+        }
+        if (!seq) {
+            if (client._sessionOptions?.background_sync === false && this.hasP2pApplicationSubscription()) {
+                await this.runAutomaticPull(ns, () => client._v2E2EE.pullPeerV2(sender, { limit: _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize, budget: { remaining: 1 } }));
+            }
+            else
+                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 || !this.hasP2pApplicationSubscription())
+            return;
+        if (client._sessionOptions?.background_sync !== false) {
+            this.schedulePeerRecovery(sender, seq);
+        }
+        else {
+            await this.runAutomaticPull(ns, () => client._v2E2EE.pullPeerV2(sender, { limit: _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize, budget: { remaining: 1 },
+                ...(this.shouldTailPeer(ns, seq, _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize) ? { window_mode: 'tail', autoTail: { head: seq, forward: false } } : {}) }));
+        }
+    }
     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;
@@ -3399,6 +4484,8 @@ export class MessageDeliveryEngine {
                 this.retryPendingP2PInlineAck(ns, pushSeq, 'covered inline push');
             return;
         }
+        if (!this.hasP2pApplicationSubscription())
+            return;
         this.recordBackgroundPullNeed(ns, pushSeq);
         const pullActive = client._rpcPipeline?.hasPullActivity?.(ns) === true;
         if (pullActive || !this.beginRealtimeSync(ns)) {
@@ -3430,6 +4517,8 @@ export class MessageDeliveryEngine {
         if (!groupId)
             return;
         const ns = `group:${groupId}`;
+        if (this.automaticGroupPullStopped(ns))
+            return;
         const generation = this.captureInlineAckGeneration();
         const afterSeq = this.syncState(ns).ack;
         this.recordBackgroundPullNeed(ns, positiveSafeSequenceHint(data.seq));
@@ -3503,6 +4592,8 @@ export class MessageDeliveryEngine {
             return;
         }
         const ns = `group:${groupId}`;
+        if (this.automaticGroupPullStopped(ns))
+            return;
         let inlineConsumed = false;
         const pendingInlineAck = this.pendingGroupInlineAcks?.get(ns);
         const inlineBlockedByPendingAck = Boolean(pendingInlineAck && pendingInlineAck.seq !== seq);
@@ -3561,6 +4652,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') {
@@ -3568,6 +4667,7 @@ export class MessageDeliveryEngine {
                 if (state && Object.keys(state).length > 0) {
                     state = this.migrateSeqStateGroupIds(state);
                     client._seqTracker.restoreSyncState(state);
+                    rememberPeers();
                     return;
                 }
             }
@@ -3577,6 +4677,7 @@ export class MessageDeliveryEngine {
                 if (state && Object.keys(state).length > 0) {
                     state = this.migrateSeqStateGroupIds(state);
                     client._seqTracker.restoreState(state);
+                    rememberPeers();
                     return;
                 }
             }
@@ -3590,6 +4691,7 @@ export class MessageDeliveryEngine {
                         client._seqTracker.restoreSyncState(state);
                     else
                         client._seqTracker.restoreState(state);
+                    rememberPeers();
                 }
             }
         }
@@ -3610,6 +4712,10 @@ 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}`;
@@ -3632,6 +4738,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));
@@ -3659,9 +4775,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();
     }
@@ -3676,12 +4795,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}`);
@@ -3788,7 +4911,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);
@@ -3841,10 +4994,17 @@ 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.peerServerConfirmedAcks.delete(ns);
+        }
         this.dropSeqTrackerPending(ns);
         const saveSeq = client._tokenStore.saveSeq;
         if (seq > 0 && typeof saveSeq === 'function') {
@@ -3902,7 +5062,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;
@@ -3959,6 +5121,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();
@@ -3966,16 +5130,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;
                 }
@@ -3984,10 +5149,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;
@@ -4007,12 +5173,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;
@@ -4122,6 +5289,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);
@@ -4144,9 +5392,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;
@@ -4165,7 +5413,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);
@@ -4182,7 +5430,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);