@agentunion/fastaun-browser 0.5.19 → 0.5.21

package/dist/client/rpc-pipeline.js

@@ -1,6 +1,6 @@
-import { normalizeSlotId, slotIsolationKey } from '../config.js';
+import { _INTERNAL_MESSAGE_FLOW_LIMITS, normalizeSlotId, slotIsolationKey } from '../config.js';
 import { ClientSignatureError, ConnectionError, PermissionError, TimeoutError, ValidationError } from '../errors.js';
-import { parseCertMetadata } from '../cert-utils.js';
+import { parseCertMetadata, verifySignatureWithCert } from '../cert-utils.js';
 import { orgRequestParams, validateOrgRequestJSON } from '../org-protocol.js';
 import { canonicalJson as canonicalClientRequest } from '../v2/crypto/canonical.js';
 import { validateAIDFormat, validateGroupIDFormat } from '../validators.js';
@@ -36,6 +36,7 @@ const SIGNED_METHODS = new Set([
     'message.v2.put_peer_pk', 'message.v2.bootstrap',
     'message.v2.group_bootstrap', 'message.v2.pull', 'message.history',
     'message.v2.ack',
+    'message.peers',
     'group.send',
     'group.v2.put_group_pk', 'group.v2.bootstrap',
     'group.v2.send', 'group.v2.pull', 'group.history', 'group.v2.ack',
@@ -185,6 +186,9 @@ function hasMatchingV2Session(client) {
         return true;
     return session.aid === client._aid && session.deviceId === client._deviceId;
 }
+function isP2pNamespace(namespace) {
+    return namespace.startsWith('p2p:') || namespace.startsWith('p2p.peer.v1/');
+}
 function isTransientV2PullFallbackError(error) {
     const text = (error instanceof Error ? error.message : String(error)).toLowerCase();
     return text.includes('no_service') || text.includes('service plane unavailable');
@@ -199,6 +203,12 @@ export class RpcPipeline {
         this.runtime = runtime;
     }
     async call(method, params) {
+        return this._call(method, params);
+    }
+    async _callWithSent(method, params, onSent) {
+        return this._call(method, params, onSent);
+    }
+    async _call(method, params, onSent) {
         const client = this.runtime.client;
         const tStart = Date.now();
         const volatileCursor = method === 'message.pull'
@@ -206,7 +216,7 @@ export class RpcPipeline {
             : '';
         client._clientLog.debug(`call enter: method=${method}`);
         try {
-            const result = await this.callImpl(method, params);
+            const result = await this.callImpl(method, params, onSent);
             client._clientLog.debug(`call exit: elapsed=${Date.now() - tStart}ms method=${method}`);
             return result;
         }
@@ -216,7 +226,7 @@ export class RpcPipeline {
                 const retryParams = { ...(params ?? {}) };
                 delete retryParams.after_volatile_cursor;
                 delete retryParams.client_signature;
-                const result = await this.callImpl(method, retryParams);
+                const result = await this.callImpl(method, retryParams, onSent);
                 client._clientLog.debug(`call exit: elapsed=${Date.now() - tStart}ms method=${method}`);
                 return result;
             }
@@ -224,11 +234,21 @@ export class RpcPipeline {
             throw err;
         }
     }
-    async callImpl(method, params) {
+    async callImpl(method, params, onSent) {
         const client = this.runtime.client;
         const preflight = this.preflight(method, params);
         const p = preflight.params;
         const rpcBackground = preflight.rpcBackground;
+        if (client._p2pPeerPullEnabled) {
+            if (method === 'message.peers')
+                return await client._delivery.peers(p, rpcBackground);
+            if (method === 'message.pull' || method === 'message.v2.pull')
+                return await client._delivery.pullPeers(p, rpcBackground);
+            if (method === 'message.history')
+                return await client._v2E2EE.historyPeerV2(p);
+            if (method === 'message.ack' || method === 'message.v2.ack')
+                return await client._v2E2EE.ackPeerV2(p);
+        }
         const runWithRpcPriority = async (operation) => {
             if (!rpcBackground)
                 return await operation();
@@ -248,6 +268,7 @@ export class RpcPipeline {
                     messageId: String(p.message_id ?? '') || undefined,
                     timestamp: p.timestamp,
                     ttl: p.ttl,
+                    needRender: p.need_render !== false,
                     deviceId: String(p.device_id ?? '').trim() || String(p.to_device_id ?? '').trim() || undefined,
                     protectedHeaders: client._protectedHeadersFromParams(p),
                     context: isJsonObject(p.context) ? p.context : undefined,
@@ -265,6 +286,7 @@ export class RpcPipeline {
                     groupAid: String(p.group_aid ?? '').trim() || undefined,
                     messageId: String(p.message_id ?? '') || undefined,
                     timestamp: p.timestamp,
+                    needRender: p.need_render !== false,
                     protectedHeaders: client._protectedHeadersFromParams(p),
                     context: isJsonObject(p.context) ? p.context : undefined,
                 });
@@ -291,11 +313,15 @@ export class RpcPipeline {
         }
         const pullGateKey = this.pullGateKeyForCall(method, p);
         if (pullGateKey) {
-            return await this.runPullSerialized(pullGateKey, async () => await this.callImplInner(method, p, skipSendResultEnvelope, deferGroupReadyPostprocess, this.pullScopeKey(pullGateKey)), rpcBackground && this.pullGateBackgroundForCall(method, p));
+            if (method === 'group.history' || method === 'group.pull' || method === 'group.v2.pull') {
+                p._rpc_background = rpcBackground;
+                return await this.runPullNamespaceSerialized(pullGateKey, async () => await this.callImplInner(method, p, skipSendResultEnvelope, deferGroupReadyPostprocess, this.pullScopeKey(pullGateKey), onSent), rpcBackground && this.pullGateBackgroundForCall(method, p));
+            }
+            return await this.runPullSerialized(pullGateKey, async () => await this.callImplInner(method, p, skipSendResultEnvelope, deferGroupReadyPostprocess, this.pullScopeKey(pullGateKey), onSent), rpcBackground && this.pullGateBackgroundForCall(method, p));
         }
-        return await runWithRpcPriority(() => this.callImplInner(method, p, skipSendResultEnvelope, deferGroupReadyPostprocess));
+        return await runWithRpcPriority(() => this.callImplInner(method, p, skipSendResultEnvelope, deferGroupReadyPostprocess, undefined, onSent));
     }
-    async callImplInner(method, p, skipSendResultEnvelope = false, deferGroupReadyPostprocess = false, pullNamespace = '') {
+    async callImplInner(method, p, skipSendResultEnvelope = false, deferGroupReadyPostprocess = false, pullNamespace = '', onSent) {
         const client = this.runtime.client;
         if (method === 'message.v2.pull' || (method === 'message.pull' && hasMatchingV2Session(client))) {
             try {
@@ -339,12 +365,13 @@ export class RpcPipeline {
             await client._ensureV2SessionReady('group.pull');
             client._clientLog.debug(`call route: ${method} -> V2 pull`);
             if (p.window_mode === 'tail')
-                return await client._v2E2EE.pullGroupV2TailInternal(p);
+                return await client._v2E2EE.pullGroupV2TailInternal(p, false, true);
             const hasExplicitAfterSeq = 'after_seq' in p || 'after_message_seq' in p;
             const cursorParams = this.explicitGroupCursorParams(p);
             const ownsCursor = Object.keys(cursorParams).length === 0 || this.groupCursorTargetsCurrentInstance(cursorParams);
             const pullOpts = {
                 gateLocked: true,
+                background: p._rpc_background === true,
             };
             if (hasExplicitAfterSeq)
                 pullOpts.explicitAfterSeq = true;
@@ -377,16 +404,24 @@ export class RpcPipeline {
             }
             return await client._ackGroupV2((p.group_id ?? p.group_aid), (p.seq ?? p.msg_seq ?? p.up_to_seq), p.group_aid);
         }
+        const rpcBackground = p._rpc_foreground === true ? false
+            : (typeof p._rpc_background === 'boolean' ? p._rpc_background : client._backgroundRpcDepth > 0);
+        delete p._rpc_background;
+        delete p._rpc_foreground;
         await this.applyClientSignature(method, p);
         const callTimeout = NON_IDEMPOTENT_METHODS.has(method) ? NON_IDEMPOTENT_TIMEOUT : undefined;
-        const rpcBackground = client._backgroundRpcDepth > 0;
         const invokeTransport = () => {
-            const request = callTimeout
-                ? client._transport.call(method, p, callTimeout, undefined, rpcBackground)
-                : client._transport.call(method, p, undefined, undefined, rpcBackground);
+            const request = onSent
+                ? client._transport['_callWithSent'](method, p, onSent, callTimeout, undefined, rpcBackground)
+                : callTimeout
+                    ? client._transport.call(method, p, callTimeout, undefined, rpcBackground)
+                    : client._transport.call(method, p, undefined, undefined, rpcBackground);
             return this.bindActivePullCancellation(method, p, request);
         };
-        let result = await this.transportCallWithIdentityRecovery(invokeTransport, method, p);
+        const invoke = () => this.transportCallWithIdentityRecovery(invokeTransport, method, p);
+        let result = method === 'group.pull'
+            ? await this.runPullSerialized(this.pullGateKeyForCall(method, p), invoke, rpcBackground)
+            : await invoke();
         const sendResultModeSource = result;
         result = await this.postprocessResult(method, p, result, {
             skipGroupState: deferGroupReadyPostprocess,
@@ -407,7 +442,8 @@ export class RpcPipeline {
         }
         const p = { ...(params ?? {}) };
         this.mergeInstanceProtectedHeaders(method, p);
-        const rpcBackground = Boolean(p._rpc_background) || client._backgroundRpcDepth > 0;
+        const rpcBackground = Boolean(p._rpc_background)
+            || (!['message.peers', 'message.pull', 'message.v2.pull', 'group.pull', 'group.v2.pull', 'group.pull_events'].includes(method) && client._backgroundRpcDepth > 0);
         delete p._rpc_background;
         if (method === 'message.send' || method === 'group.send') {
             this.normalizeOutboundMessagePayload(p, method);
@@ -520,7 +556,7 @@ export class RpcPipeline {
         }
         params.device_id = client._deviceId;
         params.slot_id = client._slotId;
-        if ((method === 'message.pull' || method === 'message.v2.pull') && params.after_volatile_cursor === undefined) {
+        if (!client._p2pPeerPullEnabled && (method === 'message.pull' || method === 'message.v2.pull') && params.after_volatile_cursor === undefined) {
             const volatileCursor = client._delivery.volatilePullCursor();
             if (volatileCursor)
                 params.after_volatile_cursor = volatileCursor;
@@ -585,6 +621,12 @@ export class RpcPipeline {
             const paramsHash = Array.from(new Uint8Array(paramsHashBuf))
                 .map(b => b.toString(16).padStart(2, '0'))
                 .join('');
+            if (params.client_signature !== undefined) {
+                const existing = params.client_signature;
+                if (!isJsonObject(existing) || existing.aid !== aid || existing.cert_fingerprint !== await signingCertFingerprint(certPem) || existing.params_hash !== paramsHash || typeof existing.timestamp !== 'string' || !/^\d+$/.test(existing.timestamp) || typeof existing.signature !== 'string' || !await verifySignatureWithCert(certPem, existing.signature, new TextEncoder().encode(`${method}|${aid}|${existing.timestamp}|${paramsHash}`)))
+                    throw new Error('已有客户端签名与请求内容不一致');
+                return;
+            }
             const signData = new TextEncoder().encode(`${method}|${aid}|${ts}|${paramsHash}`);
             const cryptoKey = await signingPrivateKey(currentAid.privateKeyPem);
             const sigP1363 = await crypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, cryptoKey, signData);
@@ -611,12 +653,18 @@ export class RpcPipeline {
         if (method === 'message.pull' || method === 'message.v2.pull' || method === 'message.history') {
             if (!client._aid)
                 return '';
+            const sender = String(params.sender_aid ?? params.peer_aid ?? '').trim();
+            if (client._p2pPeerPullEnabled && !sender)
+                return '';
+            const peerNamespace = sender && (client._p2pPeerPullEnabled || params.cursor_scope === 'peer')
+                ? `p2p.peer.v1/${btoa(String.fromCharCode(...new TextEncoder().encode(sender))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')}`
+                : '';
             const mode = method === 'message.history' ? 'history' : params.window_mode === 'tail' ? 'tail' : 'forward';
             const cursor = mode === 'history'
                 ? `before=${String(params.before_seq)}`
                 : `after=${String(params.after_seq ?? 0)}`;
             const limit = mode === 'forward' ? (Number(params.limit ?? 50) || 50) : params.limit;
-            return `p2p:${client._aid}|mode=${mode}|cursor=${cursor}|volatile=${String(params.after_volatile_cursor ?? '')}|force=${String(Boolean(params.force))}|limit=${String(limit)}`;
+            return `${peerNamespace || `p2p:${client._aid}`}|mode=${mode}|cursor=${cursor}|volatile=${String(params.after_volatile_cursor ?? '')}|force=${String(Boolean(params.force))}|limit=${String(limit)}`;
         }
         if (method === 'group.pull' || method === 'group.v2.pull' || method === 'group.history') {
             const gid = String(params.group_id ?? params.group_aid ?? '').trim();
@@ -653,14 +701,15 @@ export class RpcPipeline {
         void key;
         return 'pull';
     }
-    pullGateState(key) {
-        const name = this.pullGateName(key);
+    pullGateState(key, namespaceOnly = false) {
+        const name = namespaceOnly ? 'pull-namespace' : this.pullGateName(key);
         let state = this.pullGateStates.get(name);
         if (!state) {
-            state = { active: null, foreground: [], background: [], byKey: new Map(), lifecycle: new Map(), watchdog: null };
+            state = { networkLimited: !namespaceOnly, activeByNamespace: new Map(), foreground: [], background: [], byKey: new Map(), lifecycle: new Map(), watchdog: null, backgroundPeerDispatches: 0 };
             this.pullGateStates.set(name, state);
         }
-        this.startPullGateWatchdog(state, name);
+        if (state.networkLimited)
+            this.startPullGateWatchdog(state, name);
         return state;
     }
     pullGateOperationTimeoutMs() {
@@ -687,21 +736,23 @@ export class RpcPipeline {
         }
     }
     checkPullGate(state, name) {
-        const active = state.active;
-        if (!active) {
+        const activeJobs = [...state.activeByNamespace.values()];
+        if (activeJobs.length === 0) {
             this.drainPullGate(state);
             return;
         }
-        if (!active.pullingStartedAt || Date.now() - active.pullingStartedAt < this.pullGateOperationTimeoutMs())
-            return;
-        if (active.timedOut)
-            return;
-        active.timedOut = true;
-        active.invalidated = true;
-        active.cancel?.();
-        const err = new TimeoutError(`pull gate timeout: ${active.namespace}`, { retryable: true });
-        this.runtime.client._clientLog?.warn(`pull gate watchdog timeout: gate=${name} key=${active.key}`);
-        active.reject(err);
+        for (const active of activeJobs) {
+            if (!active.pullingStartedAt || Date.now() - active.pullingStartedAt < this.pullGateOperationTimeoutMs())
+                continue;
+            if (active.timedOut)
+                continue;
+            active.timedOut = true;
+            active.invalidated = true;
+            active.cancel?.();
+            const err = new TimeoutError(`pull gate timeout: ${active.namespace}`, { retryable: true });
+            this.runtime.client._clientLog?.warn(`pull gate watchdog timeout: gate=${name} key=${active.key}`);
+            active.reject(err);
+        }
     }
     realtimePullNamespace(key) {
         for (const marker of ['|tail|', '|forward|']) {
@@ -721,7 +772,7 @@ export class RpcPipeline {
         if (typeof cancel !== 'function' || !key)
             return request;
         const state = this.pullGateStates.get(this.pullGateName(key));
-        const active = state?.active;
+        const active = [...(state?.activeByNamespace.values() ?? [])].find((candidate) => candidate.key === key);
         if (!active || active.key !== key || active.timedOut || active.invalidated)
             return request;
         const boundCancel = () => cancel.call(request);
@@ -742,30 +793,29 @@ export class RpcPipeline {
     }
     hasPendingRealtimePull(ns) {
         const normalized = String(ns ?? '').trim();
-        if (!normalized || (!normalized.startsWith('p2p:') && !normalized.startsWith('group:')))
+        if (!normalized || (!isP2pNamespace(normalized) && !normalized.startsWith('group:')))
             return false;
         if (this.isPullResponseProcessing(normalized))
             return true;
-        const state = this.pullGateStates.get(this.pullGateName(normalized));
-        if (!state)
-            return false;
         const matches = (job) => {
             if (!job)
                 return false;
             return this.realtimePullNamespace(job.key) === normalized;
         };
-        return matches(state.active)
+        return [...this.pullGateStates.values()].some((state) => [...state.activeByNamespace.values()].some(matches)
             || state.foreground.some(matches)
-            || state.background.some(matches);
+            || state.background.some(matches));
     }
     hasPullActivity(namespace, includePending = true) {
         const ns = String(namespace ?? '').trim();
-        if ((!ns.startsWith('p2p:') && !ns.startsWith('group:'))
+        if ((!isP2pNamespace(ns) && !ns.startsWith('group:') && !ns.startsWith('group_event:'))
             || this.inlineRealtimeScopes.has(ns))
             return true;
         const client = this.runtime.client;
         if ((client._pullResponseKeys?.get?.(ns) ?? 0) > 0)
             return true;
+        if (isP2pNamespace(ns) && client._v2E2EE?.hasPeerPageActivity?.(ns))
+            return true;
         const pendingP2p = client._pendingP2pPullUpper;
         const pendingGroup = client._pendingGroupPullUpper;
         if (includePending && ((pendingP2p?.get(ns) ?? 0) > 0 || (pendingGroup?.get(ns) ?? 0) > 0
@@ -773,7 +823,7 @@ export class RpcPipeline {
             return true;
         for (const marker of client._gapFillDone ?? []) {
             const value = String(marker ?? '').trim();
-            if (ns.startsWith('p2p:') && (value.startsWith('p2p_pull:') || value.startsWith('p2p_pull_retry:')))
+            if (isP2pNamespace(ns) && (value.startsWith(`p2p_pull:${ns}`) || value.startsWith(`p2p_pull_retry:${ns}`)))
                 return true;
             if (ns.startsWith('group:') && value.startsWith(`group_pull:${ns}`))
                 return true;
@@ -782,17 +832,15 @@ export class RpcPipeline {
             if (gate?.inflight && this.pullScopeKey(key) === ns)
                 return true;
         }
-        const state = this.pullGateStates.get(this.pullGateName(ns));
-        if (!state)
-            return false;
         const matches = (job) => job !== null && job.namespace === ns;
-        return matches(state.active) || state.foreground.some(matches) || state.background.some(matches);
+        return [...this.pullGateStates.values()].some((state) => [...state.activeByNamespace.values()].some(matches)
+            || state.foreground.some(matches) || state.background.some(matches));
     }
     hasAnyPullActivity() {
         if (this.pullWorkTokens.size > 0)
             return true;
         for (const state of this.pullGateStates.values()) {
-            if (state.active || state.foreground.length > 0 || state.background.length > 0)
+            if (state.activeByNamespace.size > 0 || state.foreground.length > 0 || state.background.length > 0)
                 return true;
         }
         return false;
@@ -816,7 +864,7 @@ export class RpcPipeline {
     }
     async tryRunInlineRealtime(ns, seq, operation) {
         const normalized = String(ns ?? '').trim();
-        if ((!normalized.startsWith('p2p:') && !normalized.startsWith('group:'))
+        if ((!isP2pNamespace(normalized) && !normalized.startsWith('group:'))
             || !Number.isSafeInteger(seq) || seq <= 0 || typeof operation !== 'function') {
             return { acquired: false };
         }
@@ -833,7 +881,9 @@ export class RpcPipeline {
         }
         const key = `${normalized}|inline|seq=${seq}`;
         const state = this.pullGateState(key);
-        if (state.active !== null || state.foreground.length > 0 || state.background.length > 0) {
+        if (state.activeByNamespace.has(normalized)
+            || state.foreground.some((job) => job.namespace === normalized)
+            || state.background.some((job) => job.namespace === normalized)) {
             return { acquired: false };
         }
         const guard = {
@@ -864,11 +914,13 @@ export class RpcPipeline {
         }
         finally {
             this.inlineRealtimeScopes.delete(normalized);
-            if (state.active === guard)
-                state.active = null;
-            this.drainPullGate(state);
+            if (state.activeByNamespace.get(normalized) === guard)
+                state.activeByNamespace.delete(normalized);
+            for (const queuedState of this.pullGateStates.values()) {
+                this.drainPullGate(queuedState);
+                this.armQueuedPullTimers(queuedState);
+            }
             this.runtime.client._delivery?.onPullGateIdle?.(normalized);
-            this.armQueuedPullTimers(state);
         }
     }
     tryAcquirePullGate(key) {
@@ -877,7 +929,7 @@ export class RpcPipeline {
         if (this.inlineRealtimeScopes.has(this.pullScopeKey(key)))
             return null;
         const serialized = this.pullGateStates.get(this.pullGateName(key));
-        if (serialized?.active?.inline === true)
+        if ([...(serialized?.activeByNamespace.values() ?? [])].some((job) => job.inline === true))
             return null;
         const client = this.runtime.client;
         const now = Date.now();
@@ -907,8 +959,10 @@ export class RpcPipeline {
         const ns = this.pullScopeKey(namespace);
         if (!ns)
             return true;
-        const active = this.pullGateStates.get(this.pullGateName(ns))?.active;
-        return !active || active.namespace !== ns || (!active.timedOut && !active.invalidated);
+        return [...this.pullGateStates.values()].every((state) => {
+            const active = state.activeByNamespace.get(ns);
+            return !active || active.namespace !== ns || (!active.timedOut && !active.invalidated);
+        });
     }
     invalidatePulls() {
         if (this.pullInvalidationWait)
@@ -917,8 +971,8 @@ export class RpcPipeline {
         const waits = [];
         for (const state of this.pullGateStates.values()) {
             const jobs = new Set();
-            if (state.active)
-                jobs.add(state.active);
+            for (const active of state.activeByNamespace.values())
+                jobs.add(active);
             for (const job of state.foreground)
                 jobs.add(job);
             for (const job of state.background)
@@ -960,7 +1014,10 @@ export class RpcPipeline {
     pullInvalidationInProgress() {
         return this.pullInvalidationWait !== null;
     }
-    async runPullSerialized(key, operation, background = false) {
+    async runPullNamespaceSerialized(key, operation, background = false) {
+        return await this.runPullSerialized(key, operation, background, true);
+    }
+    async runPullSerialized(key, operation, background = false, namespaceOnly = false) {
         if (this.pullInvalidationInProgress()) {
             throw new Error('pull invalidated');
         }
@@ -978,12 +1035,12 @@ export class RpcPipeline {
                 releasePullWork();
             }
         }
-        const state = this.pullGateState(key);
+        const state = this.pullGateState(key, namespaceOnly);
         const namespace = this.pullScopeKey(key);
         const candidate = state.byKey.get(key);
         const existing = candidate && !candidate.timedOut && !candidate.invalidated ? candidate : null;
         if (existing) {
-            if (!background && existing.background && existing !== state.active) {
+            if (!background && existing.background && ![...state.activeByNamespace.values()].includes(existing)) {
                 const index = state.background.indexOf(existing);
                 if (index >= 0)
                     state.background.splice(index, 1);
@@ -1014,7 +1071,8 @@ export class RpcPipeline {
         (background ? state.background : state.foreground).push(job);
         state.byKey.set(key, job);
         this.drainPullGate(state);
-        this.checkPullGate(state, this.pullGateName(key));
+        if (state.networkLimited)
+            this.checkPullGate(state, this.pullGateName(key));
         return await promise;
     }
     async executePullOperation(operation, background) {
@@ -1032,8 +1090,8 @@ export class RpcPipeline {
             return;
         const state = this.pullGateState(key);
         const namespace = this.pullScopeKey(key);
-        const job = state.active?.key === key ? state.active : null;
-        if (!job || state.active !== job)
+        const job = [...state.activeByNamespace.values()].find((candidate) => candidate.key === key) ?? null;
+        if (!job)
             return;
         const replacementKey = String(nextKey || key);
         if (state.byKey.get(job.key) === job)
@@ -1046,7 +1104,7 @@ export class RpcPipeline {
         state.lifecycle.set(namespace, 'pulled');
         job.suspended = true;
         job.resume = new Promise((resolve) => { job.resumeResolve = resolve; });
-        state.active = null;
+        state.activeByNamespace.delete(namespace);
         (job.background ? state.background : state.foreground).push(job);
         this.drainPullGate(state);
         if (job.resume) {
@@ -1066,69 +1124,92 @@ export class RpcPipeline {
         if (!ns)
             return;
         const state = this.pullGateStates.get(this.pullGateName(ns));
-        if (!state || state.active?.namespace !== ns)
+        if (!state || !state.activeByNamespace.has(ns))
             return;
         state.lifecycle.set(ns, lifecycle);
     }
     drainPullGate(state) {
-        if (state.active)
-            return;
+        const peerForward = (job) => job.background && job.namespace.startsWith('p2p.peer.v1/')
+            && job.key.includes('|peer=background|') && job.key.includes('|tail=false|') && job.key.includes('|force=false|');
+        const priority = (job) => peerForward(job)
+            ? this.runtime.client._delivery?.peerBackgroundPullPriority?.(job.namespace) : undefined;
         const takeRunnable = (queue) => {
-            const index = queue.findIndex((candidate) => !this.inlineRealtimeScopes.has(candidate.namespace));
+            let index = queue.findIndex((candidate) => (!this.inlineRealtimeScopes.has(candidate.namespace)
+                && !state.activeByNamespace.has(candidate.namespace)));
+            if (index >= 0 && queue === state.background && peerForward(queue[index])
+                && (state.backgroundPeerDispatches + 1) % _INTERNAL_MESSAGE_FLOW_LIMITS.pullMaxInflight !== 0) {
+                let best = priority(queue[index]);
+                if (best !== undefined)
+                    for (let next = index + 1; next < queue.length; next += 1) {
+                        const hint = priority(queue[next]);
+                        if (hint === undefined)
+                            break;
+                        if (!this.inlineRealtimeScopes.has(queue[next].namespace) && !state.activeByNamespace.has(queue[next].namespace) && hint < best) {
+                            index = next;
+                            best = hint;
+                        }
+                    }
+            }
             return index >= 0 ? queue.splice(index, 1)[0] : undefined;
         };
-        const foregroundJob = takeRunnable(state.foreground);
-        const foregroundDrained = foregroundJob !== undefined && state.foreground.length === 0;
-        const job = foregroundJob ?? takeRunnable(state.background);
-        if (!job)
-            return;
-        state.active = job;
-        this.runtime.client._delivery?.onPullStarted?.(job.namespace);
-        if (foregroundDrained)
-            this.runtime.client._delivery?.onForegroundPullsDrained?.();
-        if (job.timer)
-            clearTimeout(job.timer);
-        job.pullingStartedAt = Date.now();
-        job.timedOut = false;
-        state.lifecycle.set(job.namespace, 'pulling');
-        const resumeResolve = job.resumeResolve;
-        job.resume = null;
-        job.resumeResolve = null;
-        if (job.suspended) {
-            job.suspended = false;
-            resumeResolve?.();
-            return;
+        while (state.activeByNamespace.size < _INTERNAL_MESSAGE_FLOW_LIMITS.pullMaxInflight) {
+            const foregroundJob = takeRunnable(state.foreground);
+            const foregroundDrained = foregroundJob !== undefined && state.foreground.length === 0;
+            const job = foregroundJob ?? takeRunnable(state.background);
+            if (!job)
+                break;
+            if (peerForward(job))
+                state.backgroundPeerDispatches = (state.backgroundPeerDispatches + 1) % _INTERNAL_MESSAGE_FLOW_LIMITS.pullMaxInflight;
+            state.activeByNamespace.set(job.namespace, job);
+            this.runtime.client._delivery?.onPullStarted?.(job.namespace);
+            if (foregroundDrained)
+                this.runtime.client._delivery?.onForegroundPullsDrained?.();
+            if (job.timer)
+                clearTimeout(job.timer);
+            job.pullingStartedAt = Date.now();
+            job.timedOut = false;
+            state.lifecycle.set(job.namespace, 'pulling');
+            const resumeResolve = job.resumeResolve;
+            job.resume = null;
+            job.resumeResolve = null;
+            if (job.suspended) {
+                job.suspended = false;
+                resumeResolve?.();
+                continue;
+            }
+            job.running = true;
+            let failed = false;
+            void this.executePullOperation(job.operation, state.networkLimited && job.background).then((value) => { if (!job.timedOut && !job.invalidated)
+                job.resolve(value); }, (error) => {
+                failed = true;
+                if (!job.timedOut && !job.invalidated)
+                    job.reject(error);
+            }).finally(() => {
+                this.pullWorkTokens.delete(job.workToken);
+                state.lifecycle.set(job.namespace, 'idle');
+                if (state.activeByNamespace.get(job.namespace) === job)
+                    state.activeByNamespace.delete(job.namespace);
+                if (state.byKey.get(job.key) === job)
+                    state.byKey.delete(job.key);
+                this.drainPullGate(state);
+                job.settledResolve?.();
+                job.settledResolve = null;
+                if (!job.invalidated)
+                    this.runtime.client._delivery?.onPullGateIdle?.(job.namespace);
+                if (failed || job.invalidated)
+                    this.runtime.client._delivery?.onPullAborted?.();
+                this.runtime.client._delivery?.onPullWorkSettled?.();
+            });
         }
-        job.running = true;
-        let failed = false;
-        void this.executePullOperation(job.operation, job.background).then((value) => { if (!job.timedOut && !job.invalidated)
-            job.resolve(value); }, (error) => {
-            failed = true;
-            if (!job.timedOut && !job.invalidated)
-                job.reject(error);
-        }).finally(() => {
-            this.pullWorkTokens.delete(job.workToken);
-            state.lifecycle.set(job.namespace, 'idle');
-            if (state.active === job)
-                state.active = null;
-            if (state.byKey.get(job.key) === job)
-                state.byKey.delete(job.key);
-            this.drainPullGate(state);
-            job.settledResolve?.();
-            job.settledResolve = null;
-            if (!job.invalidated)
-                this.runtime.client._delivery?.onPullGateIdle?.(job.namespace);
-            if (failed || job.invalidated)
-                this.runtime.client._delivery?.onPullAborted?.();
-            this.runtime.client._delivery?.onPullWorkSettled?.();
-        });
     }
     armQueuedPullTimers(_state) { }
     async rawCall(method, params, options) {
         const client = this.runtime.client;
         const payload = { ...(params ?? {}) };
-        const rpcBackground = Boolean(payload._rpc_background) || client._backgroundRpcDepth > 0 || options?.background === true;
+        const rpcBackground = options?.background ?? (!Boolean(payload._rpc_foreground)
+            && (Boolean(payload._rpc_background) || client._backgroundRpcDepth > 0));
         delete payload._rpc_background;
+        delete payload._rpc_foreground;
         const signed = options?.signed ?? true;
         if (signed || method.startsWith('org.')) {
             await this.applyClientSignature(method, payload);
@@ -1146,9 +1227,14 @@ export class RpcPipeline {
                 request = client._transport.call(method, payload);
             return this.bindActivePullCancellation(method, payload, request, options?.pullGateKey ?? '');
         };
-        const result = await this.transportCallWithIdentityRecovery(invokeTransport, method, payload);
-        this.throwIfPullInvalidated(this.pullScopeKey(options?.pullGateKey || this.pullGateKeyForCall(method, payload)));
-        return result;
+        try {
+            const result = await this.transportCallWithIdentityRecovery(invokeTransport, method, payload);
+            this.throwIfPullInvalidated(this.pullScopeKey(options?.pullGateKey || this.pullGateKeyForCall(method, payload)));
+            return result;
+        }
+        finally {
+            client._delivery?.requestBackgroundPullRecovery?.();
+        }
     }
     async transportCallWithIdentityRecovery(operation, method, params) {
         try {