@agentunion/fastaun-browser 0.5.4 → 0.5.8

package/dist/client/rpc-pipeline.js

@@ -1,9 +1,9 @@
 import { normalizeSlotId, slotIsolationKey } from '../config.js';
-import { ClientSignatureError, ConnectionError, PermissionError, StateError, ValidationError } from '../errors.js';
-import { normalizeGroupId } from '../group-id.js';
+import { ClientSignatureError, ConnectionError, PermissionError, TimeoutError, ValidationError } from '../errors.js';
 import { validateAIDFormat, validateGroupIDFormat } from '../validators.js';
 import { p1363ToDer, pemToArrayBuffer, uint8ToBase64 } from '../crypto.js';
 import { ConnectionState, isJsonObject, } from '../types.js';
+import { normalizeGroupMentionMode, normalizeGroupSettingsResponse } from './mention-mode.js';
 const INTERNAL_ONLY_METHODS = new Set([
     'auth.login1',
     'auth.aid_login1',
@@ -22,11 +22,11 @@ const PROTECTED_HEADERS_METHODS = new Set([
 const SIGNED_METHODS = new Set([
     'message.send',
     'message.v2.put_peer_pk', 'message.v2.bootstrap',
-    'message.v2.group_bootstrap', 'message.v2.pull',
+    'message.v2.group_bootstrap', 'message.v2.pull', 'message.history',
     'message.v2.ack',
     'group.send',
     'group.v2.put_group_pk', 'group.v2.bootstrap',
-    'group.v2.send', 'group.v2.pull', 'group.v2.ack',
+    'group.v2.send', 'group.v2.pull', 'group.history', 'group.v2.ack',
     'group.v2.propose_state', 'group.v2.confirm_state',
     'group.v2.get_proposal',
     'group.kick', 'group.add_member',
@@ -119,9 +119,10 @@ async function signingCertFingerprint(certPem) {
     return await cached;
 }
 const PULL_GATE_STALE_MS = 30000;
+const PULL_GATE_OPERATION_TIMEOUT_MS = 3000;
 const NON_IDEMPOTENT_TIMEOUT = 35;
 const NON_IDEMPOTENT_METHODS = new Set([
-    'message.send', 'group.send', 'group.create', 'group.invite',
+    'message.send', 'mail.send', 'group.send', 'group.create', 'group.invite',
     'group.kick', 'group.remove_member', 'group.leave', 'group.dissolve',
     'group.set_settings',
     'group.update_announcement', 'group.update_rules',
@@ -167,6 +168,8 @@ function isTransientV2PullFallbackError(error) {
 }
 export class RpcPipeline {
     runtime;
+    pullGateStates = new Map();
+    inlineRealtimeScopes = new Set();
     constructor(runtime) {
         this.runtime = runtime;
     }
@@ -196,6 +199,8 @@ export class RpcPipeline {
         };
         const skipSendResultEnvelope = Boolean(p._skip_send_result_envelope);
         delete p._skip_send_result_envelope;
+        const deferGroupReadyPostprocess = Boolean(p._defer_group_ready_postprocess);
+        delete p._defer_group_ready_postprocess;
         if (method === 'message.send') {
             const encrypt = p.encrypt !== undefined ? p.encrypt : true;
             delete p.encrypt;
@@ -217,7 +222,8 @@ export class RpcPipeline {
             if (encrypt) {
                 await client._ensureV2SessionReady('group.send', 'V2 session not initialized; encrypted group.send requires V2 (V1 E2EE removed)');
                 client._clientLog.debug('call route: group.send -> V2 encrypted send');
-                return await client._sendGroupV2(String(p.group_aid ?? p.group_id ?? ''), p.payload ?? {}, {
+                return await client._sendGroupV2(String(p.group_id ?? p.group_aid ?? ''), p.payload ?? {}, {
+                    groupAid: String(p.group_aid ?? '').trim() || undefined,
                     messageId: String(p.message_id ?? '') || undefined,
                     timestamp: p.timestamp,
                     protectedHeaders: client._protectedHeadersFromParams(p),
@@ -246,19 +252,22 @@ export class RpcPipeline {
         }
         const pullGateKey = this.pullGateKeyForCall(method, p);
         if (pullGateKey) {
-            return await this.runPullSerialized(pullGateKey, async () => {
-                return await runWithRpcPriority(() => this.callImplInner(method, p, skipSendResultEnvelope));
-            });
+            return await this.runPullSerialized(pullGateKey, async () => await this.callImplInner(method, p, skipSendResultEnvelope, deferGroupReadyPostprocess), rpcBackground && this.pullGateBackgroundForCall(method, p));
         }
-        return await runWithRpcPriority(() => this.callImplInner(method, p, skipSendResultEnvelope));
+        return await runWithRpcPriority(() => this.callImplInner(method, p, skipSendResultEnvelope, deferGroupReadyPostprocess));
     }
-    async callImplInner(method, p, skipSendResultEnvelope = false) {
+    async callImplInner(method, p, skipSendResultEnvelope = false, deferGroupReadyPostprocess = false) {
         const client = this.runtime.client;
         if (method === 'message.v2.pull' || (method === 'message.pull' && hasMatchingV2Session(client))) {
             try {
                 await client._ensureV2SessionReady('message.pull');
                 client._clientLog.debug(`call route: ${method} -> V2 pull`);
-                const messages = await client._pullV2(Number(p.after_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, { force: p.force === true });
+                if (p.window_mode === 'tail')
+                    return await client._v2E2EE.pullV2TailInternal(p);
+                const messages = await client._pullV2(Number(p.after_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, {
+                    gateLocked: true,
+                    force: p.force === true,
+                });
                 return { messages };
             }
             catch (exc) {
@@ -268,48 +277,71 @@ export class RpcPipeline {
                 client._clientLog.warn(`message.pull V2 route unavailable, fallback to plain pull: ${exc instanceof Error ? exc.message : String(exc)}`);
             }
         }
+        if (method === 'message.history') {
+            await client._ensureV2SessionReady('message.history');
+            return await client._v2E2EE.historyV2Internal(p);
+        }
         if (method === 'message.v2.ack' || (method === 'message.ack' && hasMatchingV2Session(client))) {
             await client._ensureV2SessionReady('message.ack');
             client._clientLog.debug(`call route: ${method} -> V2 ack`);
-            return await client._ackV2(Number(p.seq ?? p.up_to_seq ?? 0) || undefined);
+            return await client._ackV2((p.seq ?? p.up_to_seq));
         }
         if ((method === 'group.v2.pull' || method === 'group.pull') && p.group_id && (method === 'group.v2.pull' || hasMatchingV2Session(client))) {
             await client._ensureV2SessionReady('group.pull');
             client._clientLog.debug(`call route: ${method} -> V2 pull`);
+            if (p.window_mode === 'tail')
+                return await client._v2E2EE.pullGroupV2TailInternal(p);
             const hasExplicitAfterSeq = 'after_seq' in p || 'after_message_seq' in p;
-            const cursorParams = client._explicitGroupCursorParams(p);
-            const ownsCursor = Object.keys(cursorParams).length === 0 || client._groupCursorTargetsCurrentInstance(cursorParams);
-            const pullOpts = {};
+            const cursorParams = this.explicitGroupCursorParams(p);
+            const ownsCursor = Object.keys(cursorParams).length === 0 || this.groupCursorTargetsCurrentInstance(cursorParams);
+            const pullOpts = {
+                gateLocked: true,
+            };
             if (hasExplicitAfterSeq)
                 pullOpts.explicitAfterSeq = true;
+            if (p.force === true)
+                pullOpts.force = true;
             if (Object.keys(cursorParams).length > 0)
                 pullOpts.cursorParams = cursorParams;
             if (!ownsCursor)
                 pullOpts.ownsCursor = false;
             if (String(p.group_id ?? '').trim())
                 pullOpts.wireGroupId = String(p.group_id).trim();
-            const messages = await client._pullGroupV2(String(p.group_aid ?? p.group_id), Number(p.after_seq ?? p.after_message_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, Object.keys(pullOpts).length > 0 ? pullOpts : undefined);
+            if (String(p.group_aid ?? '').trim())
+                pullOpts.groupAid = String(p.group_aid).trim();
+            const messages = await client._pullGroupV2(String(p.group_id ?? p.group_aid), Number(p.after_seq ?? p.after_message_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, Object.keys(pullOpts).length > 0 ? pullOpts : undefined);
             return { messages };
         }
+        if (method === 'group.history') {
+            if (!String(p.group_id ?? p.group_aid ?? '').trim())
+                throw new ValidationError('group.history requires group_id');
+            await client._ensureV2SessionReady('group.history');
+            return await client._v2E2EE.historyGroupV2Internal(p);
+        }
         if ((method === 'group.v2.ack' || method === 'group.ack_messages') && p.group_id && (method === 'group.v2.ack' || hasMatchingV2Session(client))) {
             await client._ensureV2SessionReady('group.ack_messages');
             client._clientLog.debug(`call route: ${method} -> V2 ack`);
-            const cursorParams = client._explicitGroupCursorParams(p);
-            const ownsCursor = Object.keys(cursorParams).length === 0 || client._groupCursorTargetsCurrentInstance(cursorParams);
+            const cursorParams = this.explicitGroupCursorParams(p);
+            const ownsCursor = Object.keys(cursorParams).length === 0 || this.groupCursorTargetsCurrentInstance(cursorParams);
             if (!ownsCursor) {
                 return await client._rawGroupAckMessages(p);
             }
-            return await client._ackGroupV2(String(p.group_aid ?? p.group_id), Number(p.seq ?? p.msg_seq ?? p.up_to_seq ?? 0) || undefined);
+            return await client._ackGroupV2((p.group_id ?? p.group_aid), (p.seq ?? p.msg_seq ?? p.up_to_seq), p.group_aid);
         }
         await this.applyClientSignature(method, p);
         const callTimeout = NON_IDEMPOTENT_METHODS.has(method) ? NON_IDEMPOTENT_TIMEOUT : undefined;
         const rpcBackground = client._backgroundRpcDepth > 0;
-        let result = callTimeout
-            ? await client._transport.call(method, p, callTimeout, undefined, rpcBackground)
-            : await client._transport.call(method, p, undefined, undefined, rpcBackground);
-        result = await this.postprocessResult(method, p, result);
+        const invokeTransport = () => {
+            const request = 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 sendResultModeSource = result;
+        result = await this.postprocessResult(method, p, result, { skipGroupState: deferGroupReadyPostprocess });
         if (!skipSendResultEnvelope) {
-            result = client._delivery.attachSendResultEnvelope(method, p, result, Boolean(p.encrypted));
+            result = client._delivery.attachSendResultEnvelope(method, p, result, Boolean(p.encrypted), sendResultModeSource);
         }
         return result;
     }
@@ -501,22 +533,240 @@ export class RpcPipeline {
     // ── Pull Gate（序列化同一 key 的并发 pull）──────────────────
     pullGateKeyForCall(method, params) {
         const client = this.runtime.client;
-        if (method === 'message.pull' || method === 'message.v2.pull') {
-            return client._aid ? `p2p:${client._aid}` : '';
-        }
-        if (method === 'group.pull' || method === 'group.v2.pull') {
-            const gid = String(params.group_aid ?? params.group_id ?? '').trim();
-            return gid ? `group:${gid}` : '';
+        if (method === 'message.pull' || method === 'message.v2.pull' || method === 'message.history') {
+            if (!client._aid)
+                return '';
+            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)}|force=${String(Boolean(params.force))}`;
+            return `p2p:${client._aid}|${mode}|${cursor}|limit=${String(params.limit)}`;
+        }
+        if (method === 'group.pull' || method === 'group.v2.pull' || method === 'group.history') {
+            const gid = String(params.group_id ?? params.group_aid ?? '').trim();
+            if (!gid)
+                return '';
+            const mode = method === 'group.history' ? 'history' : params.window_mode === 'tail' ? 'tail' : 'forward';
+            const cursor = mode === 'history'
+                ? `before=${String(params.before_seq)}`
+                : `after=${String(params.after_seq ?? params.after_message_seq ?? 0)}|force=${String(Boolean(params.force))}`;
+            return `group:${gid}|${mode}|${cursor}|limit=${String(params.limit)}`;
         }
         if (method === 'group.pull_events') {
-            const gid = String(params.group_aid ?? params.group_id ?? '').trim();
-            return gid ? `group_event:${gid}` : '';
+            const gid = String(params.group_id ?? params.group_aid ?? '').trim();
+            return gid
+                ? `group_event:${gid}|forward|after=${String(params.after_event_seq ?? 0)}|limit=${String(params.limit)}`
+                : '';
+        }
+        return '';
+    }
+    pullGateBackgroundForCall(method, params) {
+        if (method === 'message.history' || method === 'group.history')
+            return false;
+        if (['message.pull', 'message.v2.pull', 'group.pull', 'group.v2.pull'].includes(method)) {
+            return params.window_mode !== 'tail';
+        }
+        return true;
+    }
+    pullGateName(key) {
+        void key;
+        return 'pull';
+    }
+    pullGateState(key) {
+        const name = this.pullGateName(key);
+        let state = this.pullGateStates.get(name);
+        if (!state) {
+            state = { active: null, foreground: [], background: [], byKey: new Map(), lifecycle: new Map(), watchdog: null };
+            this.pullGateStates.set(name, state);
+            this.startPullGateWatchdog(state, name);
+        }
+        return state;
+    }
+    pullGateOperationTimeoutMs() {
+        const client = this.runtime.client;
+        const configured = Number(client._PULL_GATE_OPERATION_TIMEOUT_MS
+            ?? client._PULL_GATE_TIMEOUT_MS
+            ?? client._PULL_GATE_QUEUE_TIMEOUT_MS);
+        return Number.isFinite(configured) && configured > 0 ? configured : PULL_GATE_OPERATION_TIMEOUT_MS;
+    }
+    startPullGateWatchdog(state, name) {
+        if (state.watchdog)
+            return;
+        const interval = Math.min(50, Math.max(1, Math.floor(this.pullGateOperationTimeoutMs() / 4)));
+        const timer = setInterval(() => this.checkPullGate(state, name), interval);
+        state.watchdog = timer;
+        timer.unref?.();
+    }
+    checkPullGate(state, name) {
+        const active = state.active;
+        if (!active) {
+            this.drainPullGate(state);
+            return;
+        }
+        if (!active.pullingStartedAt || Date.now() - active.pullingStartedAt < this.pullGateOperationTimeoutMs())
+            return;
+        if (active.timedOut)
+            return;
+        active.timedOut = 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}`);
+        state.lifecycle.set(active.namespace, 'idle');
+        if (state.active === active)
+            state.active = null;
+        if (state.byKey.get(active.key) === active)
+            state.byKey.delete(active.key);
+        active.resolve = () => { };
+        active.reject(err);
+        this.drainPullGate(state);
+        this.runtime.client._delivery?.onPullGateIdle?.(active.namespace);
+    }
+    realtimePullNamespace(key) {
+        for (const marker of ['|tail|', '|forward|']) {
+            const index = key.indexOf(marker);
+            if (index > 0)
+                return key.slice(0, index);
         }
         return '';
     }
+    pullScopeKey(key) {
+        const index = key.indexOf('|');
+        return index < 0 ? key : key.slice(0, index);
+    }
+    bindActivePullCancellation(method, params, request) {
+        const cancel = request.cancel;
+        const key = this.pullGateKeyForCall(method, params);
+        if (typeof cancel !== 'function' || !key)
+            return request;
+        const state = this.pullGateStates.get(this.pullGateName(key));
+        const active = state?.active;
+        if (!active || active.namespace !== this.pullScopeKey(key) || active.timedOut)
+            return request;
+        const boundCancel = () => cancel.call(request);
+        active.cancel = boundCancel;
+        return request.finally(() => {
+            if (active.cancel === boundCancel)
+                active.cancel = null;
+        });
+    }
+    isPullResponseProcessing(key) {
+        const responseKeys = this.runtime.client._pullResponseKeys;
+        return Boolean(key) && (responseKeys?.get(this.pullScopeKey(key)) ?? 0) > 0;
+    }
+    emptyPullResultForCall(method) {
+        if (method === 'group.pull_events')
+            return { events: [], count: 0 };
+        return { messages: [], count: 0 };
+    }
+    hasPendingRealtimePull(ns) {
+        const normalized = String(ns ?? '').trim();
+        if (!normalized || (!normalized.startsWith('p2p:') && !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)
+            || state.foreground.some(matches)
+            || state.background.some(matches);
+    }
+    hasPullActivity(namespace, includePending = true) {
+        const ns = String(namespace ?? '').trim();
+        if ((!ns.startsWith('p2p:') && !ns.startsWith('group:'))
+            || this.inlineRealtimeScopes.has(ns))
+            return true;
+        const client = this.runtime.client;
+        if ((client._pullResponseKeys?.get?.(ns) ?? 0) > 0)
+            return true;
+        const pendingP2p = client._pendingP2pPullUpper;
+        const pendingGroup = client._pendingGroupPullUpper;
+        if (includePending && ((pendingP2p?.get(ns) ?? 0) > 0 || (pendingGroup?.get(ns) ?? 0) > 0
+            || client._delivery?.hasPendingPull?.(ns)))
+            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:')))
+                return true;
+            if (ns.startsWith('group:') && value.startsWith(`group_pull:${ns}`))
+                return true;
+        }
+        for (const [key, gate] of client._pullGates?.entries?.() ?? []) {
+            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);
+    }
+    async tryRunInlineRealtime(ns, seq, operation) {
+        const normalized = String(ns ?? '').trim();
+        if ((!normalized.startsWith('p2p:') && !normalized.startsWith('group:'))
+            || !Number.isSafeInteger(seq) || seq <= 0 || typeof operation !== 'function') {
+            return { acquired: false };
+        }
+        const client = this.runtime.client;
+        if (this.hasPullActivity(normalized)) {
+            return { acquired: false };
+        }
+        if (this.isPullResponseProcessing(normalized)) {
+            return { acquired: false };
+        }
+        for (const [key, gate] of client._pullGates?.entries?.() ?? []) {
+            if (gate?.inflight && this.pullScopeKey(key) === normalized)
+                return { acquired: false };
+        }
+        const key = `${normalized}|inline|seq=${seq}`;
+        const state = this.pullGateState(key);
+        if (state.active !== null || state.foreground.length > 0 || state.background.length > 0) {
+            return { acquired: false };
+        }
+        const guard = {
+            key,
+            namespace: normalized,
+            background: false,
+            running: true,
+            suspended: false,
+            inline: true,
+            operation,
+            promise: Promise.resolve(undefined),
+            resolve: () => { },
+            reject: () => { },
+            timer: null,
+            resume: null,
+            resumeResolve: null,
+            pullingStartedAt: 0,
+            timedOut: false,
+            cancel: null,
+        };
+        this.inlineRealtimeScopes.add(normalized);
+        try {
+            return { acquired: true, value: await operation() };
+        }
+        finally {
+            this.inlineRealtimeScopes.delete(normalized);
+            if (state.active === guard)
+                state.active = null;
+            this.drainPullGate(state);
+            this.runtime.client._delivery?.onPullGateIdle?.(normalized);
+            this.armQueuedPullTimers(state);
+        }
+    }
     tryAcquirePullGate(key) {
         if (!key)
             return 0;
+        if (this.inlineRealtimeScopes.has(this.pullScopeKey(key)))
+            return null;
+        const serialized = this.pullGateStates.get(this.pullGateName(key));
+        if (serialized?.active?.inline === true)
+            return null;
         const client = this.runtime.client;
         const now = Date.now();
         const gate = client._pullGates.get(key) ?? { inflight: false, startedAt: 0, token: 0 };
@@ -541,25 +791,129 @@ export class RpcPipeline {
         gate.inflight = false;
         gate.startedAt = 0;
     }
-    async runPullSerialized(key, operation) {
-        let token = this.tryAcquirePullGate(key);
-        if (token === null) {
-            const deadline = Date.now() + PULL_GATE_STALE_MS + 100;
-            while (token === null && Date.now() <= deadline) {
-                await this._sleep(25);
-                token = this.tryAcquirePullGate(key);
-            }
-            if (token === null) {
-                throw new StateError(`pull already in-flight for ${key}`);
+    async runPullSerialized(key, operation, background = false) {
+        if (!key)
+            return await this.executePullOperation(operation, background);
+        const state = this.pullGateState(key);
+        const namespace = this.pullScopeKey(key);
+        const active = state.active?.namespace === namespace ? state.active : null;
+        const queuedForeground = state.foreground.find((job) => job.namespace === namespace);
+        const queuedBackground = state.background.find((job) => job.namespace === namespace);
+        const existing = background
+            ? (active ?? queuedForeground ?? queuedBackground)
+            : (queuedForeground ?? (active && !active.background ? active : null) ?? queuedBackground);
+        if (existing) {
+            if (!background && existing.background && existing !== state.active) {
+                const index = state.background.indexOf(existing);
+                if (index >= 0)
+                    state.background.splice(index, 1);
+                existing.background = false;
+                state.foreground.push(existing);
             }
+            return await existing.promise;
+        }
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+        void promise.catch(() => { });
+        const job = {
+            key, namespace, background, running: false, suspended: false, operation, promise, resolve, reject, timer: null,
+            resume: null, resumeResolve: null,
+            pullingStartedAt: 0,
+            timedOut: false,
+            cancel: null,
+        };
+        (background ? state.background : state.foreground).push(job);
+        state.byKey.set(key, job);
+        this.drainPullGate(state);
+        this.checkPullGate(state, this.pullGateName(key));
+        return await promise;
+    }
+    async executePullOperation(operation, background) {
+        if (background)
+            return await this.runtime.client._withBackgroundRpc(operation);
+        return await operation();
+    }
+    async yieldPullGate(key, nextKey, background) {
+        if (!key)
+            return;
+        const state = this.pullGateState(key);
+        const namespace = this.pullScopeKey(key);
+        const job = state.active?.namespace === namespace
+            ? state.active
+            : [...state.foreground, ...state.background].find((candidate) => candidate.namespace === namespace);
+        if (!job || state.active !== job)
+            return;
+        const replacementKey = String(nextKey || key);
+        if (state.byKey.get(job.key) === job)
+            state.byKey.delete(job.key);
+        job.key = replacementKey;
+        job.namespace = this.pullScopeKey(replacementKey);
+        if (background !== undefined)
+            job.background = background;
+        state.byKey.set(job.key, job);
+        state.lifecycle.set(namespace, 'pulled');
+        job.suspended = true;
+        job.resume = new Promise((resolve) => { job.resumeResolve = resolve; });
+        state.active = null;
+        (job.background ? state.background : state.foreground).push(job);
+        this.drainPullGate(state);
+        if (job.resume)
+            await job.resume;
+    }
+    getPullLifecycle(namespace) {
+        const ns = this.pullScopeKey(namespace);
+        if (!ns)
+            return 'idle';
+        return this.pullGateStates.get(this.pullGateName(ns))?.lifecycle.get(ns) ?? 'idle';
+    }
+    setPullLifecycle(namespace, lifecycle) {
+        const ns = this.pullScopeKey(namespace);
+        if (!ns)
+            return;
+        const state = this.pullGateStates.get(this.pullGateName(ns));
+        if (!state || state.active?.namespace !== ns)
+            return;
+        state.lifecycle.set(ns, lifecycle);
+    }
+    drainPullGate(state) {
+        if (state.active)
+            return;
+        const takeRunnable = (queue) => {
+            const index = queue.findIndex((candidate) => !this.inlineRealtimeScopes.has(candidate.namespace));
+            return index >= 0 ? queue.splice(index, 1)[0] : undefined;
+        };
+        const job = takeRunnable(state.foreground) ?? takeRunnable(state.background);
+        if (!job)
+            return;
+        state.active = job;
+        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;
         }
-        try {
-            return await operation();
-        }
-        finally {
-            this.releasePullGate(key, token);
-        }
+        job.running = true;
+        void this.executePullOperation(job.operation, job.background).then(job.resolve, job.reject).finally(() => {
+            if (job.timedOut)
+                return;
+            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);
+            this.runtime.client._delivery?.onPullGateIdle?.(job.namespace);
+        });
     }
+    armQueuedPullTimers(_state) { }
     async rawCall(method, params, options) {
         const client = this.runtime.client;
         const payload = { ...(params ?? {}) };
@@ -570,20 +924,40 @@ export class RpcPipeline {
             await this.applyClientSignature(method, payload);
         }
         const timeout = options?.timeout;
-        if (rpcBackground) {
-            return await client._transport.call(method, payload, timeout, options?.trace, true);
-        }
-        if (options?.trace !== undefined) {
-            return await client._transport.call(method, payload, timeout, options.trace);
+        const invokeTransport = () => {
+            let request;
+            if (rpcBackground)
+                request = client._transport.call(method, payload, timeout, options?.trace, true);
+            else if (options?.trace !== undefined)
+                request = client._transport.call(method, payload, timeout, options.trace);
+            else if (timeout !== undefined)
+                request = client._transport.call(method, payload, timeout);
+            else
+                request = client._transport.call(method, payload);
+            return this.bindActivePullCancellation(method, payload, request);
+        };
+        return await this.transportCallWithIdentityRecovery(invokeTransport, method, payload);
+    }
+    async transportCallWithIdentityRecovery(operation, method, params) {
+        try {
+            return await operation();
         }
-        if (timeout !== undefined) {
-            return await client._transport.call(method, payload, timeout);
+        catch (err) {
+            const recover = this.runtime.client._recoverIdentityAdmission;
+            if (typeof recover !== 'function' || !await recover.call(this.runtime.client, err, method, params))
+                throw err;
+            return await operation();
         }
-        return await client._transport.call(method, payload);
     }
-    async postprocessResult(method, params, result) {
+    async postprocessResult(method, params, result, options = {}) {
         const client = this.runtime.client;
         let next = result;
+        if ((method === 'group.send' || method === 'group.v2.send') && isJsonObject(next)) {
+            next = normalizeGroupMentionMode(next);
+        }
+        if (method === 'group.get_settings' || method === 'group.set_settings') {
+            next = normalizeGroupSettingsResponse(next);
+        }
         if (method === 'group.thought.get' && isJsonObject(next)) {
             client._clientLog?.debug?.(`group.thought.get transport result: found=${String(next.found ?? '')}, raw_count=${Array.isArray(next.thoughts) ? next.thoughts.length : 0}`);
             next = await client._decryptGroupThoughts(next);
@@ -593,12 +967,40 @@ export class RpcPipeline {
             next = await client._decryptMessageThoughts(next);
         }
         if (method === 'message.pull' && isJsonObject(next)) {
-            this.postprocessMessagePull(params, next);
+            const isTail = String(next.window_mode ?? params.window_mode ?? '').trim().toLowerCase() === 'tail';
+            if (!isTail && client._aid && client._seqTracker) {
+                const ns = `p2p:${client._aid}`;
+                const afterSeq = Math.max(0, Number(params.after_seq ?? 0) || 0);
+                await client._delivery.commitPlainForwardPage(ns, afterSeq, 'message.pull', next);
+            }
+            else {
+                this.postprocessMessagePull(params, next);
+            }
         }
         if (method === 'group.pull' && isJsonObject(next)) {
-            this.postprocessGroupPull(params, next);
+            if (Array.isArray(next.messages)) {
+                next.messages = next.messages.map((message) => normalizeGroupMentionMode(message));
+            }
+            const gid = String(params.group_id ?? params.group_aid ?? '').trim();
+            const explicitCursorParams = this.explicitGroupCursorParams(params);
+            const ownsCursor = Object.keys(explicitCursorParams).length === 0
+                || this.groupCursorTargetsCurrentInstance(explicitCursorParams);
+            const isTail = String(next.window_mode ?? params.window_mode ?? '').trim().toLowerCase() === 'tail';
+            if (!ownsCursor) {
+                client._clientLog.debug(`group.pull external cursor skips local Forward commit: group=${gid}`);
+            }
+            else if (!isTail && gid && client._seqTracker) {
+                const ns = `group:${gid}`;
+                const afterSeq = Math.max(0, Number(params.after_message_seq ?? params.after_seq ?? 0) || 0);
+                await client._delivery.commitPlainForwardPage(ns, afterSeq, 'group.pull', next, gid);
+            }
+            else {
+                this.postprocessGroupPull(params, next);
+            }
+        }
+        if (!options.skipGroupState) {
+            next = await client._groupState.postprocessResult(method, params, next);
         }
-        next = await client._groupState.postprocessResult(method, params, next);
         return next;
     }
     _sleep(ms) {
@@ -616,12 +1018,12 @@ export class RpcPipeline {
         if (rawMessages.length) {
             client._seqTracker.onPullResult(ns, rawMessages, Number(params.after_seq ?? 0) || 0);
         }
-        const serverAck = Number(result.server_ack_seq ?? 0);
-        if (serverAck > 0) {
+        const retentionFloor = Math.max(0, Number(result.retention_floor_seq ?? 0));
+        if (retentionFloor > 0) {
             const contig = client._seqTracker.getContiguousSeq(ns);
-            if (contig < serverAck) {
-                client._clientLog?.info?.(`message.pull retention-floor advance: ns=${ns} contiguous=${contig} -> server_ack_seq=${serverAck}`);
-                client._seqTracker.forceContiguousSeq(ns, serverAck);
+            if (contig < retentionFloor) {
+                client._clientLog?.info?.(`message.pull retention-floor advance: ns=${ns} contiguous=${contig} -> retention_floor_seq=${retentionFloor}`);
+                client._seqTracker.forceContiguousSeq(ns, retentionFloor);
             }
         }
         if (client._seqTracker.getContiguousSeq(ns) !== contigBefore) {
@@ -631,7 +1033,10 @@ export class RpcPipeline {
     }
     postprocessGroupPull(params, result) {
         const client = this.runtime.client;
-        const gid = String(params.group_aid ?? params.group_id ?? '').trim();
+        if (Array.isArray(result.messages)) {
+            result.messages = result.messages.map((message) => normalizeGroupMentionMode(message));
+        }
+        const gid = String(params.group_id ?? params.group_aid ?? '').trim();
         if (!gid || !client._seqTracker) {
             return;
         }
@@ -643,12 +1048,15 @@ export class RpcPipeline {
             client._seqTracker.onPullResult(ns, rawMessages, Number(params.after_message_seq ?? params.after_seq ?? 0) || 0);
         }
         const cursor = isJsonObject(result.cursor) ? result.cursor : null;
-        const serverAck = Number(cursor?.current_seq ?? 0);
-        if (serverAck > 0) {
+        const retentionFloor = Math.max(0, Number(result.retention_floor_message_seq ?? result.retention_floor_seq ?? 0), Number(cursor?.retention_floor_seq ?? 0));
+        const isTail = String(result.window_mode ?? params.window_mode ?? '').trim().toLowerCase() === 'tail';
+        const visibilityFloor = isTail ? 0 : Math.max(0, Math.max(0, Number(result.earliest_available_message_seq ?? 1) - 1), Number(cursor?.join_seq ?? 0));
+        const effectiveFloor = Math.max(retentionFloor, visibilityFloor);
+        if (effectiveFloor > 0) {
             const contig = client._seqTracker.getContiguousSeq(ns);
-            if (contig < serverAck) {
-                client._clientLog?.info?.(`group.pull retention-floor advance: ns=${ns} contiguous=${contig} -> cursor.current_seq=${serverAck}`);
-                client._seqTracker.forceContiguousSeq(ns, serverAck);
+            if (contig < effectiveFloor) {
+                client._clientLog?.info?.(`group.pull floor advance: ns=${ns} contiguous=${contig} -> effective_floor=${effectiveFloor} retention_floor=${retentionFloor} visibility_floor=${visibilityFloor} mode=${isTail ? 'tail' : 'forward'}`);
+                client._seqTracker.forceContiguousSeq(ns, effectiveFloor);
             }
         }
         if (client._seqTracker.getContiguousSeq(ns) !== contigBefore) {
@@ -685,33 +1093,16 @@ export class RpcPipeline {
             return;
         }
         const record = params;
-        const rawEntries = [
-            ['group_aid', record.group_aid],
-            ['groupAid', record.groupAid],
-            ['group_id', record.group_id],
-            ['groupId', record.groupId],
-        ];
-        const found = rawEntries.find(([, value]) => String(value ?? '').trim());
-        if (found) {
-            const [key, raw] = found;
-            const rawGroupId = String(raw).trim();
-            const normalizedGroupId = normalizeGroupId(rawGroupId);
-            if (normalizedGroupId) {
-                if (normalizedGroupId !== rawGroupId) {
-                    this.runtime.client._clientLog?.debug?.(`call group identifier normalized: ${key}=${rawGroupId} -> ${normalizedGroupId} method=${method}`);
-                }
-                const existingGroupId = String(record.group_id ?? record.groupId ?? '').trim();
-                if (key === 'group_id' || key === 'groupId') {
-                    params.group_id = rawGroupId;
-                }
-                else if (existingGroupId) {
-                    params.group_id = existingGroupId;
-                }
-                else {
-                    params.group_id = normalizedGroupId;
-                }
-                params.group_aid = normalizedGroupId;
-            }
+        const rawGroupId = String(record.group_id ?? record.groupId ?? '').trim();
+        const rawGroupAid = String(record.group_aid ?? record.groupAid ?? '').trim();
+        if (rawGroupId) {
+            params.group_id = rawGroupId;
+        }
+        else if (rawGroupAid) {
+            params.group_id = rawGroupAid;
+        }
+        if (rawGroupAid) {
+            params.group_aid = rawGroupAid;
         }
         delete record.groupAid;
         delete record.groupId;
@@ -725,6 +1116,19 @@ export class RpcPipeline {
         }
         return cursorParams;
     }
+    explicitGroupCursorParams(params) {
+        const value = params._group_cursor_params;
+        if (!isJsonObject(value))
+            return {};
+        return { ...value };
+    }
+    groupCursorTargetsCurrentInstance(params) {
+        const client = this.runtime.client;
+        const deviceId = String(params.device_id ?? '').trim();
+        const slotId = String(params.slot_id ?? '').trim();
+        return (!deviceId || deviceId === (client._deviceId ?? ''))
+            && (!slotId || slotId === (client._slotId ?? ''));
+    }
     validateMessageRecipient(toAid) {
         if (isGroupServiceAid(toAid)) {
             throw new ValidationError('message.send receiver cannot be group.{issuer}; use group.send instead');