@agentunion/fastaun-browser 0.5.8 → 0.5.10

package/dist/bundle.js

@@ -460,7 +460,7 @@ var init_indexeddb_store = __esm({
 });
 
 // src/version.ts
-var VERSION = "0.5.8";
+var VERSION = "0.5.10";
 
 // src/types.ts
 var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
@@ -799,6 +799,15 @@ var EventDispatcher = class {
   constructor() {
     __publicField(this, "_log", _noopLog);
     __publicField(this, "_handlers", /* @__PURE__ */ new Map());
+    __publicField(this, "_queue", []);
+    __publicField(this, "_draining", false);
+    __publicField(this, "_drainScheduled", false);
+    __publicField(this, "_handlerDepth", 0);
+    __publicField(this, "_synchronousHandlerDepth", 0);
+    __publicField(this, "_drainPromise", null);
+    __publicField(this, "_drainResolve", null);
+    __publicField(this, "_closing", false);
+    __publicField(this, "_closed", false);
   }
   setLogger(log) {
     this._log = log;
@@ -827,17 +836,154 @@ var EventDispatcher = class {
       this._handlers.delete(event);
     }
   }
-  /** 发布事件（依次调用所有处理函数，支持异步） */
+  /**
+   * 发布事件。事件总是异步进入 FIFO 队列；调用方 await 时等待该事件处理完成。
+   * drain 中派生事件只入队，不等待自身，避免事件处理器互相等待形成死锁。
+   */
   async publish(event, payload) {
+    if (this._closed || this._closing) return;
+    let resolveItem;
+    const itemDone = new Promise((resolve) => {
+      resolveItem = resolve;
+    });
+    this._queue.push({
+      run: () => this.dispatchNow(event, payload),
+      resolve: resolveItem
+    });
+    if (this._handlerDepth > 0) return;
+    if (this._drainPromise === null) {
+      this._drainPromise = new Promise((resolve) => {
+        this._drainResolve = resolve;
+      });
+    }
+    this.scheduleDrain();
+    await itemDone;
+  }
+  /** 将事件放入异步 FIFO 队列，不等待处理器执行完成。 */
+  enqueue(event, payload) {
+    void this.publish(event, payload).catch((exc) => {
+      this._log.warn(`event ${event} enqueue failed:`, exc);
+    });
+  }
+  /** 将非事件 observer 放入同一 FIFO 队列。 */
+  enqueueTask(task) {
+    if (this._closed || this._closing) return;
+    this._queue.push({
+      run: () => this.dispatchTask(task),
+      resolve: () => {
+      }
+    });
+    if (this._drainPromise === null) {
+      this._drainPromise = new Promise((resolve) => {
+        this._drainResolve = resolve;
+      });
+    }
+    this.scheduleDrain();
+  }
+  /** 关闭调度器，排空已经入队的应用事件后拒绝后续事件。 */
+  async close() {
+    if (this._closed) return;
+    this._closing = true;
+    if (this._synchronousHandlerDepth > 0) return;
+    if (this._drainPromise !== null) await this._drainPromise;
+    this.finishClose();
+  }
+  /** 等待当前队列排空；事件 handler 重入时直接返回，避免自等待。 */
+  async flush() {
+    if (this._synchronousHandlerDepth > 0) return;
+    if (this._drainPromise !== null) await this._drainPromise;
+    await Promise.resolve();
+  }
+  finishClose() {
+    if (!this._closing || this._closed || this._draining || this._drainScheduled || this._queue.length > 0) return;
+    this._closed = true;
+    this._handlers.clear();
+  }
+  scheduleDrain() {
+    if (this._draining || this._drainScheduled || this._queue.length === 0) return;
+    this._drainScheduled = true;
+    queueMicrotask(() => {
+      this._drainScheduled = false;
+      void this._drain();
+    });
+  }
+  async _drain() {
+    if (this._draining) return;
+    this._draining = true;
+    try {
+      while (this._queue.length > 0) {
+        const item = this._queue.shift();
+        try {
+          await item.run();
+        } catch (exc) {
+          this._log.warn("event dispatch failed:", exc);
+        } finally {
+          item.resolve();
+        }
+      }
+    } finally {
+      this._draining = false;
+      const resolve = this._drainResolve;
+      this._drainResolve = null;
+      this._drainPromise = null;
+      resolve?.();
+      this.finishClose();
+      if (this._queue.length > 0 && !this._closed) {
+        if (this._drainPromise === null) {
+          this._drainPromise = new Promise((nextResolve) => {
+            this._drainResolve = nextResolve;
+          });
+        }
+        this.scheduleDrain();
+      }
+    }
+  }
+  /** 当前是否正在调用应用 handler 或 observer。供生命周期入口识别重入。 */
+  isDispatchingHandler() {
+    return this._handlerDepth > 0;
+  }
+  async dispatchTask(task) {
+    let result;
+    this._handlerDepth += 1;
+    try {
+      this._synchronousHandlerDepth += 1;
+      result = task();
+    } catch (exc) {
+      this._log.warn("event task execution exception:", exc);
+      this._handlerDepth -= 1;
+      return;
+    } finally {
+      this._synchronousHandlerDepth -= 1;
+    }
+    try {
+      await result;
+    } catch (exc) {
+      this._log.warn("event task execution exception:", exc);
+    } finally {
+      this._handlerDepth -= 1;
+    }
+  }
+  async dispatchNow(event, payload) {
     const handlers = [...this._handlers.get(event) ?? []];
     for (const handler of handlers) {
+      let result;
+      this._handlerDepth += 1;
       try {
-        const result = handler(payload);
-        if (result instanceof Promise) {
-          await result;
-        }
+        this._synchronousHandlerDepth += 1;
+        result = handler(payload);
+      } catch (exc) {
+        this._log.warn(`event ${event} handler execution exception:`, exc);
+        this._handlerDepth -= 1;
+        continue;
+      } finally {
+        this._synchronousHandlerDepth -= 1;
+      }
+      try {
+        await result;
       } catch (exc) {
         this._log.warn(`event ${event} handler execution exception:`, exc);
+      } finally {
+        this._handlerDepth -= 1;
       }
     }
   }
@@ -1156,6 +1302,154 @@ var _noopLog3 = { error: () => {
 }, debug: () => {
 } };
 var _rpcIdCounter = 0;
+var WORKER_WEBSOCKET_SOURCE = `
+let socket = null;
+self.onmessage = (event) => {
+  const command = event.data || {};
+  if (command.type === 'connect') {
+    try {
+      socket = new WebSocket(command.url);
+      socket.onopen = () => self.postMessage({ type: 'open' });
+      socket.onmessage = (message) => self.postMessage({ type: 'message', data: message.data });
+      socket.onerror = () => self.postMessage({ type: 'error', message: 'websocket error' });
+      socket.onclose = (close) => self.postMessage({
+        type: 'close', code: close.code, reason: close.reason || '', wasClean: close.wasClean === true,
+      });
+    } catch (error) {
+      self.postMessage({ type: 'error', message: error instanceof Error ? error.message : String(error) });
+    }
+    return;
+  }
+  if (command.type === 'send') {
+    try {
+      if (!socket || socket.readyState !== WebSocket.OPEN) throw new Error('websocket is not open');
+      socket.send(command.data);
+      self.postMessage({ type: 'send_result', id: command.id, ok: true });
+    } catch (error) {
+      self.postMessage({
+        type: 'send_result', id: command.id, ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+    return;
+  }
+  if (command.type === 'close' && socket) socket.close(command.code, command.reason);
+};
+`;
+var _WorkerWebSocketProxy = class _WorkerWebSocketProxy {
+  constructor(url) {
+    __publicField(this, "readyState", _WorkerWebSocketProxy.CONNECTING);
+    __publicField(this, "onopen", null);
+    __publicField(this, "onmessage", null);
+    __publicField(this, "onerror", null);
+    __publicField(this, "onclose", null);
+    __publicField(this, "_worker");
+    __publicField(this, "_workerUrl");
+    __publicField(this, "_listeners", /* @__PURE__ */ new Map());
+    __publicField(this, "_pendingSends", /* @__PURE__ */ new Map());
+    __publicField(this, "_sendSeq", 0);
+    this._workerUrl = URL.createObjectURL(new Blob([WORKER_WEBSOCKET_SOURCE], { type: "text/javascript" }));
+    try {
+      this._worker = new Worker(this._workerUrl);
+    } catch (error) {
+      URL.revokeObjectURL(this._workerUrl);
+      throw error;
+    }
+    this._worker.onmessage = (event) => this._handleWorkerMessage(event.data);
+    this._worker.onerror = (event) => this._emitError(event.message || "websocket worker error");
+    this._worker.postMessage({ type: "connect", url });
+  }
+  send(data) {
+    if (this.readyState !== _WorkerWebSocketProxy.OPEN) return Promise.reject(new Error("websocket is not open"));
+    const id = ++this._sendSeq;
+    return new Promise((resolve, reject) => {
+      this._pendingSends.set(id, { resolve, reject });
+      try {
+        this._worker.postMessage({ type: "send", id, data });
+      } catch (error) {
+        this._pendingSends.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  close(code, reason) {
+    if (this.readyState === _WorkerWebSocketProxy.CLOSED) return;
+    this.readyState = _WorkerWebSocketProxy.CLOSING;
+    this._worker.postMessage({ type: "close", code, reason });
+  }
+  addEventListener(type, listener) {
+    const callback = typeof listener === "function" ? listener : (event) => listener.handleEvent(event);
+    const listeners = this._listeners.get(type) ?? /* @__PURE__ */ new Set();
+    listeners.add(callback);
+    this._listeners.set(type, listeners);
+  }
+  removeEventListener(type, listener) {
+    if (typeof listener === "function") this._listeners.get(type)?.delete(listener);
+  }
+  _handleWorkerMessage(reply) {
+    if (reply.type === "send_result" && reply.id !== void 0) {
+      const pending = this._pendingSends.get(reply.id);
+      if (!pending) return;
+      this._pendingSends.delete(reply.id);
+      if (reply.ok) pending.resolve();
+      else pending.reject(new Error(reply.error || "websocket send failed"));
+      return;
+    }
+    if (reply.type === "open") {
+      this.readyState = _WorkerWebSocketProxy.OPEN;
+      const event = new Event("open");
+      this.onopen?.(event);
+      this._emit("open", event);
+      return;
+    }
+    if (reply.type === "message") {
+      const event = new MessageEvent("message", { data: reply.data });
+      this.onmessage?.(event);
+      this._emit("message", event);
+      return;
+    }
+    if (reply.type === "error") {
+      this._emitError(reply.message || "websocket worker error");
+      return;
+    }
+    if (reply.type === "close") {
+      this.readyState = _WorkerWebSocketProxy.CLOSED;
+      for (const pending of this._pendingSends.values()) pending.reject(new Error("websocket closed"));
+      this._pendingSends.clear();
+      const event = new CloseEvent("close", {
+        code: reply.code ?? 1006,
+        reason: reply.reason ?? "",
+        wasClean: reply.wasClean === true
+      });
+      this.onclose?.(event);
+      this._emit("close", event);
+      this._worker.terminate();
+      URL.revokeObjectURL(this._workerUrl);
+    }
+  }
+  _emitError(message) {
+    const event = new ErrorEvent("error", { message });
+    this.onerror?.(event);
+    this._emit("error", event);
+  }
+  _emit(type, event) {
+    for (const listener of [...this._listeners.get(type) ?? []]) listener(event);
+  }
+};
+__publicField(_WorkerWebSocketProxy, "CONNECTING", 0);
+__publicField(_WorkerWebSocketProxy, "OPEN", 1);
+__publicField(_WorkerWebSocketProxy, "CLOSING", 2);
+__publicField(_WorkerWebSocketProxy, "CLOSED", 3);
+var WorkerWebSocketProxy = _WorkerWebSocketProxy;
+function createTransportWebSocket(url) {
+  if (typeof Worker === "function" && typeof Blob === "function" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function" && typeof URL.revokeObjectURL === "function") {
+    try {
+      return new WorkerWebSocketProxy(url);
+    } catch {
+    }
+  }
+  return new WebSocket(url);
+}
 var TRACE_SPAN_DETAIL_FIELDS = [
   "method",
   "route",
@@ -1426,6 +1720,10 @@ var RPCTransport = class {
     __publicField(this, "_traceMode", "off");
     // Trace observer：observer(traceInfo) 在每次 RPC/事件携带 _trace 时调用
     __publicField(this, "_traceObserver", null);
+    // 每个 transport 实例一个轻量级网络 actor。命令只在此处启动网络操作，
+    // 不等待 RPC 响应，避免应用回调中的 send 反向占住收包路径。
+    __publicField(this, "_actorTail", Promise.resolve());
+    __publicField(this, "_actorBusy", false);
     this._dispatcher = opts.eventDispatcher;
     this._timeout = opts.timeout ?? 10;
     this._connectTimeout = opts.timeout ?? 10;
@@ -1455,15 +1753,18 @@ var RPCTransport = class {
   setMetaObserver(observer) {
     this._metaObserver = observer;
   }
-  async _notifyMetaObserver(message) {
-    if (this._metaObserver === null) return;
+  _notifyMetaObserver(message) {
+    const observer = this._metaObserver;
+    if (observer === null) return;
     const meta = message._meta;
     if (!isJsonObject(meta)) return;
-    try {
-      await this._metaObserver(meta);
-    } catch (exc) {
-      this._log.debug(`meta_observer raised: ${String(exc)}`);
-    }
+    this._dispatcher.enqueueTask(async () => {
+      try {
+        await observer(meta);
+      } catch (exc) {
+        this._log.debug(`meta_observer raised: ${String(exc)}`);
+      }
+    });
   }
   /** 设置 trace 模式：off / log / diag */
   setTraceMode(mode) {
@@ -1499,7 +1800,10 @@ var RPCTransport = class {
    * 连接到 WebSocket URL。
    * 等待首条消息，若为 challenge 则返回，否则进入消息路由。
    */
-  async connect(url) {
+  connect(url) {
+    return this._enqueueActorStart(() => this._connectImpl(url));
+  }
+  async _connectImpl(url) {
     const tStart = Date.now();
     this._log.debug(`connect enter: url=${url}`);
     const setup = await this._withConnectionSetup(async () => {
@@ -1508,7 +1812,7 @@ var RPCTransport = class {
       this._lastCloseCode = null;
       this._lastCloseReason = "";
       const handshake = new Promise((resolve, reject) => {
-        const ws = new WebSocket(url);
+        const ws = createTransportWebSocket(url);
         this._ws = ws;
         this._closed = false;
         let initialResolved = false;
@@ -1637,7 +1941,10 @@ var RPCTransport = class {
     return setup.handshake;
   }
   /** 关闭连接 */
-  async close() {
+  close() {
+    return this._enqueueActor(() => this._closeImpl());
+  }
+  async _closeImpl() {
     await this._withConnectionSetup(() => this._closeUnlocked());
   }
   /** 已持有连接建立串行权时关闭当前 WebSocket。 */
@@ -1708,7 +2015,13 @@ var RPCTransport = class {
    * 发起 JSON-RPC 2.0 调用。
    * 返回 result 字段的值；若有 error 字段则抛出映射后的错误。
    */
-  async call(method, params2, timeout, trace, background = false) {
+  call(method, params2, timeout, trace, background = false) {
+    return this._enqueueActorStart(
+      () => this._callImpl(method, params2, timeout, trace, background),
+      () => new TimeoutError(`rpc cancelled: ${method}`, { retryable: true })
+    );
+  }
+  _callImpl(method, params2, timeout, trace, background = false) {
     if (this._closed || !this._ws) {
       throw this._notConnectedError();
     }
@@ -1749,7 +2062,7 @@ var RPCTransport = class {
         this._drainRpcQueue();
       }, effectiveTimeout);
       const pending = {
-        resolve: async (response) => {
+        resolve: (response) => {
           clearTimeout(timer);
           const elapsed = Date.now() - tStart;
           if (response.error !== void 0) {
@@ -1767,7 +2080,7 @@ var RPCTransport = class {
             if (traceId) {
               this._log.info(`[trace=${traceId}] rpc_recv method=${method} rpc_id=${rpcId} duration_ms=${elapsed} status=ok`);
             }
-            await this._notifyMetaObserver(response);
+            this._notifyMetaObserver(response);
             const respTrace = response._trace;
             if (respTrace && typeof respTrace === "object" && !Array.isArray(respTrace)) {
               this._handleResponseTrace(method, "ok", elapsed, respTrace);
@@ -1815,7 +2128,10 @@ var RPCTransport = class {
     return Object.assign(promise, { cancel: () => cancelRpc?.() });
   }
   /** 发送 JSON-RPC 2.0 Notification，不分配 id，也不等待响应。 */
-  async notify(method, params2) {
+  notify(method, params2) {
+    return this._enqueueActorStart(() => this._notifyImpl(method, params2));
+  }
+  async _notifyImpl(method, params2) {
     if (this._closed || !this._ws) {
       throw this._notConnectedError();
     }
@@ -1844,6 +2160,58 @@ var RPCTransport = class {
     });
     return run;
   }
+  _enqueueActor(operation) {
+    this._actorBusy = true;
+    const run = this._actorTail.then(async () => {
+      return await operation();
+    }, async () => {
+      return await operation();
+    });
+    const tail = run.then(() => void 0, () => void 0);
+    this._actorTail = tail;
+    void tail.then(() => {
+      if (this._actorTail === tail) this._actorBusy = false;
+    });
+    return run;
+  }
+  _enqueueActorStart(operation, cancellationError) {
+    let resolveResult;
+    let rejectResult;
+    const result = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    let cancel;
+    let cancelRequested = false;
+    const launch = () => {
+      if (cancelRequested) return;
+      try {
+        const inner = operation();
+        cancel = inner.cancel;
+        inner.then(resolveResult, rejectResult);
+      } catch (err) {
+        rejectResult(err);
+      }
+    };
+    if (this._actorBusy) {
+      const gate = this._actorTail.then(launch, launch);
+      const tail = gate.then(() => void 0, () => void 0);
+      this._actorTail = tail;
+      void tail.then(() => {
+        if (this._actorTail === tail) this._actorBusy = false;
+      });
+    } else {
+      launch();
+    }
+    return Object.assign(result, {
+      cancel: () => {
+        if (cancelRequested) return;
+        cancelRequested = true;
+        if (cancel) cancel();
+        else rejectResult(cancellationError?.() ?? new TimeoutError("rpc cancelled", { retryable: true }));
+      }
+    });
+  }
   _sendText(payload, context, beforeSend) {
     return this._enqueueSend(async () => {
       if (beforeSend && !beforeSend()) {
@@ -1854,7 +2222,7 @@ var RPCTransport = class {
       }
       const ws = this._ws;
       try {
-        ws.send(payload);
+        await Promise.resolve(ws.send(payload));
       } catch (err) {
         throw await this._sendFailureError(context, err, ws);
       }
@@ -1978,7 +2346,14 @@ var RPCTransport = class {
       const enriched = { ...respTrace, spans };
       this._log.info(traceDisplay(method, status, elapsedMs, respTrace, spans));
       if (this._traceObserver !== null) {
-        this._traceObserver({ type: "rpc", method, trace: enriched, status, duration_ms: elapsedMs });
+        const observer = this._traceObserver;
+        this._dispatcher.enqueueTask(async () => {
+          try {
+            await observer({ type: "rpc", method, trace: enriched, status, duration_ms: elapsedMs });
+          } catch (err) {
+            this._log.debug(`trace observer raised: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        });
       }
     } catch (err) {
       this._log.debug(`trace handling raised: ${err instanceof Error ? err.message : String(err)}`);
@@ -2019,10 +2394,17 @@ var RPCTransport = class {
     this._backgroundRpcQueue = [];
     if (!wasClosed) {
       const error = new ConnectionError(`websocket closed: code=${event.code} reason=${event.reason}`);
-      this._dispatcher.publish("connection.error", { error });
       if (this._onDisconnect) {
-        this._onDisconnect(error, event.code).catch((exc) => this._log.warn("[aun_core.transport] disconnect callback exception:", exc));
+        const onDisconnect = this._onDisconnect;
+        this._dispatcher.enqueueTask(async () => {
+          try {
+            await onDisconnect(error, event.code);
+          } catch (exc) {
+            this._log.warn("[aun_core.transport] disconnect callback exception:", exc);
+          }
+        });
       }
+      this._dispatcher.enqueue("connection.error", { error });
     }
   }
   _notConnectedError() {
@@ -2050,39 +2432,43 @@ var RPCTransport = class {
     if (method === "challenge") {
       this._challenge = message;
       this._log.debug("challenge received");
-      this._dispatcher.publish("connection.challenge", message.params ?? {});
+      this._dispatcher.enqueue("connection.challenge", message.params ?? {});
       return;
     }
     if (method.startsWith("event/")) {
       const protocolEvent = method.slice(6);
       const sdkEvent = EVENT_NAME_MAP[protocolEvent] ?? protocolEvent;
       this._log.debug(`event recv: event=${sdkEvent} ${summarizeDict(message.params, DIAG_RESULT_FIELDS)}`);
-      void this._notifyMetaObserver(message);
+      this._notifyMetaObserver(message);
       const params2 = message.params ?? {};
       if ("_trace" in params2) {
         const eventTrace = params2._trace;
         delete params2._trace;
         if (eventTrace && typeof eventTrace === "object" && !Array.isArray(eventTrace)) {
           if (this._traceObserver !== null) {
-            try {
-              this._traceObserver({ type: "event", event: sdkEvent, trace: eventTrace });
-            } catch {
-            }
+            const observer = this._traceObserver;
+            const tracePayload = eventTrace;
+            this._dispatcher.enqueueTask(async () => {
+              try {
+                await observer({ type: "event", event: sdkEvent, trace: tracePayload });
+              } catch {
+              }
+            });
           }
           const traceObj = eventTrace;
           this._log.info(`[trace=${String(traceObj.trace_id ?? "")}] event_recv event=${sdkEvent}`);
         }
       }
       if (sdkEvent.startsWith("app.")) {
-        this._dispatcher.publish(sdkEvent, params2);
+        this._dispatcher.enqueue(sdkEvent, params2);
         return;
       }
-      this._dispatcher.publish(`_raw.${sdkEvent}`, params2);
+      this._dispatcher.enqueue(`_raw.${sdkEvent}`, params2);
       return;
     }
-    void this._notifyMetaObserver(message);
+    this._notifyMetaObserver(message);
     this._log.debug(`notification recv: method=${method || "<no-method>"}`);
-    this._dispatcher.publish("notification", message);
+    this._dispatcher.enqueue("notification", message);
   }
   _decodeMessage(raw) {
     if (isJsonObject(raw)) {
@@ -2806,7 +3192,7 @@ var _AuthFlow = class _AuthFlow {
     return new Promise((resolve, reject) => {
       let ws;
       try {
-        ws = new WebSocket(gatewayUrl);
+        ws = createTransportWebSocket(gatewayUrl);
       } catch (e) {
         reject(new AuthError(`WebSocket \u8FDE\u63A5\u5931\u8D25: ${gatewayUrl}`));
         return;
@@ -2849,7 +3235,19 @@ var _AuthFlow = class _AuthFlow {
               params: params2
             });
             this._log.debug(`short RPC request full: ${JSON.stringify(redactRpcLogPayload(JSON.parse(requestPayload)))}`);
-            ws.send(requestPayload);
+            const sendResult = ws.send(requestPayload);
+            if (sendResult && typeof sendResult.then === "function") {
+              void Promise.resolve(sendResult).catch((error) => {
+                if (settled) return;
+                settled = true;
+                globalThis.clearTimeout(timeout);
+                try {
+                  ws.close();
+                } catch {
+                }
+                reject(error instanceof Error ? error : new AuthError(String(error)));
+              });
+            }
             return;
           }
           if (!isJsonObject(msg) || msg.id !== requestId) return;
@@ -4507,10 +4905,15 @@ function p2pAppEventFromPlainPullMessage(message) {
 var MessageDeliveryEngine = class {
   constructor(runtime) {
     __publicField(this, "runtime");
+    __publicField(this, "pendingPullDeliveryChanges", null);
+    __publicField(this, "deliveryGeneration", 0);
     __publicField(this, "realtimeTailResults", null);
     __publicField(this, "realtimeSyncing", null);
     __publicField(this, "pendingP2pPullUpper", null);
     __publicField(this, "pendingGroupPullUpper", null);
+    __publicField(this, "pendingPullNoProgressAcks", null);
+    __publicField(this, "onlineUnreadHintTargets", null);
+    __publicField(this, "onlineUnreadHintOwners", null);
     __publicField(this, "realtimeAcking", null);
     __publicField(this, "pendingP2PInlineAcks", null);
     __publicField(this, "pendingGroupInlineAcks", null);
@@ -4523,9 +4926,15 @@ var MessageDeliveryEngine = class {
   }
   resetInlineAckState() {
     this.inlineGeneration += 1;
+    this.deliveryGeneration += 1;
+    this.pendingPullDeliveryChanges = null;
+    void this.runtime.client._rpcPipeline?.invalidatePulls?.();
     this.realtimeSyncing = null;
     this.pendingP2pPullUpper = null;
     this.pendingGroupPullUpper = null;
+    this.pendingPullNoProgressAcks = null;
+    this.onlineUnreadHintTargets = null;
+    this.onlineUnreadHintOwners = null;
     this.realtimeTailResults = null;
     this.realtimeAcking = null;
     this.pendingP2PInlineAcks = null;
@@ -4535,6 +4944,16 @@ var MessageDeliveryEngine = class {
   isInlineGenerationCurrent(generation) {
     return generation === this.inlineGeneration;
   }
+  isPullOperationCurrent() {
+    const client = this.runtime.client;
+    const generation = client._pullOperationGeneration;
+    if (generation === void 0) return true;
+    const pipeline = client._rpcPipeline;
+    return typeof pipeline?.isPullGenerationCurrent === "function" ? pipeline.isPullGenerationCurrent(generation) : true;
+  }
+  ensurePullOperationCurrent() {
+    if (!this.isPullOperationCurrent()) throw new Error("pull invalidated");
+  }
   captureInlineGeneration() {
     return this.inlineGeneration;
   }
@@ -4556,6 +4975,67 @@ var MessageDeliveryEngine = class {
     if (!ns) return;
     this.schedulePendingPullIfNeeded(ns, "pull-gate-idle");
   }
+  onPullWorkSettled() {
+    const pipeline = this.runtime.client._rpcPipeline;
+    if (pipeline?.hasAnyPullActivity?.() === true) return;
+    void this.flushPullDeliveryChanges();
+  }
+  deliveryChangeNamespace(event, payload, ns = "") {
+    if (event === "message.received") return "p2p";
+    if (event !== "group.message_created") return "";
+    if (!isJsonObject(payload)) return "";
+    const aid = String(this.runtime.client._aid ?? "").trim().toLowerCase();
+    const dot = aid.indexOf(".");
+    const localIssuer = dot > 0 ? aid.slice(dot + 1) : "";
+    const fallback = ns.startsWith("group:") ? ns.slice("group:".length) : "";
+    const groupAid = normalizeGroupAid(payload.group_aid ?? payload.group_id ?? fallback, { localIssuer });
+    return groupAid.includes(".") ? `group:${groupAid}` : "";
+  }
+  isDeliverableMessageBody(event, payload) {
+    if (event !== "message.received" && event !== "group.message_created" || !isJsonObject(payload)) return false;
+    const messageId = typeof payload.message_id === "string" && payload.message_id.trim().length > 0;
+    const seq2 = typeof payload.seq === "number" && Number.isSafeInteger(payload.seq) && payload.seq > 0;
+    return messageId || seq2;
+  }
+  recordDeliveryChange(changes, event, payload, ns, generation) {
+    if (generation !== this.deliveryGeneration || !this.isDeliverableMessageBody(event, payload)) return;
+    const namespace = this.deliveryChangeNamespace(event, payload, ns);
+    if (!namespace) return;
+    changes.set(namespace, (changes.get(namespace) ?? 0) + 1);
+  }
+  deliveryChangesPayload(changes) {
+    return [...changes.entries()].filter(([, deliveredCount]) => deliveredCount > 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([namespace, deliveredCount]) => ({ namespace, delivered_count: deliveredCount }));
+  }
+  createDeliveryChangeBatch(trigger) {
+    return { generation: this.deliveryGeneration, trigger, changes: /* @__PURE__ */ new Map(), closed: false };
+  }
+  async flushRealtimeDeliveryChanges(batch) {
+    if (batch.closed) return;
+    batch.closed = true;
+    if (batch.generation !== this.deliveryGeneration) return;
+    if (this.deliveryChangesPayload(batch.changes).length === 0) return;
+    const pendingPull = this.pendingPullDeliveryChanges;
+    this.pendingPullDeliveryChanges = null;
+    if (pendingPull) {
+      for (const [namespace, count] of pendingPull) {
+        batch.changes.set(namespace, (batch.changes.get(namespace) ?? 0) + count);
+      }
+    }
+    if (batch.generation !== this.deliveryGeneration) return;
+    const changes = this.deliveryChangesPayload(batch.changes);
+    if (changes.length === 0) return;
+    this.runtime.client._dispatcher.enqueue("delivery.changed", { trigger: batch.trigger, changes });
+  }
+  async flushPullDeliveryChanges() {
+    const generation = this.deliveryGeneration;
+    const pending = this.pendingPullDeliveryChanges;
+    if (!pending || pending.size === 0 || generation !== this.deliveryGeneration) return;
+    this.pendingPullDeliveryChanges = null;
+    if (generation !== this.deliveryGeneration) return;
+    const changes = this.deliveryChangesPayload(pending);
+    if (changes.length === 0) return;
+    this.runtime.client._dispatcher.enqueue("delivery.changed", { trigger: "pull_drained", changes });
+  }
   recordPendingPull(ns, seq2) {
     if (!ns || !Number.isSafeInteger(seq2) || seq2 <= 0) return;
     const pending = ns.startsWith("p2p:") ? this.pendingP2pPullUpper ?? /* @__PURE__ */ new Map() : this.pendingGroupPullUpper ?? /* @__PURE__ */ new Map();
@@ -4565,7 +5045,15 @@ var MessageDeliveryEngine = class {
   }
   consumePendingPull(ns, throughSeq) {
     const pending = ns.startsWith("p2p:") ? this.pendingP2pPullUpper : this.pendingGroupPullUpper;
-    if ((pending?.get(ns) ?? 0) <= throughSeq) pending?.delete(ns);
+    if ((pending?.get(ns) ?? 0) <= throughSeq) {
+      pending?.delete(ns);
+      this.pendingPullNoProgressAcks?.delete(ns);
+    }
+  }
+  markPendingPullNoProgress(ns, ack) {
+    const blocked = this.pendingPullNoProgressAcks ?? /* @__PURE__ */ new Map();
+    this.pendingPullNoProgressAcks = blocked;
+    blocked.set(ns, ack);
   }
   schedulePendingPullIfNeeded(ns, reason) {
     const pending = ns.startsWith("p2p:") ? this.pendingP2pPullUpper : this.pendingGroupPullUpper;
@@ -4573,15 +5061,20 @@ var MessageDeliveryEngine = class {
     const upper = pending.get(ns) ?? 0;
     if (upper <= 0) {
       pending.delete(ns);
+      this.pendingPullNoProgressAcks?.delete(ns);
       return false;
     }
     const client = this.runtime.client;
     const contiguous = client._seqTracker.getContiguousSeq(ns);
     if (upper <= contiguous) {
       pending.delete(ns);
+      this.pendingPullNoProgressAcks?.delete(ns);
       client._clientLog?.debug(`pending pull upper already covered: ns=${ns}, upper_seq=${upper}, contiguous=${contiguous}, reason=${reason}`);
       return false;
     }
+    const blockedAck = this.pendingPullNoProgressAcks?.get(ns);
+    if (blockedAck !== void 0 && contiguous <= blockedAck) return false;
+    this.pendingPullNoProgressAcks?.delete(ns);
     if (client.state !== "ready" /* READY */ || client._closing || this.realtimeSyncing?.has(ns) || client._rpcPipeline?.hasPullActivity?.(ns, false)) return false;
     pending.delete(ns);
     client._clientLog?.debug(`pending push follow-up pull scheduled: ns=${ns}, upper_seq=${upper}, reason=${reason}`);
@@ -4947,6 +5440,15 @@ var MessageDeliveryEngine = class {
       value = row.effective_ack_seq;
     } else if (Object.prototype.hasOwnProperty.call(row, "ack_seq")) {
       value = row.ack_seq;
+    } else if (Object.prototype.hasOwnProperty.call(row, "cursor")) {
+      const cursor = row.cursor;
+      const cursorRow = isJsonObject(cursor) ? cursor : null;
+      if (cursorRow) {
+        if (!Object.prototype.hasOwnProperty.call(cursorRow, "current_seq")) return 0;
+        value = cursorRow.current_seq;
+      } else {
+        value = cursor;
+      }
     } else {
       return requestedSeq;
     }
@@ -4961,6 +5463,7 @@ var MessageDeliveryEngine = class {
   }
   async confirmPlainForwardAck(ns, method, ackSeq, groupId = "") {
     const client = this.runtime.client;
+    this.ensurePullOperationCurrent();
     const coordinator = this.forwardCoordinator();
     const generation = this.captureInlineGeneration();
     coordinator.recordForwardAck(ns, ackSeq);
@@ -4977,6 +5480,7 @@ var MessageDeliveryEngine = class {
       _rpc_background: true
     };
     const result = await client._rpcPipeline.rawCall(method, params2, { background: true });
+    this.ensurePullOperationCurrent();
     const actualAckSeq = this.resolveForwardAckSeq(result, ackSeq);
     if (actualAckSeq < ackSeq) {
       throw new Error(`${method} server ACK watermark ${actualAckSeq} is below requested ${ackSeq}`);
@@ -4993,6 +5497,7 @@ var MessageDeliveryEngine = class {
       throw new Error(`${method} response must be an object`);
     }
     const client = this.runtime.client;
+    this.ensurePullOperationCurrent();
     const response = result;
     const messages = deduplicatePlainForwardPageMessages(response.messages, afterSeq);
     const coordinator = this.forwardCoordinator();
@@ -5020,24 +5525,29 @@ var MessageDeliveryEngine = class {
     let committed = false;
     try {
       for (const rawMessage of messages) {
+        this.ensurePullOperationCurrent();
         const seq2 = positiveSafeSequenceHint(rawMessage.seq);
         if (method === "message.pull") {
           const appEvent = p2pAppEventFromPlainPullMessage(rawMessage);
           if (await this.publishPulledMessage(appEvent.event, ns, seq2, appEvent.payload, false)) {
             publishedCount += 1;
           }
+          this.ensurePullOperationCurrent();
           continue;
         }
         const message = normalizeGroupMentionMode(rawMessage);
         if (this.recallEventFromGroupMessage(message)) {
           if (await this.publishGroupRecallTombstone(groupId, seq2, message)) {
+            this.ensurePullOperationCurrent();
             this.markPublishedSeq(ns, seq2);
             publishedCount += 1;
           }
         } else if (await this.publishPulledMessage("group.message_created", ns, seq2, message, false)) {
+          this.ensurePullOperationCurrent();
           publishedCount += 1;
         }
       }
+      this.ensurePullOperationCurrent();
       if (messages.length > 0) client._seqTracker.onPullResult(ns, messages, afterSeq);
       const commitTarget = Math.max(
         client._seqTracker.getContiguousSeq(ns),
@@ -5049,17 +5559,20 @@ var MessageDeliveryEngine = class {
         client._seqTracker.forceContiguousSeq(ns, commitTarget);
       }
       if (client._seqTracker.getContiguousSeq(ns) !== pageContigBefore) {
+        this.ensurePullOperationCurrent();
         await this.drainOrderedMessages(ns, void 0, false, false);
+        this.ensurePullOperationCurrent();
         await client._commitSeqTrackerState(ns);
       }
       committed = true;
     } catch (exc) {
-      if (!committed && typeof client._seqTracker.restoreNamespaceSnapshot === "function") {
+      if (this.isPullOperationCurrent() && !committed && typeof client._seqTracker.restoreNamespaceSnapshot === "function") {
         client._seqTracker.restoreNamespaceSnapshot(ns, pageTrackerSnapshot);
         this.dropSeqTrackerPending(ns);
       }
       throw exc;
     }
+    this.ensurePullOperationCurrent();
     const committedAck = client._seqTracker.getContiguousSeq(ns);
     if (deferredServerCursor > 0 && committedAck >= deferredServerCursor) {
       coordinator.clearForwardCursor(ns, committedAck);
@@ -5092,18 +5605,19 @@ var MessageDeliveryEngine = class {
       if (clampedAckSeq < pendingAckSeq) {
         throw new Error(`${ackMethod} cannot confirm pending Forward watermark ${pendingAckSeq}`);
       }
+      this.ensurePullOperationCurrent();
       await this.confirmPlainForwardAck(ns, ackMethod, pendingAckSeq, groupId);
     }
     return { rawCount: messages.length, publishedCount };
   }
-  enqueueOrderedMessage(ns, event, seq2, payload) {
+  enqueueOrderedMessage(ns, event, seq2, payload, source = "push") {
     const client = this.runtime.client;
     let queue = client._pendingOrderedMsgs.get(ns);
     if (!queue) {
       queue = /* @__PURE__ */ new Map();
       client._pendingOrderedMsgs.set(ns, queue);
     }
-    queue.set(seq2, { event, payload });
+    queue.set(seq2, { event, payload, source });
     if (queue.size > PENDING_ORDERED_LIMIT) {
       const drop = [...queue.keys()].sort((a, b) => a - b).slice(0, queue.size - PENDING_ORDERED_LIMIT);
       for (const oldSeq of drop) queue.delete(oldSeq);
@@ -5112,7 +5626,7 @@ var MessageDeliveryEngine = class {
   isGroupEventNamespace(ns) {
     return ns.startsWith("group_event:");
   }
-  async publishOrderedQueueItem(ns, event, seq2, payload, pullResponse = false) {
+  async publishOrderedQueueItem(ns, event, seq2, payload, pullResponse = false, source = "push", batch) {
     const client = this.runtime.client;
     if (event === "group.changed" && this.isGroupEventNamespace(ns)) {
       await this.publishOrderedGroupChanged(payload);
@@ -5123,10 +5637,10 @@ var MessageDeliveryEngine = class {
       return;
     }
     if (pullResponse) {
-      await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload));
+      await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
       return;
     }
-    await client._publishAppEvent(event, payload);
+    await client._publishAppEvent(event, payload, source, ns, batch);
   }
   async publishOrderedGroupChanged(payload) {
     const client = this.runtime.client;
@@ -5269,6 +5783,7 @@ var MessageDeliveryEngine = class {
     setIfPresent("type", firstValue(body.type, params2.type, params2.message_type, params2.payload_type));
     setIfPresent("kind", firstValue(body.kind, params2.kind));
     setIfPresent("version", firstValue(body.version, params2.version));
+    setIfPresent("message_id", firstValue(params2.message_id, body.message_id, resultObj.message_id));
     setIfPresent("timestamp", firstValue(params2.timestamp, resultObj.timestamp, resultObj.created_at, resultObj.t_server, Date.now()));
     envelope.encrypted = Boolean(encrypted);
     const context = this.envelopeMetadata(params2.context);
@@ -5546,8 +6061,9 @@ var MessageDeliveryEngine = class {
     }
     if (contig !== contigBefore) this.persistSeq(ns);
   }
-  async publishAppEvent(event, payload) {
+  async publishAppEvent(event, payload, source = "", ns = "", batch) {
     const client = this.runtime.client;
+    const generation = this.deliveryGeneration;
     if ((event === "message.received" || event === "group.message_created") && isJsonObject(payload)) {
       client._maybeAppendEchoTraceReceive(payload);
     }
@@ -5566,7 +6082,19 @@ var MessageDeliveryEngine = class {
         client._clientLog.debug(`agent_md etag inject skipped: ${String(exc)}`);
       }
     }
-    await client._dispatcher.publish(event, this.normalizePublishedMessagePayload(event, payload));
+    client._dispatcher.enqueue(event, this.normalizePublishedMessagePayload(event, payload));
+    if (generation !== this.deliveryGeneration) return;
+    if (source !== "pull" && source !== "tail" && source !== "pending_retry" && source !== "push" && source !== "inline_push") return;
+    if (source === "push" || source === "inline_push") {
+      const localBatch = batch ?? this.createDeliveryChangeBatch(source);
+      this.recordDeliveryChange(localBatch.changes, event, payload, ns, generation);
+      if (!batch) await this.flushRealtimeDeliveryChanges(localBatch);
+    } else {
+      const changes = this.pendingPullDeliveryChanges ?? /* @__PURE__ */ new Map();
+      this.pendingPullDeliveryChanges = changes;
+      this.recordDeliveryChange(changes, event, payload, ns, generation);
+      if (client._rpcPipeline?.hasAnyPullActivity?.() !== true) await this.flushPullDeliveryChanges();
+    }
   }
   messageTargetsCurrentInstance(message) {
     if (!isJsonObject(message)) return true;
@@ -5699,7 +6227,7 @@ var MessageDeliveryEngine = class {
     const client = this.runtime.client;
     try {
       if (!isJsonObject(data)) {
-        await client._publishAppEvent("message.received", data);
+        await client._publishAppEvent("message.received", data, "push");
         return;
       }
       const msg = { ...data };
@@ -5744,7 +6272,7 @@ var MessageDeliveryEngine = class {
           await client._publishEncryptedPushMessage("message.received", "message.undecryptable", "", seq2 ?? 0, msg, false);
           return;
         }
-        await client._publishAppEvent("message.received", msg);
+        await client._publishAppEvent("message.received", msg, "push");
       }
     } catch (exc) {
       client._clientLog.warn(`P2P push processing failed:${String(exc)}`);
@@ -5783,7 +6311,7 @@ var MessageDeliveryEngine = class {
     const client = this.runtime.client;
     try {
       if (!isJsonObject(data)) {
-        await client._publishAppEvent("group.message_created", data);
+        await client._publishAppEvent("group.message_created", data, "push");
         return;
       }
       const msg = { ...data };
@@ -5855,7 +6383,7 @@ var MessageDeliveryEngine = class {
           await client._publishEncryptedPushMessage("group.message_created", "group.message_undecryptable", "", seq2 ?? 0, msg, true);
           return;
         }
-        await client._publishAppEvent("group.message_created", msg);
+        await client._publishAppEvent("group.message_created", msg, "push");
       }
     } catch (exc) {
       client._clientLog.warn(`group push processing failed:${String(exc)}`);
@@ -5939,11 +6467,16 @@ var MessageDeliveryEngine = class {
       P2P_GAP_FILL_RETRY_MAX_MS
     );
     client._gapFillDone.add(retryKey);
+    const releasePullWork = client._rpcPipeline?.reservePullWork?.() ?? (() => {
+    });
     client._clientLog.debug(`P2P message gap-fill retry scheduled: ns=${ns} attempt=${retryAttempt} delay_ms=${delayMs}`);
     globalThis.setTimeout(() => {
       client._gapFillDone.delete(retryKey);
-      if (client.state !== "ready" /* READY */ || client._closing) return;
-      client._safeAsync(this.fillP2pGap(retryAttempt));
+      if (client.state !== "ready" /* READY */ || client._closing) {
+        releasePullWork();
+        return;
+      }
+      client._safeAsync(this.fillP2pGap(retryAttempt).finally(releasePullWork));
     }, delayMs);
   }
   async fillP2pGap(retryAttempt = 0) {
@@ -6234,9 +6767,30 @@ var MessageDeliveryEngine = class {
     const groupId = String(data.group_id ?? "").trim();
     if (!groupId) return;
     const ns = `group:${groupId}`;
-    client._safeAsync(this.runGroupForwardRecovery(groupId, ns, 50, true).catch((exc) => {
-      client._clientLog?.debug(`online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
-    }));
+    const targets = this.onlineUnreadHintTargets ?? /* @__PURE__ */ new Map();
+    const owners = this.onlineUnreadHintOwners ?? /* @__PURE__ */ new Set();
+    this.onlineUnreadHintTargets = targets;
+    this.onlineUnreadHintOwners = owners;
+    targets.set(ns, Math.max(targets.get(ns) ?? 0, positiveSafeSequenceHint(data.seq)));
+    if (owners.has(ns)) return;
+    owners.add(ns);
+    client._safeAsync((async () => {
+      try {
+        while (true) {
+          const throughSeq = targets.get(ns) ?? 0;
+          const ackBefore = this.syncState(ns).ack;
+          await this.runGroupForwardRecovery(groupId, ns, 50, true, throughSeq);
+          const ackAfter = this.syncState(ns).ack;
+          const target = targets.get(ns) ?? 0;
+          if (ackAfter >= target || ackAfter <= ackBefore) return;
+        }
+      } catch (exc) {
+        client._clientLog?.debug(`online unread hint background Forward failed: ns=${ns} err=${formatDeliveryError(exc)}`);
+      } finally {
+        if (this.onlineUnreadHintTargets === targets) targets.delete(ns);
+        if (this.onlineUnreadHintOwners === owners) owners.delete(ns);
+      }
+    })());
   }
   enqueueOnlineUnreadEventHint(data) {
     const client = this.runtime.client;
@@ -6266,17 +6820,19 @@ var MessageDeliveryEngine = class {
     const key = pipeline.pullGateKeyForCall("message.pull", request);
     return await pipeline.runPullSerialized(key, invoke, background);
   }
-  async runGroupForwardRecovery(groupId, ns, pageLimit, background = false) {
+  async runGroupForwardRecovery(groupId, ns, pageLimit, background = false, throughSeq = 0) {
     const client = this.runtime.client;
+    const state = this.syncState(ns);
+    const maxPages = this.forwardMaxPages(state.ack, throughSeq, pageLimit);
     const request = {
       group_id: groupId,
-      after_seq: this.syncState(ns).ack,
+      after_seq: state.ack,
       limit: pageLimit,
-      max_pages: 1
+      max_pages: maxPages
     };
     const invoke = async () => {
       const after = this.syncState(ns).ack;
-      const messages = await client._pullGroupV2(groupId, after, pageLimit, { gateLocked: true, maxPages: 1 });
+      const messages = await client._pullGroupV2(groupId, after, pageLimit, { gateLocked: true, maxPages });
       return { messages, raw_count: messages.length };
     };
     const pipeline = client._rpcPipeline;
@@ -6290,6 +6846,10 @@ var MessageDeliveryEngine = class {
     const ack = Number(tracker.getContiguousSeq(ns) || 0);
     return { ack, tail: ack, head: Math.max(ack, Number(tracker.getMaxSeenSeq?.(ns) || 0)) };
   }
+  forwardMaxPages(ack, throughSeq, pageLimit) {
+    const limit = Number.isSafeInteger(pageLimit) && pageLimit > 0 ? pageLimit : 1;
+    return Math.max(1, Math.ceil(Math.max(0, throughSeq - ack) / limit));
+  }
   inlineMessage(data) {
     if (!isJsonObject(data)) return null;
     const inline = data.inline_message;
@@ -6469,7 +7029,7 @@ var MessageDeliveryEngine = class {
     const tracker = client._seqTracker;
     const snapshot = typeof tracker.snapshotNamespace === "function" ? tracker.snapshotNamespace(ns) : null;
     try {
-      const published = await this.publishPulledMessage(event, ns, seq2, payload);
+      const published = await this.publishPulledMessage(event, ns, seq2, payload, true, "inline_push");
       if (!this.isInlineGenerationCurrent(generation)) return false;
       if (!published) return false;
       const needsPull = Boolean(tracker.onMessageSeq(ns, seq2));
@@ -6621,17 +7181,28 @@ var MessageDeliveryEngine = class {
     if (forceTail || order[0] === "tail") result = await run(true, false, void 0, false, forceTail);
     const state = this.syncState(ns);
     const tailMissedDuringPull = tailCompleted && Number(client._seqTracker.getMaxSeenSeq(ns) || 0) > state.head;
-    const pendingThroughSeq = tailMissedDuringPull ? Number(client._seqTracker.getMaxSeenSeq(ns) || 0) : 0;
+    const maxSeen = Number(client._seqTracker.getMaxSeenSeq(ns) || 0);
+    const pendingThroughSeq = tailMissedDuringPull ? maxSeen : 0;
     const tailForward = tailCompleted && (state.ack < state.tail - 1 || tailMissedDuringPull);
     const backgroundWindowForward = order[0] === "forward" && !headForward;
     if (headForward || tailForward || client._sessionOptions?.background_sync !== false && backgroundWindowForward) {
+      const forwardTarget = Math.max(
+        headForward ? Math.max(pushSeq, maxSeen) : 0,
+        tailForward || backgroundWindowForward ? state.tail - 1 : 0,
+        tailMissedDuringPull ? maxSeen : 0
+      );
+      const forwardMaxPages = this.forwardMaxPages(state.ack, forwardTarget, pageLimit);
       result = await run(
         false,
         !(headForward || tailForward),
-        headForward ? 2 : order[0] === "tail" ? 1 : void 0,
+        forwardMaxPages,
         headForward || tailMissedDuringPull
       );
-      if (pendingThroughSeq > 0) this.consumePendingPull(ns, pendingThroughSeq);
+      if (pendingThroughSeq > 0) {
+        const committedAck = this.syncState(ns).ack;
+        if (committedAck >= pendingThroughSeq) this.consumePendingPull(ns, pendingThroughSeq);
+        else if (committedAck <= state.ack) this.markPendingPullNoProgress(ns, committedAck);
+      }
     }
     const finalState = this.syncState(ns);
     if (tailCompleted && finalState.ack < finalState.tail - 1) {
@@ -6678,17 +7249,28 @@ var MessageDeliveryEngine = class {
     if (forceTail || order[0] === "tail") result = await run(true, false, void 0, false, forceTail);
     const state = this.syncState(ns);
     const tailMissedDuringPull = tailCompleted && Number(client._seqTracker.getMaxSeenSeq(ns) || 0) > state.head;
-    const pendingThroughSeq = tailMissedDuringPull ? Number(client._seqTracker.getMaxSeenSeq(ns) || 0) : 0;
+    const maxSeen = Number(client._seqTracker.getMaxSeenSeq(ns) || 0);
+    const pendingThroughSeq = tailMissedDuringPull ? maxSeen : 0;
     const tailForward = tailCompleted && (state.ack < state.tail - 1 || tailMissedDuringPull);
     const backgroundWindowForward = order[0] === "forward" && !headForward;
     if (headForward || tailForward || client._sessionOptions?.background_sync !== false && backgroundWindowForward) {
+      const forwardTarget = Math.max(
+        headForward ? Math.max(pushSeq, maxSeen) : 0,
+        tailForward || backgroundWindowForward ? state.tail - 1 : 0,
+        tailMissedDuringPull ? maxSeen : 0
+      );
+      const forwardMaxPages = this.forwardMaxPages(state.ack, forwardTarget, pageLimit);
       result = await run(
         false,
         !(headForward || tailForward),
-        headForward ? 2 : order[0] === "tail" ? 1 : void 0,
+        forwardMaxPages,
         headForward || tailMissedDuringPull
       );
-      if (pendingThroughSeq > 0) this.consumePendingPull(ns, pendingThroughSeq);
+      if (pendingThroughSeq > 0) {
+        const committedAck = this.syncState(ns).ack;
+        if (committedAck >= pendingThroughSeq) this.consumePendingPull(ns, pendingThroughSeq);
+        else if (committedAck <= state.ack) this.markPendingPullNoProgress(ns, committedAck);
+      }
     }
     const finalState = this.syncState(ns);
     if (tailCompleted && finalState.ack < finalState.tail - 1) {
@@ -6935,13 +7517,12 @@ var MessageDeliveryEngine = class {
         }
       }
     } catch (exc) {
-      client._dispatcher.publish("seq_tracker.persist_error", {
+      client._dispatcher.enqueue("seq_tracker.persist_error", {
         phase: "restore",
         aid,
         device_id: deviceId,
         slot_id: slotId,
         error: String(exc)
-      }).catch(() => {
       });
     }
   }
@@ -7132,13 +7713,12 @@ var MessageDeliveryEngine = class {
     } catch (exc) {
       const error = formatDeliveryError(exc);
       client._clientLog.warn(`save SeqTracker state failed: ${error}`);
-      client._dispatcher.publish("seq_tracker.persist_error", {
+      client._dispatcher.enqueue("seq_tracker.persist_error", {
         phase: "save",
         aid,
         device_id: deviceId,
         slot_id: slotId,
         error: String(error)
-      }).catch(() => {
       });
       if (throwOnError) throw exc;
     }
@@ -7243,88 +7823,137 @@ var MessageDeliveryEngine = class {
     }
     return params2;
   }
-  async drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true) {
+  async drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true, batch, source = "pull") {
     const client = this.runtime.client;
+    this.ensurePullOperationCurrent();
     const queue = client._pendingOrderedMsgs.get(ns);
     if (!queue || queue.size === 0) return;
     const contig = client._seqTracker.getContiguousSeq(ns);
     const ready = [...queue.keys()].filter((seq2) => seq2 <= contig && (beforeSeq === void 0 || seq2 < beforeSeq)).sort((a, b) => a - b);
     let delivered = false;
-    for (const seq2 of ready) {
-      const item = queue.get(seq2);
-      queue.delete(seq2);
-      if (!item || client._pushedSeqs.get(ns)?.has(seq2)) continue;
-      await this.publishOrderedQueueItem(ns, item.event, seq2, item.payload, pullResponse);
-      this.markPublishedSeq(ns, seq2);
-      delivered = true;
+    const drainBatches = /* @__PURE__ */ new Map();
+    try {
+      for (const seq2 of ready) {
+        this.ensurePullOperationCurrent();
+        const item = queue.get(seq2);
+        queue.delete(seq2);
+        if (!item || client._pushedSeqs.get(ns)?.has(seq2)) continue;
+        const itemSource = item.source ?? source;
+        let itemBatch = batch;
+        if ((itemSource === "push" || itemSource === "inline_push") && (!batch || batch.trigger !== itemSource)) {
+          itemBatch = drainBatches.get(itemSource);
+          if (!itemBatch) {
+            itemBatch = this.createDeliveryChangeBatch(itemSource);
+            drainBatches.set(itemSource, itemBatch);
+          }
+        }
+        await this.publishOrderedQueueItem(
+          ns,
+          item.event,
+          seq2,
+          item.payload,
+          pullResponse,
+          itemSource,
+          itemBatch
+        );
+        this.ensurePullOperationCurrent();
+        this.markPublishedSeq(ns, seq2);
+        delivered = true;
+      }
+    } finally {
+      for (const drainBatch of drainBatches.values()) {
+        await this.flushRealtimeDeliveryChanges(drainBatch);
+      }
     }
     if (queue.size === 0) {
       client._pendingOrderedMsgs.delete(ns);
-      if (delivered && persist) await this.saveSeqTrackerState();
+      if (delivered && persist) {
+        this.ensurePullOperationCurrent();
+        await this.saveSeqTrackerState();
+      }
     }
   }
-  async publishOrderedMessage(event, ns, seq2, payload) {
+  async publishOrderedMessage(event, ns, seq2, payload, source = "push", operationBatch) {
     const client = this.runtime.client;
-    const seqNum = Number(seq2);
-    if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0) {
-      await this.publishOrderedQueueItem(ns, event, seqNum, payload);
+    const ownsBatch = !operationBatch && (source === "push" || source === "inline_push");
+    const batch = operationBatch ?? (ownsBatch ? this.createDeliveryChangeBatch(source) : void 0);
+    try {
+      const seqNum = Number(seq2);
+      if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0) {
+        await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch);
+        return true;
+      }
+      if (client._pushedSeqs.get(ns)?.has(seqNum)) {
+        const queue2 = client._pendingOrderedMsgs.get(ns);
+        queue2?.delete(seqNum);
+        if (queue2 && queue2.size === 0) client._pendingOrderedMsgs.delete(ns);
+        return false;
+      }
+      const contig = client._seqTracker.getContiguousSeq(ns);
+      if (seqNum > contig) {
+        this.enqueueOrderedMessage(ns, event, seqNum, payload, source);
+        return false;
+      }
+      await this.drainOrderedMessages(ns, seqNum, true, true, batch, source);
+      if (client._pushedSeqs.get(ns)?.has(seqNum)) return false;
+      const queue = client._pendingOrderedMsgs.get(ns);
+      queue?.delete(seqNum);
+      if (queue && queue.size === 0) client._pendingOrderedMsgs.delete(ns);
+      await this.publishOrderedQueueItem(ns, event, seqNum, payload, false, source, batch);
+      this.markPublishedSeq(ns, seqNum);
+      await this.drainOrderedMessages(ns, void 0, false, true, batch, source);
+      if (!client._pendingOrderedMsgs.get(ns)) await this.saveSeqTrackerState();
       return true;
+    } finally {
+      if (ownsBatch && batch) await this.flushRealtimeDeliveryChanges(batch);
     }
-    if (client._pushedSeqs.get(ns)?.has(seqNum)) {
-      const queue2 = client._pendingOrderedMsgs.get(ns);
-      queue2?.delete(seqNum);
-      if (queue2 && queue2.size === 0) client._pendingOrderedMsgs.delete(ns);
-      return false;
-    }
-    const contig = client._seqTracker.getContiguousSeq(ns);
-    if (seqNum > contig) {
-      this.enqueueOrderedMessage(ns, event, seqNum, payload);
-      return false;
-    }
-    await this.drainOrderedMessages(ns, seqNum, true);
-    if (client._pushedSeqs.get(ns)?.has(seqNum)) return false;
-    const queue = client._pendingOrderedMsgs.get(ns);
-    queue?.delete(seqNum);
-    if (queue && queue.size === 0) client._pendingOrderedMsgs.delete(ns);
-    await this.publishOrderedQueueItem(ns, event, seqNum, payload);
-    this.markPublishedSeq(ns, seqNum);
-    await this.drainOrderedMessages(ns);
-    if (!client._pendingOrderedMsgs.get(ns)) await this.saveSeqTrackerState();
-    return true;
   }
-  async publishPulledMessage(event, ns, seq2, payload, persist = true) {
+  async publishPulledMessage(event, ns, seq2, payload, persist = true, source = "pull", operationBatch) {
     const client = this.runtime.client;
-    const seqNum = Number(seq2);
-    if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0 || !ns) {
+    const ownsBatch = !operationBatch && (source === "push" || source === "inline_push");
+    const batch = operationBatch ?? (ownsBatch ? this.createDeliveryChangeBatch(source) : void 0);
+    try {
+      this.ensurePullOperationCurrent();
+      const seqNum = Number(seq2);
+      if (!Number.isFinite(seqNum) || !Number.isInteger(seqNum) || seqNum <= 0 || !ns) {
+        if (event === "message.recalled") {
+          const published = await client._withPullResponseProcessing(
+            ns,
+            () => this.publishMessageRecallTombstone(seq2, payload)
+          );
+          this.ensurePullOperationCurrent();
+          return published;
+        }
+        await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
+        this.ensurePullOperationCurrent();
+        return true;
+      }
+      const queue = client._pendingOrderedMsgs.get(ns);
+      if (client._pushedSeqs.get(ns)?.has(seqNum)) {
+        queue?.delete(seqNum);
+        if (queue && queue.size === 0) client._pendingOrderedMsgs.delete(ns);
+        return false;
+      }
+      await this.drainOrderedMessages(ns, seqNum, false, persist, batch, source);
+      this.ensurePullOperationCurrent();
+      queue?.delete(seqNum);
+      if (queue && queue.size === 0) client._pendingOrderedMsgs.delete(ns);
       if (event === "message.recalled") {
-        return await client._withPullResponseProcessing(
+        const published = await client._withPullResponseProcessing(
           ns,
-          () => this.publishMessageRecallTombstone(seq2, payload)
+          () => this.publishMessageRecallTombstone(seqNum, payload)
         );
+        this.ensurePullOperationCurrent();
+        this.markPublishedSeq(ns, seqNum);
+        return published;
       }
-      await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload));
-      return true;
-    }
-    const queue = client._pendingOrderedMsgs.get(ns);
-    if (client._pushedSeqs.get(ns)?.has(seqNum)) {
-      queue?.delete(seqNum);
-      if (queue && queue.size === 0) client._pendingOrderedMsgs.delete(ns);
-      return false;
-    }
-    await this.drainOrderedMessages(ns, seqNum, false, persist);
-    queue?.delete(seqNum);
-    if (queue && queue.size === 0) client._pendingOrderedMsgs.delete(ns);
-    if (event === "message.recalled") {
-      const published = await client._withPullResponseProcessing(
-        ns,
-        () => this.publishMessageRecallTombstone(seqNum, payload)
-      );
+      await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload, source, ns, batch));
+      this.ensurePullOperationCurrent();
       this.markPublishedSeq(ns, seqNum);
-      return published;
+      return true;
+    } finally {
+      if (ownsBatch && batch) await this.flushRealtimeDeliveryChanges(batch);
     }
-    await client._withPullResponseProcessing(ns, () => client._publishAppEvent(event, payload));
-    this.markPublishedSeq(ns, seqNum);
-    return true;
   }
 };
 
@@ -7513,12 +8142,7 @@ var LifecycleController = class {
   async publishConnectionEvent(owner, event, payload) {
     const client = this.runtime.client;
     this.assertConnectionAttemptOwner(owner);
-    client._connectEventDispatchDepth = Number(client._connectEventDispatchDepth ?? 0) + 1;
-    try {
-      await client._dispatcher.publish(event, payload);
-    } finally {
-      client._connectEventDispatchDepth -= 1;
-    }
+    client._dispatcher.enqueue(event, payload);
     return this.ownsConnectionAttempt(owner);
   }
   async cancelConnectionAttemptAndWait() {
@@ -7826,14 +8450,9 @@ var LifecycleController = class {
       client._clientLog.warn(`reentrant close failed: ${err instanceof Error ? err.message : String(err)}`);
     });
   }
-  async publishLifecycleStopEvent(payload) {
+  publishLifecycleStopEvent(payload) {
     const client = this.runtime.client;
-    client._lifecycleStopEventDispatchDepth = Number(client._lifecycleStopEventDispatchDepth ?? 0) + 1;
-    try {
-      await client._dispatcher.publish("state_change", payload);
-    } finally {
-      client._lifecycleStopEventDispatchDepth -= 1;
-    }
+    client._dispatcher.enqueue("state_change", payload);
   }
   async withLifecycleStop(operation, kind) {
     const client = this.runtime.client;
@@ -7884,14 +8503,17 @@ var LifecycleController = class {
           return;
         }
         client._delivery.resetInlineAckState();
+        const pullInvalidation = client._rpcPipeline?.invalidatePulls?.();
+        client._rpcPipeline?.stopPullGateWatchdogs?.();
+        await client._transport.close();
+        await pullInvalidation;
         await client._cancelReconnectAndWait();
         await this.cancelConnectionAttemptAndWait();
         await client._saveSeqTrackerState();
         client._stopBackgroundTasks();
-        await client._transport.close();
         if (client._closing) return;
         this.runtime.lifecycle.resetForDisconnect("standby");
-        await this.publishLifecycleStopEvent({ state: client._publicState(client._state) });
+        this.publishLifecycleStopEvent({ state: client._publicState(client._state) });
         client._clientLog.debug(`disconnect exit: elapsed=${Date.now() - tStart}ms`);
       }, "disconnect");
     } finally {
@@ -7901,6 +8523,7 @@ var LifecycleController = class {
   async close() {
     const client = this.runtime.client;
     const tStart = Date.now();
+    const calledFromHandler = client._dispatcher.isDispatchingHandler();
     client._clientLog.debug(`close enter: state=${client._state}`);
     this.runtime.lifecycle.setClosing(true);
     client._delivery.resetInlineAckState();
@@ -7909,26 +8532,39 @@ var LifecycleController = class {
       return;
     }
     return this.withLifecycleStop(async () => {
-      await client._cancelReconnectAndWait();
-      await this.cancelConnectionAttemptAndWait();
-      await client._saveSeqTrackerState();
-      client._stopBackgroundTasks();
-      if (client._state === "idle" || client._state === "closed") {
+      try {
+        const pullInvalidation = client._rpcPipeline?.invalidatePulls?.();
+        client._rpcPipeline?.stopPullGateWatchdogs?.();
+        client._stopBackgroundTasks();
+        if (client._state === "idle" || client._state === "closed") {
+          const reconnectCancellation2 = client._cancelReconnectAndWait();
+          const connectionCancellation2 = this.cancelConnectionAttemptAndWait();
+          await Promise.all([reconnectCancellation2, connectionCancellation2]);
+          await pullInvalidation;
+          await client._saveSeqTrackerState();
+          this.runtime.lifecycle.setState("closed");
+          client._resetSeqTrackingState();
+          client._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms reason=already_idle`);
+          return;
+        }
+        const reconnectCancellation = client._cancelReconnectAndWait();
+        const connectionCancellation = this.cancelConnectionAttemptAndWait();
+        try {
+          await client._transport.call("auth.logout", {});
+        } catch (err) {
+          client._clientLog.warn(`auth.logout during close failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await client._transport.close();
+        await Promise.all([pullInvalidation, reconnectCancellation, connectionCancellation]);
+        await client._saveSeqTrackerState();
         this.runtime.lifecycle.setState("closed");
+        this.publishLifecycleStopEvent({ state: client._publicState(client._state) });
         client._resetSeqTrackingState();
-        client._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms reason=already_idle`);
-        return;
-      }
-      try {
-        await client._transport.call("auth.logout", {});
-      } catch (err) {
-        client._clientLog.warn(`auth.logout during close failed: ${err instanceof Error ? err.message : String(err)}`);
+        client._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms`);
+      } finally {
+        const closing = client._dispatcher.close();
+        if (!calledFromHandler) await closing;
       }
-      await client._transport.close();
-      this.runtime.lifecycle.setState("closed");
-      await this.publishLifecycleStopEvent({ state: client._publicState(client._state) });
-      client._resetSeqTrackingState();
-      client._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms`);
     }, "close");
   }
 };
@@ -14725,6 +15361,14 @@ var PROTECTED_HEADERS_METHODS = /* @__PURE__ */ new Set([
   "message.thought.put",
   "group.thought.put"
 ]);
+function generateMessageId() {
+  if (typeof crypto.randomUUID === "function") return `m-${crypto.randomUUID().replace(/-/g, "")}`;
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  return `m-${Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
 var SIGNED_METHODS = /* @__PURE__ */ new Set([
   "message.send",
   "message.v2.put_peer_pk",
@@ -14829,6 +15473,7 @@ var SIGNED_METHODS = /* @__PURE__ */ new Set([
   "group.resume"
 ]);
 var SIGNING_KEY_CACHE_MAX = 32;
+var IDENTITY_ADMISSION_RETRY_DELAYS_MS = [0, 50, 100, 200];
 var signingKeyCache = /* @__PURE__ */ new Map();
 var certFingerprintCache = /* @__PURE__ */ new Map();
 function cacheGet(cache, key) {
@@ -14883,6 +15528,13 @@ async function signingCertFingerprint(certPem) {
 }
 var PULL_GATE_STALE_MS = 3e4;
 var PULL_GATE_OPERATION_TIMEOUT_MS = 3e3;
+function sameIdentityAdmissionRejection(error, original) {
+  const errorCode2 = Number(error?.code);
+  const originalCode = Number(original?.code);
+  const errorMessage3 = String(error instanceof Error ? error.message : error?.message ?? "").trim().toLowerCase();
+  const originalMessage = String(original instanceof Error ? original.message : original?.message ?? "").trim().toLowerCase();
+  return errorCode2 === -32003 && originalCode === -32003 && errorMessage3 === originalMessage;
+}
 var NON_IDEMPOTENT_TIMEOUT = 35;
 var NON_IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
   "message.send",
@@ -14979,6 +15631,9 @@ var RpcPipeline = class {
     __publicField(this, "runtime");
     __publicField(this, "pullGateStates", /* @__PURE__ */ new Map());
     __publicField(this, "inlineRealtimeScopes", /* @__PURE__ */ new Set());
+    __publicField(this, "pullWorkTokens", /* @__PURE__ */ new Set());
+    __publicField(this, "pullGeneration", 0);
+    __publicField(this, "pullInvalidationWait", null);
     this.runtime = runtime;
   }
   async call(method, params2) {
@@ -15184,6 +15839,9 @@ var RpcPipeline = class {
     delete p._rpc_background;
     if (method === "message.send" || method === "group.send") {
       this.normalizeOutboundMessagePayload(p, method);
+      if (!Object.prototype.hasOwnProperty.call(p, "message_id") || p.message_id == null) {
+        p.message_id = generateMessageId();
+      }
     }
     this.normalizeGroupCallIdentifier(method, p);
     this.validateOutboundCall(method, p);
@@ -15348,19 +16006,21 @@ var RpcPipeline = class {
     if (method === "message.pull" || method === "message.v2.pull" || method === "message.history") {
       if (!client._aid) return "";
       const mode = method === "message.history" ? "history" : params2.window_mode === "tail" ? "tail" : "forward";
-      const cursor = mode === "history" ? `before=${String(params2.before_seq)}` : `after=${String(params2.after_seq ?? 0)}|force=${String(Boolean(params2.force))}`;
-      return `p2p:${client._aid}|${mode}|${cursor}|limit=${String(params2.limit)}`;
+      const cursor = mode === "history" ? `before=${String(params2.before_seq)}` : `after=${String(params2.after_seq ?? 0)}`;
+      return `p2p:${client._aid}|mode=${mode}|cursor=${cursor}|force=${String(Boolean(params2.force))}|limit=${String(params2.limit)}`;
     }
     if (method === "group.pull" || method === "group.v2.pull" || method === "group.history") {
       const gid = String(params2.group_id ?? params2.group_aid ?? "").trim();
       if (!gid) return "";
       const mode = method === "group.history" ? "history" : params2.window_mode === "tail" ? "tail" : "forward";
-      const cursor = mode === "history" ? `before=${String(params2.before_seq)}` : `after=${String(params2.after_seq ?? params2.after_message_seq ?? 0)}|force=${String(Boolean(params2.force))}`;
-      return `group:${gid}|${mode}|${cursor}|limit=${String(params2.limit)}`;
+      const cursor = mode === "history" ? `before=${String(params2.before_seq)}` : `after=${String(params2.after_seq ?? params2.after_message_seq ?? 0)}`;
+      const explicitCursor = this.explicitGroupCursorParams(params2);
+      const cursorSuffix = Object.keys(explicitCursor).length > 0 ? `|cursor_params=${stableStringify(explicitCursor)}` : "";
+      return `group:${gid}|mode=${mode}|cursor=${cursor}${cursorSuffix}|force=${String(Boolean(params2.force))}|limit=${String(params2.limit)}`;
     }
     if (method === "group.pull_events") {
       const gid = String(params2.group_id ?? params2.group_aid ?? "").trim();
-      return gid ? `group_event:${gid}|forward|after=${String(params2.after_event_seq ?? 0)}|limit=${String(params2.limit)}` : "";
+      return gid ? `group_event:${gid}|mode=forward|cursor=after=${String(params2.after_event_seq ?? 0)}|force=${String(Boolean(params2.force))}|limit=${String(params2.limit)}` : "";
     }
     return "";
   }
@@ -15380,8 +16040,8 @@ var RpcPipeline = class {
     if (!state) {
       state = { active: null, foreground: [], background: [], byKey: /* @__PURE__ */ new Map(), lifecycle: /* @__PURE__ */ new Map(), watchdog: null };
       this.pullGateStates.set(name, state);
-      this.startPullGateWatchdog(state, name);
     }
+    this.startPullGateWatchdog(state, name);
     return state;
   }
   pullGateOperationTimeoutMs() {
@@ -15398,6 +16058,13 @@ var RpcPipeline = class {
     state.watchdog = timer;
     timer.unref?.();
   }
+  stopPullGateWatchdogs() {
+    for (const state of this.pullGateStates.values()) {
+      if (state.watchdog === null) continue;
+      clearInterval(state.watchdog);
+      state.watchdog = null;
+    }
+  }
   checkPullGate(state, name) {
     const active = state.active;
     if (!active) {
@@ -15407,17 +16074,12 @@ var RpcPipeline = class {
     if (!active.pullingStartedAt || Date.now() - active.pullingStartedAt < this.pullGateOperationTimeoutMs()) return;
     if (active.timedOut) return;
     active.timedOut = true;
+    active.invalidated = true;
+    this.pullGeneration += 1;
     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|"]) {
@@ -15436,7 +16098,7 @@ var RpcPipeline = class {
     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;
+    if (!active || active.key !== key || active.timedOut || active.invalidated) return request;
     const boundCancel = () => cancel.call(request);
     active.cancel = boundCancel;
     return request.finally(() => {
@@ -15484,6 +16146,28 @@ var RpcPipeline = class {
     const matches = (job) => job !== null && job.namespace === ns;
     return matches(state.active) || 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) return true;
+    }
+    return false;
+  }
+  reservePullWork() {
+    const token = Symbol("pull-work");
+    this.pullWorkTokens.add(token);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.pullWorkTokens.delete(token);
+      this.runtime.client._delivery?.onPullWorkSettled?.();
+    };
+  }
+  releasePullWorkToken(token) {
+    if (!this.pullWorkTokens.delete(token)) return;
+    this.runtime.client._delivery?.onPullWorkSettled?.();
+  }
   async tryRunInlineRealtime(ns, seq2, operation) {
     const normalized = String(ns ?? "").trim();
     if (!normalized.startsWith("p2p:") && !normalized.startsWith("group:") || !Number.isSafeInteger(seq2) || seq2 <= 0 || typeof operation !== "function") {
@@ -15522,7 +16206,11 @@ var RpcPipeline = class {
       resumeResolve: null,
       pullingStartedAt: 0,
       timedOut: false,
-      cancel: null
+      invalidated: false,
+      cancel: null,
+      settled: Promise.resolve(),
+      settledResolve: null,
+      workToken: Symbol("inline-pull-work")
     };
     this.inlineRealtimeScopes.add(normalized);
     try {
@@ -15562,14 +16250,68 @@ var RpcPipeline = class {
     gate.inflight = false;
     gate.startedAt = 0;
   }
+  isPullGenerationCurrent(generation) {
+    return generation === this.pullGeneration;
+  }
+  invalidatePulls() {
+    if (this.pullInvalidationWait) return this.pullInvalidationWait;
+    this.pullGeneration += 1;
+    const error = new Error("pull invalidated");
+    const waits = [];
+    for (const state of this.pullGateStates.values()) {
+      const jobs = /* @__PURE__ */ new Set();
+      if (state.active) jobs.add(state.active);
+      for (const job of state.foreground) jobs.add(job);
+      for (const job of state.background) jobs.add(job);
+      for (const job of jobs) {
+        job.invalidated = true;
+        if (!job.timedOut) job.reject(error);
+        job.cancel?.();
+        job.resumeResolve?.();
+        job.resumeResolve = null;
+        if (job.running) {
+          waits.push(job.settled);
+        } else {
+          this.releasePullWorkToken(job.workToken);
+          job.settledResolve?.();
+          job.settledResolve = null;
+        }
+      }
+      state.foreground = state.foreground.filter((job) => !jobs.has(job));
+      state.background = state.background.filter((job) => !jobs.has(job));
+      for (const [key, job] of state.byKey.entries()) {
+        if (jobs.has(job) && !job.running) state.byKey.delete(key);
+      }
+      this.drainPullGate(state);
+    }
+    const wait = Promise.all(waits).then(() => void 0);
+    this.runtime.client._delivery?.onPullWorkSettled?.();
+    let tracked;
+    tracked = wait.finally(() => {
+      if (this.pullInvalidationWait === tracked) this.pullInvalidationWait = null;
+    });
+    this.pullInvalidationWait = tracked;
+    return tracked;
+  }
+  pullInvalidationInProgress() {
+    return this.pullInvalidationWait !== null;
+  }
   async runPullSerialized(key, operation, background = false) {
-    if (!key) return await this.executePullOperation(operation, background);
+    if (this.pullInvalidationInProgress()) {
+      throw new Error("pull invalidated");
+    }
+    if (!key) {
+      const releasePullWork = this.reservePullWork();
+      try {
+        return await this.executePullOperation(operation, background);
+      } finally {
+        releasePullWork();
+      }
+    }
     const state = this.pullGateState(key);
     const namespace = this.pullScopeKey(key);
-    const active = state.active?.namespace === namespace ? state.active : null;
-    const queuedForeground = state.foreground.find((job2) => job2.namespace === namespace);
-    const queuedBackground = state.background.find((job2) => job2.namespace === namespace);
-    const existing = background ? active ?? queuedForeground ?? queuedBackground : queuedForeground ?? (active && !active.background ? active : null) ?? queuedBackground;
+    const candidate = state.byKey.get(key);
+    const existing = candidate && !candidate.timedOut && !candidate.invalidated ? candidate : null;
     if (existing) {
       if (!background && existing.background && existing !== state.active) {
         const index = state.background.indexOf(existing);
@@ -15579,12 +16321,18 @@ var RpcPipeline = class {
       }
       return await existing.promise;
     }
+    const workToken = Symbol("pull-work");
+    this.pullWorkTokens.add(workToken);
     let resolve;
     let reject;
+    let settledResolve;
     const promise = new Promise((res, rej) => {
       resolve = res;
       reject = rej;
     });
+    const settled = new Promise((resolveSettled) => {
+      settledResolve = resolveSettled;
+    });
     void promise.catch(() => {
     });
     const job = {
@@ -15602,7 +16350,11 @@ var RpcPipeline = class {
       resumeResolve: null,
       pullingStartedAt: 0,
       timedOut: false,
-      cancel: null
+      invalidated: false,
+      cancel: null,
+      settled,
+      settledResolve,
+      workToken
     };
     (background ? state.background : state.foreground).push(job);
     state.byKey.set(key, job);
@@ -15611,14 +16363,30 @@ var RpcPipeline = class {
     return await promise;
   }
   async executePullOperation(operation, background) {
-    if (background) return await this.runtime.client._withBackgroundRpc(operation);
-    return await operation();
+    const client = this.runtime.client;
+    const hadPrevious = Object.prototype.hasOwnProperty.call(client, "_pullOperationGeneration");
+    const previous = client._pullOperationGeneration;
+    client._pullOperationGeneration = this.pullGeneration;
+    try {
+      if (background) return await client._withBackgroundRpc(operation);
+      return await operation();
+    } finally {
+      if (hadPrevious) client._pullOperationGeneration = previous;
+      else delete client._pullOperationGeneration;
+    }
+  }
+  pullOperationIsCurrent() {
+    const generation = this.runtime.client._pullOperationGeneration;
+    return generation === void 0 || this.isPullGenerationCurrent(generation);
+  }
+  throwIfPullInvalidated() {
+    if (!this.pullOperationIsCurrent()) throw new Error("pull invalidated");
   }
   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);
+    const job = state.active?.key === key ? state.active : null;
     if (!job || state.active !== job) return;
     const replacementKey = String(nextKey || key);
     if (state.byKey.get(job.key) === job) state.byKey.delete(job.key);
@@ -15634,7 +16402,10 @@ var RpcPipeline = class {
     state.active = null;
     (job.background ? state.background : state.foreground).push(job);
     this.drainPullGate(state);
-    if (job.resume) await job.resume;
+    if (job.resume) {
+      await job.resume;
+      if (job.invalidated) throw new Error("pull invalidated");
+    }
   }
   getPullLifecycle(namespace) {
     const ns = this.pullScopeKey(namespace);
@@ -15670,13 +16441,23 @@ var RpcPipeline = class {
       return;
     }
     job.running = true;
-    void this.executePullOperation(job.operation, job.background).then(job.resolve, job.reject).finally(() => {
-      if (job.timedOut) return;
+    void this.executePullOperation(job.operation, job.background).then(
+      (value) => {
+        if (!job.timedOut && !job.invalidated) job.resolve(value);
+      },
+      (error) => {
+        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);
-      this.runtime.client._delivery?.onPullGateIdle?.(job.namespace);
+      job.settledResolve?.();
+      job.settledResolve = null;
+      if (!job.invalidated) this.runtime.client._delivery?.onPullGateIdle?.(job.namespace);
+      this.runtime.client._delivery?.onPullWorkSettled?.();
     });
   }
   armQueuedPullTimers(_state) {
@@ -15699,7 +16480,9 @@ var RpcPipeline = class {
       else request = client._transport.call(method, payload);
       return this.bindActivePullCancellation(method, payload, request);
     };
-    return await this.transportCallWithIdentityRecovery(invokeTransport, method, payload);
+    const result = await this.transportCallWithIdentityRecovery(invokeTransport, method, payload);
+    this.throwIfPullInvalidated();
+    return result;
   }
   async transportCallWithIdentityRecovery(operation, method, params2) {
     try {
@@ -15707,11 +16490,22 @@ var RpcPipeline = class {
     } catch (err) {
       const recover = this.runtime.client._recoverIdentityAdmission;
       if (typeof recover !== "function" || !await recover.call(this.runtime.client, err, method, params2)) throw err;
-      return await operation();
+      let lastError = err;
+      for (const delay of IDENTITY_ADMISSION_RETRY_DELAYS_MS) {
+        if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+        try {
+          return await operation();
+        } catch (retryError) {
+          if (!sameIdentityAdmissionRejection(retryError, err)) throw retryError;
+          lastError = retryError;
+        }
+      }
+      throw lastError;
     }
   }
   async postprocessResult(method, params2, result, options = {}) {
     const client = this.runtime.client;
+    this.throwIfPullInvalidated();
     let next = result;
     if ((method === "group.send" || method === "group.v2.send") && isJsonObject(next)) {
       next = normalizeGroupMentionMode(next);
@@ -17412,17 +18206,21 @@ var GroupFacade = class extends RpcFacade {
   }
   create(params2) {
     const split = splitAidStore(params2);
-    if (typeof this.client.createGroup === "function") {
+    if (split.params.group_name === void 0 && split.params.groupName !== void 0) {
+      split.params.group_name = split.params.groupName;
+      delete split.params.groupName;
+    }
+    if (split.aidStore && typeof this.client.createGroup === "function") {
       return this.client.createGroup(split.params, { aidStore: split.aidStore });
     }
     return this.call("group.create", split.params);
   }
   bindAid(params2) {
-    return this.bindGroupAid(params2);
+    return this.call("group.bind_aid", splitAidStore(params2).params);
   }
   bindGroupAid(params2) {
     const split = splitAidStore(params2);
-    if (typeof this.client.bindGroupAid === "function") {
+    if (split.aidStore && typeof this.client.bindGroupAid === "function") {
       return this.client.bindGroupAid(split.params, { aidStore: split.aidStore });
     }
     return this.call("group.bind_group_aid", split.params);
@@ -22795,6 +23593,10 @@ var V2Session = class {
 };
 
 // src/client/v2-e2ee.ts
+function pullGateKeyForClient(client, method, params2, fallback) {
+  const key = client._rpcPipeline?.pullGateKeyForCall?.(method, params2);
+  return typeof key === "string" && key ? key : fallback;
+}
 var V2_BOOTSTRAP_TTL_MS = 60 * 60 * 1e3;
 var V2_RETRYABLE_CODES = /* @__PURE__ */ new Set([-33011, -33012, -33050, -33052, -33054]);
 var V2_GROUP_STALE_BOOTSTRAP_CODE = -33054;
@@ -23552,11 +24354,22 @@ var V2E2EECoordinator = class {
     const fetchKey = this.pendingSenderIKFetchKey(fromAid, senderDeviceId, groupId);
     if (!fromAid || client._v2SenderIKFetching.has(fetchKey)) return;
     client._v2SenderIKFetching.add(fetchKey);
-    client._safeAsync(this.resolveSenderIKPending(fromAid, senderDeviceId, groupId, fetchKey));
+    const releasePullWork = client._rpcPipeline?.reservePullWork?.() ?? (() => {
+    });
+    const generation = client._delivery.captureInlineGeneration?.();
+    client._safeAsync(this.resolveSenderIKPending(
+      fromAid,
+      senderDeviceId,
+      groupId,
+      fetchKey,
+      generation
+    ).finally(releasePullWork));
   }
-  async resolveSenderIKPending(fromAid, senderDeviceId, groupId, fetchKey) {
+  async resolveSenderIKPending(fromAid, senderDeviceId, groupId, fetchKey, generation) {
     const client = this.client;
+    const generationCurrent = () => generation === void 0 || client._delivery.isInlineGenerationCurrent?.(generation) !== false;
     try {
+      if (!generationCurrent()) return;
       const session = client._v2Session;
       if (session && fromAid) {
         try {
@@ -23587,17 +24400,21 @@ var V2E2EECoordinator = class {
           await this.getV2SenderPubDer(fromAid, senderDeviceId);
         }
       }
+      if (!generationCurrent()) return;
       const pendingItems = [...client._v2SenderIKPending.entries()].filter(([, entry]) => entry.fromAid === fromAid && entry.senderDeviceId === senderDeviceId && entry.groupId === groupId);
       for (const [key, entry] of pendingItems) {
+        if (!generationCurrent()) return;
         let plaintext = null;
         const retryStatus = {};
         try {
           plaintext = await client._decryptV2Message(entry.msg, false, true, true, true, retryStatus);
         } catch (exc) {
+          if (!generationCurrent()) return;
           client._clientLog.warn(`V2 sender IK pending retry raised: key=${key} err=${String(formatE2EEError(exc))}`);
           client._v2SenderIKPending.delete(key);
           continue;
         }
+        if (!generationCurrent()) return;
         if (plaintext === null) {
           if (retryStatus.deferred) {
             client._clientLog.warn(`V2 pending retry still missing key material: key=${key}`);
@@ -23649,6 +24466,7 @@ var V2E2EECoordinator = class {
       return client.call("message.send", {
         to: toAid,
         payload: envelope,
+        message_id: opts?.messageId,
         encrypt: false,
         _skip_send_result_envelope: true
       });
@@ -23725,7 +24543,8 @@ var V2E2EECoordinator = class {
           event.event,
           client._aid ? `p2p:${client._aid}` : "",
           seq2,
-          event.payload
+          event.payload,
+          source
         );
       } else {
         await client._publishAppEvent(event.event, event.payload, source);
@@ -23784,7 +24603,8 @@ var V2E2EECoordinator = class {
           "group.message_created",
           `group:${groupId}`,
           seq2,
-          plaintext
+          plaintext,
+          source
         );
       } else {
         await client._publishAppEvent("group.message_created", plaintext, source);
@@ -23854,7 +24674,11 @@ var V2E2EECoordinator = class {
     const ns = client._aid ? `p2p:${client._aid}` : "";
     if (opts?.windowMode === "tail") {
       if (!opts.gateLocked) {
-        const key = `${ns}|tail|after=${afterSeq}|limit=${limit}`;
+        const key = pullGateKeyForClient(client, "message.v2.pull", {
+          window_mode: "tail",
+          after_seq: afterSeq,
+          limit
+        }, `${ns}|tail|after=${afterSeq}|limit=${limit}`);
         return await client._runPullSerialized(key, () => this.pullV2(afterSeq, limit, {
           ...opts ?? {},
           gateLocked: true
@@ -23864,7 +24688,11 @@ var V2E2EECoordinator = class {
       return Array.isArray(result.messages) ? result.messages : [];
     }
     if (ns && !opts?.gateLocked) {
-      const key = `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`;
+      const key = pullGateKeyForClient(client, "message.v2.pull", {
+        after_seq: afterSeq,
+        force: opts?.force === true,
+        limit
+      }, `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`);
       return await client._runPullSerialized(key, () => this.pullV2(afterSeq, limit, {
         ...opts ?? {},
         gateLocked: true
@@ -23872,7 +24700,11 @@ var V2E2EECoordinator = class {
     }
     const decrypted = [];
     let nextAfterSeq = opts?.force ? afterSeq : afterSeq || (ns ? client._seqTracker.getContiguousSeq(ns) : 0);
-    let pullGateKey = ns ? `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}` : "";
+    let pullGateKey = ns ? pullGateKeyForClient(client, "message.v2.pull", {
+      after_seq: afterSeq,
+      force: opts?.force === true,
+      limit
+    }, `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`) : "";
     const deferredServerCursor = ns ? this.pendingForwardCursor(ns, client._seqTracker.getContiguousSeq(ns)) : 0;
     const deferredForwardAck = ns ? this.pendingForwardAck(ns, client._seqTracker.getContiguousSeq(ns)) : 0;
     let pageCount = 0;
@@ -23917,6 +24749,7 @@ var V2E2EECoordinator = class {
       const pageTrackerSnapshot = ns && typeof client._seqTracker.snapshotNamespace === "function" ? client._seqTracker.snapshotNamespace(ns) : null;
       const pageMaxSeq = seqs.length > 0 ? Math.max(...seqs) : nextAfterSeq;
       const deferredKeyFetches = /* @__PURE__ */ new Map();
+      let blockedSeq = 0;
       for (const msg of messages) {
         const seq2 = Number(msg.seq ?? 0);
         if (!Number.isFinite(seq2) || seq2 <= 0) continue;
@@ -23939,7 +24772,7 @@ var V2E2EECoordinator = class {
             attachGatewayProximity(v1Msg, msg);
             const appEvent = client._delivery.p2pAppEventForMessage(v1Msg);
             if (ns) await client._publishPulledMessage(appEvent.event, ns, seq2, appEvent.payload, false);
-            else await client._publishAppEvent(appEvent.event, appEvent.payload);
+            else await client._publishAppEvent(appEvent.event, appEvent.payload, "pull");
             decrypted.push(v1Msg);
           } else {
             client._clientLog.debug(`message.v2.pull skipping V1 envelope seq=${seq2} payload_type=${payloadType || "<none>"} (V1 E2EE removed)`);
@@ -23956,6 +24789,9 @@ var V2E2EECoordinator = class {
         }
         const deferStatus = {};
         const plaintext = await client._decryptV2Message(msg, true, true, true, true, deferStatus, true);
+        if (deferStatus.deferred) {
+          blockedSeq = blockedSeq > 0 ? Math.min(blockedSeq, seq2) : seq2;
+        }
         if (deferStatus.deferred && deferStatus.fromAid) {
           const key = `${deferStatus.fromAid}\0${deferStatus.senderDeviceId ?? ""}\0${deferStatus.groupId ?? ""}`;
           deferredKeyFetches.set(key, {
@@ -23969,7 +24805,7 @@ var V2E2EECoordinator = class {
           await client._publishPulledMessage("message.received", ns, seq2, plaintext, false);
           decrypted.push(plaintext);
         } else {
-          await client._publishAppEvent("message.received", plaintext);
+          await client._publishAppEvent("message.received", plaintext, "pull");
           decrypted.push(plaintext);
         }
       }
@@ -23978,7 +24814,7 @@ var V2E2EECoordinator = class {
       const serverAckSeq = parsedServerAckSeq ?? 0;
       const retentionFloor = Math.max(0, Number(result.retention_floor_seq ?? 0));
       if (ns) {
-        const commitTarget = Math.max(
+        const commitTarget = blockedSeq > 0 ? pageContigBefore : Math.max(
           pageContigBefore,
           Number.isFinite(retentionFloor) ? retentionFloor : 0,
           pageCount === 1 ? deferredServerCursor : 0,
@@ -24020,7 +24856,7 @@ var V2E2EECoordinator = class {
           this.recordForwardCursor(ns, serverAckSeq, ackSeq);
         }
         const knownServerAckSeq = hasServerAckSeq ? serverAckSeq : pageCount === 1 ? deferredServerCursor : 0;
-        const ackNeeded = ackSeq > 0 && ackSeq > lastAutoAckSeq && (hasServerAckSeq && ackSeq > serverAckSeq || contigAdvanced && ackSeq > knownServerAckSeq);
+        const ackNeeded = blockedSeq <= 0 && ackSeq > 0 && ackSeq > lastAutoAckSeq && (hasServerAckSeq && ackSeq > serverAckSeq || contigAdvanced && ackSeq > knownServerAckSeq);
         if (ackNeeded) {
           this.recordForwardAck(ns, ackSeq);
           const nextAfter2 = Math.max(pageMaxSeq, nextAfterSeq);
@@ -24036,6 +24872,7 @@ var V2E2EECoordinator = class {
       }
       const nextAfter = Math.max(pageMaxSeq, nextAfterSeq);
       const rawCount = messages.length;
+      if (blockedSeq > 0) break;
       const shouldContinue = shouldContinueForwardPage({
         rawCount,
         nextAfterSeq,
@@ -24048,7 +24885,11 @@ var V2E2EECoordinator = class {
       });
       if (!shouldContinue) break;
       if (pullGateKey && opts?.gateLocked && client._rpcPipeline?.yieldPullGate) {
-        const nextKey = `${ns}|forward|after=${nextAfter}|force=${String(Boolean(opts?.force))}|limit=${limit}`;
+        const nextKey = pullGateKeyForClient(client, "message.v2.pull", {
+          after_seq: nextAfter,
+          force: opts?.force === true,
+          limit
+        }, `${ns}|forward|after=${nextAfter}|force=${String(Boolean(opts?.force))}|limit=${limit}`);
         await client._rpcPipeline.yieldPullGate(pullGateKey, nextKey, true);
         pullGateKey = nextKey;
       }
@@ -24140,7 +24981,8 @@ var V2E2EECoordinator = class {
       });
       return client.call("group.v2.send", withExplicitGroupAid({
         group_id: gid,
-        envelope
+        envelope,
+        message_id: opts?.messageId
       }, groupAid));
     };
     try {
@@ -24268,7 +25110,13 @@ var V2E2EECoordinator = class {
     const ns = `group:${gid}`;
     if (opts?.windowMode === "tail") {
       if (!opts.gateLocked) {
-        const key = `${ns}|tail|after=${afterSeq}|limit=${limit}`;
+        const key = pullGateKeyForClient(client, "group.v2.pull", {
+          group_id: gid,
+          window_mode: "tail",
+          after_seq: afterSeq,
+          limit,
+          _group_cursor_params: opts?.cursorParams
+        }, `${ns}|tail|after=${afterSeq}|limit=${limit}`);
         return await client._runPullSerialized(key, () => this.pullGroupV2(gid, afterSeq, limit, {
           ...opts ?? {},
           gateLocked: true
@@ -24284,7 +25132,13 @@ var V2E2EECoordinator = class {
       return Array.isArray(result.messages) ? result.messages : [];
     }
     if (!opts?.gateLocked) {
-      const key = `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`;
+      const key = pullGateKeyForClient(client, "group.v2.pull", {
+        group_id: gid,
+        after_seq: afterSeq,
+        force: opts?.force === true,
+        limit,
+        _group_cursor_params: opts?.cursorParams
+      }, `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`);
       return await client._runPullSerialized(key, () => this.pullGroupV2(gid, afterSeq, limit, {
         ...opts ?? {},
         gateLocked: true
@@ -24294,7 +25148,13 @@ var V2E2EECoordinator = class {
     const wireGroupId = String(opts?.wireGroupId ?? groupId ?? "").trim() || gid;
     const cursorParams = opts?.cursorParams ?? {};
     const ownsCursor = opts?.ownsCursor !== false;
-    let pullGateKey = ownsCursor ? `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}` : "";
+    let pullGateKey = ownsCursor ? pullGateKeyForClient(client, "group.v2.pull", {
+      group_id: gid,
+      after_seq: afterSeq,
+      force: opts?.force === true,
+      limit,
+      _group_cursor_params: cursorParams
+    }, `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`) : "";
     let nextAfterSeq = opts?.explicitAfterSeq || opts?.force ? afterSeq : afterSeq || client._seqTracker.getContiguousSeq(ns);
     const deferredServerCursor = ownsCursor ? this.pendingForwardCursor(ns, client._seqTracker.getContiguousSeq(ns)) : 0;
     const deferredForwardAck = ownsCursor ? this.pendingForwardAck(ns, client._seqTracker.getContiguousSeq(ns)) : 0;
@@ -24347,6 +25207,7 @@ var V2E2EECoordinator = class {
       const pageTrackerSnapshot = typeof client._seqTracker.snapshotNamespace === "function" ? client._seqTracker.snapshotNamespace(ns) : null;
       const pageMaxSeq = seqs.length > 0 ? Math.max(...seqs) : nextAfterSeq;
       const deferredKeyFetches = /* @__PURE__ */ new Map();
+      let blockedSeq = 0;
       for (const msg of messages) {
         const seq2 = Number(msg.seq ?? 0);
         if (!Number.isFinite(seq2) || seq2 <= 0) continue;
@@ -24411,6 +25272,9 @@ var V2E2EECoordinator = class {
         }
         const deferStatus = {};
         let plaintext = await client._decryptV2Message(msg, true, true, true, true, deferStatus, true);
+        if (deferStatus.deferred) {
+          blockedSeq = blockedSeq > 0 ? Math.min(blockedSeq, seq2) : seq2;
+        }
         if (deferStatus.deferred && deferStatus.fromAid) {
           const key = `${deferStatus.fromAid}\0${deferStatus.senderDeviceId ?? ""}\0${deferStatus.groupId ?? ""}`;
           deferredKeyFetches.set(key, {
@@ -24439,7 +25303,7 @@ var V2E2EECoordinator = class {
         Number(cursor?.join_seq ?? 0)
       );
       const effectiveFloor = Math.max(retentionFloor, visibilityFloor);
-      const commitTarget = Math.max(
+      const commitTarget = blockedSeq > 0 ? pageContigBefore : Math.max(
         pageContigBefore,
         Number.isFinite(effectiveFloor) ? effectiveFloor : 0,
         ownsCursor && pageCount === 1 ? deferredServerCursor : 0,
@@ -24483,7 +25347,7 @@ var V2E2EECoordinator = class {
         this.recordForwardCursor(ns, cursorCurrentSeq, ackSeq);
       }
       const knownServerCursorSeq = hasServerCursor ? cursorCurrentSeq : ownsCursor && pageCount === 1 ? deferredServerCursor : 0;
-      const ackNeeded = ackSeq > 0 && ackSeq > lastAutoAckSeq && ownsCursor && (hasServerCursor && ackSeq > cursorCurrentSeq || contigAdvanced && ackSeq > knownServerCursorSeq);
+      const ackNeeded = blockedSeq <= 0 && ackSeq > 0 && ackSeq > lastAutoAckSeq && ownsCursor && (hasServerCursor && ackSeq > cursorCurrentSeq || contigAdvanced && ackSeq > knownServerCursorSeq);
       if (ackNeeded) {
         this.recordForwardAck(ns, ackSeq);
         const nextAfter2 = Math.max(pageMaxSeq, nextAfterSeq);
@@ -24499,6 +25363,7 @@ var V2E2EECoordinator = class {
       const nextAfter = Math.max(pageMaxSeq, nextAfterSeq);
       if (!ownsCursor) break;
       const rawCount = messages.length;
+      if (blockedSeq > 0) break;
       const shouldContinue = shouldContinueForwardPage({
         rawCount,
         nextAfterSeq,
@@ -24511,7 +25376,13 @@ var V2E2EECoordinator = class {
       });
       if (!shouldContinue) break;
       if (pullGateKey && opts?.gateLocked && client._rpcPipeline?.yieldPullGate) {
-        const nextKey = `${ns}|forward|after=${nextAfter}|force=${String(Boolean(opts?.force))}|limit=${limit}`;
+        const nextKey = pullGateKeyForClient(client, "group.v2.pull", {
+          group_id: gid,
+          after_seq: nextAfter,
+          force: opts?.force === true,
+          limit,
+          _group_cursor_params: cursorParams
+        }, `${ns}|forward|after=${nextAfter}|force=${String(Boolean(opts?.force))}|limit=${limit}`);
         await client._rpcPipeline.yieldPullGate(pullGateKey, nextKey, true);
         pullGateKey = nextKey;
       }
@@ -25547,7 +26418,7 @@ var GroupStateCoordinator = class {
     if (!isJsonObject(data) || !client._v2Session) return;
     const groupId = groupIdFromRecord(data);
     if (!groupId) return;
-    await client._dispatcher.publish("group.v2.state_proposed", data);
+    client._dispatcher.enqueue("group.v2.state_proposed", data);
     try {
       await client._v2ConfirmPendingProposal(groupId);
     } catch (exc) {
@@ -25559,7 +26430,7 @@ var GroupStateCoordinator = class {
     if (!isJsonObject(data) || !client._v2Session) return;
     const groupId = groupIdFromRecord(data);
     if (!groupId) return;
-    await client._dispatcher.publish("group.v2.state_retry_needed", data);
+    client._dispatcher.enqueue("group.v2.state_retry_needed", data);
     try {
       await client._v2AutoProposeState(groupId, { leaderDelay: true });
     } catch (exc) {
@@ -25577,7 +26448,7 @@ var GroupStateCoordinator = class {
       }
       client._v2AutoProposeLastSnapshot?.delete?.(groupId);
     }
-    await client._dispatcher.publish("group.v2.state_confirmed", data);
+    client._dispatcher.enqueue("group.v2.state_confirmed", data);
   }
   async publishV2GroupSecurityLevel(groupId, bootstrap) {
     const client = this.client;
@@ -25588,7 +26459,7 @@ var GroupStateCoordinator = class {
     const previous = securityLevels.get(gid);
     if (previous === level) return;
     securityLevels.set(gid, level);
-    await client._dispatcher.publish("group.v2.security_level", {
+    client._dispatcher.enqueue("group.v2.security_level", {
       group_id: gid,
       level,
       warning: String(bootstrap.e2ee_security_warning ?? ""),
@@ -25683,7 +26554,7 @@ var GroupStateCoordinator = class {
       } catch {
       }
       client._clientLog.warn(`V2 state chain fork detected: group=${gid} local_chain=${localChain.slice(0, 16)}... server_chain=${serverChain.slice(0, 16)}...`);
-      await client._dispatcher.publish("group.v2.fork_detected", {
+      client._dispatcher.enqueue("group.v2.fork_detected", {
         group_id: gid,
         local_chain: localChain,
         server_chain: serverChain
@@ -26084,7 +26955,7 @@ var GroupStateCoordinator = class {
       const proposalId = isJsonObject(proposeResult) ? String(proposeResult.proposal_id ?? "").trim() : "";
       if (proposalId) {
         try {
-          await client.call("group.v2.confirm_state", { proposal_id: proposalId });
+          await client.call("group.v2.confirm_state", { proposal_id: proposalId, group_id: groupId });
           client._v2AutoProposeLastSnapshot.set(groupId, membershipSnapshot);
           client._clientLog.debug(`V2 auto confirm_state: group=${groupId} proposal=${proposalId}`);
         } catch (confirmExc) {
@@ -26137,7 +27008,7 @@ var GroupStateCoordinator = class {
       return false;
     }
     if (!await this.verifyPendingProposalAgainstBase(groupId, proposal, stateResp)) return false;
-    await client.call("group.v2.confirm_state", { proposal_id: proposalId });
+    await client.call("group.v2.confirm_state", { proposal_id: proposalId, group_id: groupId });
     client._clientLog.info(`V2 confirmed pending proposal: group=${groupId} proposal=${proposalId}`);
     return true;
   }
@@ -26217,7 +27088,7 @@ var GroupStateCoordinator = class {
       }
       if (mode !== "open" && mode !== "invite_code" && mode !== "invite_only") {
         client._clientLog.warn(`V2 state tamper detected: group=${groupId} pending_extra=${extra.sort().join(",")} mode=${mode}`);
-        await client._dispatcher.publish("group.v2.state_tampered", {
+        client._dispatcher.enqueue("group.v2.state_tampered", {
           group_id: groupId,
           pending_extra: extra.sort(),
           mode
@@ -27167,6 +28038,7 @@ function buildDefaultAgentMd(aid, options = {}) {
   ].join("\n");
 }
 var HEAD_HTTP_TIMEOUT_MS = 15e3;
+var AGENT_MD_NEGATIVE_CACHE_TTL_MS = 6e4;
 var noopLogger = {
   error: () => {
   },
@@ -27400,6 +28272,7 @@ var AgentMdManager = class _AgentMdManager {
     if (content !== void 0 && content !== null) {
       const text3 = String(content ?? "");
       if (text3.length === 0) throw new ValidationError("uploadAgentMd requires non-empty content");
+      validateAgentMdDocument(text3, { expectedAid: target });
       await this.saveRecord(target, {
         content: text3,
         local_etag: await _AgentMdManager.contentEtag(text3),
@@ -27506,6 +28379,24 @@ var AgentMdManager = class _AgentMdManager {
         ttl_days: Number(ttlDays) || 0
       };
     }
+    const remoteMissingCached = String(before.remote_status ?? "").trim().toLowerCase() === "missing";
+    if (!localFound && !remoteEtagCached && remoteMissingCached && _AgentMdManager.checkedAtFresh(checkedAtCached, ttlDays)) {
+      return {
+        aid: target,
+        local_found: false,
+        remote_found: false,
+        local_etag: "",
+        remote_etag: "",
+        in_sync: false,
+        needs_update: false,
+        last_modified: "",
+        status: 404,
+        cached: true,
+        verify_status: "",
+        verify_error: "",
+        ttl_days: Number(ttlDays) || 0
+      };
+    }
     const now = Date.now();
     let remote;
     try {
@@ -27995,14 +28886,16 @@ var AgentMdManager = class _AgentMdManager {
   async _scheduleFetchIfMissing(aid, record, source = "") {
     const target = String(aid ?? "").trim();
     if (!target || await this._hasLocalContent(target, record)) return;
+    const cached = record ?? await this.loadRecord(target) ?? {};
+    const checkedAt = Number(cached.checked_at ?? 0) || 0;
+    if (String(cached.remote_status ?? "").trim().toLowerCase() === "missing" && checkedAt > 0 && Date.now() - checkedAt <= AGENT_MD_NEGATIVE_CACHE_TTL_MS) return;
     if (this._fetchInflight.has(target)) return;
     this._fetchInflight.add(target);
     try {
       await this.download(target);
     } catch (err) {
       await this.saveRecord(target, {
-        last_error: err instanceof Error ? err.message : String(err),
-        remote_status: "found"
+        last_error: err instanceof Error ? err.message : String(err)
       });
       this._log.debug(`agent.md auto fetch failed: aid=${target} source=${source || "-"} err=${err instanceof Error ? err.message : String(err)}`);
     } finally {
@@ -28426,7 +29319,6 @@ var _AUNClient = class _AUNClient {
     __publicField(this, "_reconnectActive", false);
     __publicField(this, "_reconnectAbort", null);
     __publicField(this, "_reconnectTask", null);
-    __publicField(this, "_reconnectEventDispatchDepth", 0);
     __publicField(this, "_serverKicked", false);
     // 重连状态追踪（对齐 Python client.py）
     __publicField(this, "_nextRetryAt", null);
@@ -28606,7 +29498,7 @@ var _AUNClient = class _AUNClient {
     });
     for (const evt of ["message.ack", "storage.object_changed", "stream/created", "stream/closed"]) {
       this._dispatcher.subscribe(`_raw.${evt}`, (data) => {
-        this._dispatcher.publish(evt, data);
+        this._dispatcher.enqueue(evt, data);
       });
     }
     this._dispatcher.subscribe("_raw.gateway.disconnect", async (data) => {
@@ -28877,6 +29769,7 @@ var _AUNClient = class _AUNClient {
     this._peerCache.clear();
     this._certCache.clear();
     this._gatewayUrl = null;
+    this._gatewayCandidates = [];
     this._deviceId = aid.deviceId || getDeviceId();
     this._slotId = aid.slotId || "default";
     this._logger = new AUNLogger({ debug: aid.debug, aunPath: nextConfig.aunPath });
@@ -29056,7 +29949,7 @@ var _AUNClient = class _AUNClient {
     if (!message.toLowerCase().startsWith(agentPrefix)) return false;
     const target = message.slice(agentPrefix.length).trim();
     if (!target || target.toLowerCase() !== String(this._aid ?? "").trim().toLowerCase()) return false;
-    await this._agentMdManager.upload(buildDefaultAgentMd(target));
+    await this._agentMdManager.upload(await this._agentMdManager.readContent(target) ?? buildDefaultAgentMd(target));
     return true;
   }
   async _runGroupIdentityOperation(groupId, operation) {
@@ -29085,6 +29978,10 @@ var _AUNClient = class _AUNClient {
     }
     this._aidStore = store;
     const payload = { ...params2 };
+    if (payload.group_name === void 0 && payload.groupName !== void 0) {
+      payload.group_name = payload.groupName;
+      delete payload.groupName;
+    }
     const isNamed = Boolean(String(payload.group_name ?? "").trim());
     payload._defer_group_ready_postprocess = true;
     if (!isNamed) {
@@ -29112,7 +30009,24 @@ var _AUNClient = class _AUNClient {
       delete postprocessParams2._defer_group_ready_postprocess;
       return await this._groupState.postprocessResult("group.create", postprocessParams2, result2);
     }
-    const keyPair = await new CryptoProvider().generateIdentity();
+    const pendingKey = `create:${String(payload.group_name).trim().toLowerCase()}`;
+    const keystore = store._keystore;
+    let keyPair = null;
+    if (keystore && typeof keystore.loadPendingGroupBind === "function") {
+      keyPair = await keystore.loadPendingGroupBind(pendingKey);
+    }
+    if (!keyPair || !keyPair.public_key_der_b64 || !keyPair.private_key_pem) {
+      const generated = await new CryptoProvider().generateIdentity();
+      keyPair = {
+        private_key_pem: generated.private_key_pem,
+        public_key_der_b64: generated.public_key_der_b64,
+        curve: generated.curve
+      };
+      if (keystore && typeof keystore.savePendingGroupBind === "function") {
+        await keystore.savePendingGroupBind(pendingKey, keyPair);
+      }
+    }
+    if (!keyPair) throw new ValidationError("createGroup: failed to generate or load key pair");
     payload.public_key = keyPair.public_key_der_b64;
     payload.curve = keyPair.curve;
     const result = await this.call("group.create", payload);
@@ -29138,6 +30052,9 @@ var _AUNClient = class _AUNClient {
       throw new ValidationError("createGroup requires current owner AID for group agent.md upload");
     }
     await this._uploadGroupAgentMd(store, groupAid, payload, group, uploaderAid);
+    if (keystore && typeof keystore.clearPendingGroupBind === "function") {
+      await keystore.clearPendingGroupBind(pendingKey);
+    }
     const postprocessParams = { ...payload };
     delete postprocessParams._defer_group_ready_postprocess;
     return await this._groupState.postprocessResult("group.create", postprocessParams, result);
@@ -29195,10 +30112,14 @@ var _AUNClient = class _AUNClient {
     }
     this._aidStore = store;
     const groupId = String(params2.group_id ?? params2.group_aid ?? "").trim();
+    const pendingKey = `bind:${groupId}`;
     const keystore = store._keystore;
     let keyPair = null;
     if (groupId && keystore && typeof keystore.loadPendingGroupBind === "function") {
-      keyPair = await keystore.loadPendingGroupBind(groupId);
+      keyPair = await keystore.loadPendingGroupBind(pendingKey);
+      if (!keyPair || !keyPair.public_key_der_b64 || !keyPair.private_key_pem) {
+        keyPair = await keystore.loadPendingGroupBind(groupId);
+      }
     }
     if (!keyPair || !keyPair.public_key_der_b64 || !keyPair.private_key_pem) {
       const generated = await new CryptoProvider().generateIdentity();
@@ -29208,7 +30129,7 @@ var _AUNClient = class _AUNClient {
         curve: generated.curve
       };
       if (groupId && keystore && typeof keystore.savePendingGroupBind === "function") {
-        await keystore.savePendingGroupBind(groupId, keyPair);
+        await keystore.savePendingGroupBind(pendingKey, keyPair);
       }
     }
     if (!keyPair) {
@@ -29244,6 +30165,7 @@ var _AUNClient = class _AUNClient {
     }
     await this._uploadGroupAgentMd(store, groupAid, payload, group, uploaderAid);
     if (groupId && keystore && typeof keystore.clearPendingGroupBind === "function") {
+      await keystore.clearPendingGroupBind(pendingKey);
       await keystore.clearPendingGroupBind(groupId);
     }
     return result;
@@ -29280,7 +30202,24 @@ var _AUNClient = class _AUNClient {
     if (!oldPublicKey) {
       throw new ValidationError(`renewGroupAid: cannot determine old public key for ${groupAid}`);
     }
-    const newKeyPair = await new CryptoProvider().generateIdentity();
+    const keystore = store._keystore;
+    const pendingKey = `renew:${groupId}`;
+    let newKeyPair = null;
+    if (keystore && typeof keystore.loadPendingGroupBind === "function") {
+      newKeyPair = await keystore.loadPendingGroupBind(pendingKey);
+    }
+    if (!newKeyPair || !newKeyPair.public_key_der_b64 || !newKeyPair.private_key_pem) {
+      const generated = await new CryptoProvider().generateIdentity();
+      newKeyPair = {
+        private_key_pem: generated.private_key_pem,
+        public_key_der_b64: generated.public_key_der_b64,
+        curve: generated.curve
+      };
+      if (keystore && typeof keystore.savePendingGroupBind === "function") {
+        await keystore.savePendingGroupBind(pendingKey, newKeyPair);
+      }
+    }
+    if (!newKeyPair) throw new ValidationError("renewGroupAid: failed to generate or load key pair");
     const newPublicKey = newKeyPair.public_key_der_b64;
     const newPrivateKey = newKeyPair.private_key_pem;
     const curve = newKeyPair.curve || "P-256";
@@ -29336,6 +30275,9 @@ var _AUNClient = class _AUNClient {
       throw new ValidationError("renewGroupAid requires current owner AID for group agent.md upload");
     }
     await this._uploadGroupAgentMd(store, returnedGroupAid, payload, group, uploaderAid);
+    if (keystore && typeof keystore.clearPendingGroupBind === "function") {
+      await keystore.clearPendingGroupBind(pendingKey);
+    }
     return result;
   }
   async startGroupTransfer(params2 = {}, options = {}) {
@@ -29393,12 +30335,12 @@ var _AUNClient = class _AUNClient {
     if (!store) {
       throw new ValidationError("completeGroupTransfer requires aidStore");
     }
-    const keyPair = await new CryptoProvider().generateIdentity();
     const payload = { ...params2 };
     const groupId = String(params2.group_id ?? "").trim();
     if (!groupId) {
       throw new ValidationError("completeGroupTransfer requires group_id");
     }
+    const pendingKey = `complete:${groupId}`;
     let groupAid = String(params2.group_aid ?? "").trim();
     if (!groupAid) {
       const info = await this.call("group.get_info", { group_id: groupId, required: ["member"] });
@@ -29407,6 +30349,23 @@ var _AUNClient = class _AUNClient {
     if (!groupAid) {
       throw new ValidationError("completeGroupTransfer: unable to determine group_aid");
     }
+    const keystore = store._keystore;
+    let keyPair = null;
+    if (keystore && typeof keystore.loadPendingGroupBind === "function") {
+      keyPair = await keystore.loadPendingGroupBind(pendingKey);
+    }
+    if (!keyPair || !keyPair.public_key_der_b64 || !keyPair.private_key_pem) {
+      const generated = await new CryptoProvider().generateIdentity();
+      keyPair = {
+        private_key_pem: generated.private_key_pem,
+        public_key_der_b64: generated.public_key_der_b64,
+        curve: generated.curve
+      };
+      if (keystore && typeof keystore.savePendingGroupBind === "function") {
+        await keystore.savePendingGroupBind(pendingKey, keyPair);
+      }
+    }
+    if (!keyPair) throw new ValidationError("completeGroupTransfer: failed to generate or load key pair");
     const current = this.currentAid;
     const newOwner = String(current?.aid ?? "").trim();
     if (!current || !newOwner || !current.isPrivateKeyValid()) {
@@ -29460,6 +30419,9 @@ var _AUNClient = class _AUNClient {
       throw new ValidationError("completeGroupTransfer requires current owner AID for group agent.md upload");
     }
     await this._uploadGroupAgentMd(store, returnedGroupAid, payload, group, uploaderAid);
+    if (keystore && typeof keystore.clearPendingGroupBind === "function") {
+      await keystore.clearPendingGroupBind(pendingKey);
+    }
     return result;
   }
   static _notifyParamsSizeOk(params2) {
@@ -29623,8 +30585,8 @@ var _AUNClient = class _AUNClient {
   _markPublishedSeq(ns, seq2) {
     this._delivery.markPublishedSeq(ns, seq2);
   }
-  async _publishAppEvent(event, payload) {
-    await this._delivery.publishAppEvent(event, payload);
+  async _publishAppEvent(event, payload, source = "", ns = "", batch) {
+    await this._delivery.publishAppEvent(event, payload, source, ns, batch);
   }
   _echoTimestamp() {
     const now = /* @__PURE__ */ new Date();
@@ -29662,11 +30624,11 @@ var _AUNClient = class _AUNClient {
   async _drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true) {
     await this._delivery.drainOrderedMessages(ns, beforeSeq, pullResponse, persist);
   }
-  async _publishOrderedMessage(event, ns, seq2, payload) {
-    return this._delivery.publishOrderedMessage(event, ns, seq2, payload);
+  async _publishOrderedMessage(event, ns, seq2, payload, source = "push", batch) {
+    return this._delivery.publishOrderedMessage(event, ns, seq2, payload, source, batch);
   }
-  async _publishPulledMessage(event, ns, seq2, payload, persist = true) {
-    return this._delivery.publishPulledMessage(event, ns, seq2, payload, persist);
+  async _publishPulledMessage(event, ns, seq2, payload, persist = true, source = "pull", batch) {
+    return this._delivery.publishPulledMessage(event, ns, seq2, payload, persist, source, batch);
   }
   _extractGroupIdFromResult(result) {
     const group = isJsonObject(result.group) ? result.group : null;
@@ -29697,7 +30659,7 @@ var _AUNClient = class _AUNClient {
         const groupId = d.group_id ?? d.group_aid ?? "";
         await this._delivery.handleGroupChangedEventSeq(d, groupId);
       } else {
-        await this._dispatcher.publish("group.changed", data);
+        this._dispatcher.enqueue("group.changed", data);
       }
       this._clientLog.debug(`_onRawGroupChanged exit: elapsed=${Date.now() - tStart}ms group_id=${groupIdInit}`);
     } catch (err) {
@@ -29770,7 +30732,7 @@ var _AUNClient = class _AUNClient {
       const ok = await ecdsaVerifyDer(pubKey, sigBytes, signData);
       if (!ok) {
         this._clientLog.warn(`group event sig verify failed aid=%s method=%s${sigAid} ${method}`);
-        this._dispatcher.publish("signature.verification_failed", {
+        this._dispatcher.enqueue("signature.verification_failed", {
           aid: sigAid,
           method,
           error: "ECDSA verification failed"
@@ -29779,7 +30741,7 @@ var _AUNClient = class _AUNClient {
       return ok;
     } catch (exc) {
       this._clientLog.warn(`group event sig verify exception:${String(exc)}`);
-      this._dispatcher.publish("signature.verification_failed", {
+      this._dispatcher.enqueue("signature.verification_failed", {
         aid: sigAid,
         method,
         error: String(exc)
@@ -29997,7 +30959,7 @@ var _AUNClient = class _AUNClient {
           throw new StateError("connection attempt superseded");
         }
       } else {
-        await this._dispatcher.publish("state_change", statePayload);
+        this._dispatcher.enqueue("state_change", statePayload);
       }
       this._assertReconnectOwner(reconnectOwner);
       this._lifecycle.assertConnectionAttemptOwner(connectionOwner);
@@ -30040,16 +31002,21 @@ var _AUNClient = class _AUNClient {
   async _resolveGatewayCandidatesForAid(aid) {
     const target = String(aid ?? this._aid ?? "").trim();
     if (!target) throw new StateError("gateway discovery requires a loaded AID");
+    const discovery = this._discovery;
+    const tokenStore = this._tokenStore;
+    const discoveryIsCurrent = () => this._discovery === discovery && this._tokenStore === tokenStore && !this._closing;
     if (this._gatewayCandidates.length > 0) return [...this._gatewayCandidates];
     if (this._gatewayUrl) {
       this._gatewayCandidates = [this._gatewayUrl];
       return [...this._gatewayCandidates];
     }
     try {
-      const getMetadata = this._tokenStore.getMetadata;
-      const rawList = typeof getMetadata === "function" ? String(await getMetadata.call(this._tokenStore, target, "gateway_urls") ?? "").trim() : "";
+      const getMetadata = tokenStore.getMetadata;
+      const rawList = typeof getMetadata === "function" ? String(await getMetadata.call(tokenStore, target, "gateway_urls") ?? "").trim() : "";
+      if (!discoveryIsCurrent()) throw new StateError("gateway discovery superseded by identity change");
       const cachedList = rawList ? JSON.parse(rawList) : [];
-      const raw = typeof getMetadata === "function" ? String(await getMetadata.call(this._tokenStore, target, "gateway_url") ?? "").trim() : "";
+      const raw = typeof getMetadata === "function" ? String(await getMetadata.call(tokenStore, target, "gateway_url") ?? "").trim() : "";
+      if (!discoveryIsCurrent()) throw new StateError("gateway discovery superseded by identity change");
       const candidates2 = Array.isArray(cachedList) ? cachedList.map((item) => String(item ?? "").trim()).filter(Boolean) : [];
       const gateway = candidates2[0] ?? (raw.startsWith('"') && raw.endsWith('"') ? String(JSON.parse(raw)).trim() : raw);
       if (gateway) {
@@ -30058,6 +31025,7 @@ var _AUNClient = class _AUNClient {
         return [...this._gatewayCandidates];
       }
     } catch {
+      if (!discoveryIsCurrent()) throw new StateError("gateway discovery superseded by identity change");
     }
     const dotIdx = target.indexOf(".");
     const issuerDomain = dotIdx >= 0 ? target.slice(dotIdx + 1) : target;
@@ -30069,22 +31037,26 @@ var _AUNClient = class _AUNClient {
     let lastError = null;
     for (const url of candidates) {
       try {
-        const discovered = await this._discovery.discoverAll(url);
+        const discovered = await discovery.discoverAll(url);
+        if (!discoveryIsCurrent()) throw new StateError("gateway discovery superseded by identity change");
         const gatewayUrls = [...new Set(discovered.map((item) => String(item ?? "").trim()).filter(Boolean))];
         if (gatewayUrls.length === 0) throw new ValidationError("gateway discovery returned no candidates");
         const gateway = gatewayUrls[0];
         this._gatewayCandidates = gatewayUrls;
         this._gatewayUrl = gateway;
         try {
-          const setMetadata = this._tokenStore.setMetadata;
+          const setMetadata = tokenStore.setMetadata;
           if (typeof setMetadata === "function") {
-            await setMetadata.call(this._tokenStore, target, "gateway_url", gateway);
-            await setMetadata.call(this._tokenStore, target, "gateway_urls", JSON.stringify(gatewayUrls));
+            await setMetadata.call(tokenStore, target, "gateway_url", gateway);
+            if (!discoveryIsCurrent()) throw new StateError("gateway discovery superseded by identity change");
+            await setMetadata.call(tokenStore, target, "gateway_urls", JSON.stringify(gatewayUrls));
+            if (!discoveryIsCurrent()) throw new StateError("gateway discovery superseded by identity change");
           }
         } catch {
         }
         return [...gatewayUrls];
       } catch (err) {
+        if (!discoveryIsCurrent()) throw new StateError("gateway discovery superseded by identity change");
         lastError = err;
       }
     }
@@ -30304,7 +31276,7 @@ var _AUNClient = class _AUNClient {
           if (this._sessionParams && identity.access_token) {
             this._sessionParams.access_token = identity.access_token;
           }
-          await this._dispatcher.publish("token.refreshed", {
+          this._dispatcher.enqueue("token.refreshed", {
             aid: identity.aid,
             expires_at: identity.access_token_expires_at
           });
@@ -30313,7 +31285,7 @@ var _AUNClient = class _AUNClient {
           if (exc instanceof AuthError) {
             if (authErrorRequiresRelogin(exc)) {
               this._clientLog.warn(`token refresh requires relogin, stopping refresh loop and triggering reconnect: ${exc.message}`);
-              await this._dispatcher.publish("token.refresh_exhausted", {
+              this._dispatcher.enqueue("token.refresh_exhausted", {
                 aid: this._identity?.aid ?? null,
                 consecutive_failures: 1,
                 last_error: String(exc),
@@ -30326,7 +31298,7 @@ var _AUNClient = class _AUNClient {
             this._tokenRefreshFailures++;
             if (this._tokenRefreshFailures >= 3) {
               this._clientLog.warn(`token refresh failed ${this._tokenRefreshFailures} consecutive times, stopping refresh loop and triggering reconnect`);
-              await this._dispatcher.publish("token.refresh_exhausted", {
+              this._dispatcher.enqueue("token.refresh_exhausted", {
                 aid: this._identity?.aid ?? null,
                 consecutive_failures: this._tokenRefreshFailures,
                 last_error: String(exc)
@@ -30337,7 +31309,7 @@ var _AUNClient = class _AUNClient {
             }
             this._clientLog.warn(`token refresh failed (${this._tokenRefreshFailures}/3), next retry: ${String(exc)}`);
           } else {
-            this._dispatcher.publish("connection.error", { error: formatCaughtError2(exc) });
+            this._dispatcher.enqueue("connection.error", { error: formatCaughtError2(exc) });
           }
         }
         scheduleRefresh();
@@ -30366,7 +31338,7 @@ var _AUNClient = class _AUNClient {
     this._serverKicked = !retryable;
     this._lastDisconnectInfo = { code, reason, detail };
     try {
-      await this._dispatcher.publish("gateway.disconnect", { code, reason, detail });
+      this._dispatcher.enqueue("gateway.disconnect", { code, reason, detail });
     } catch (exc) {
       this._clientLog.debug(`publish gateway.disconnect failed: ${exc?.message ?? exc}`);
     }
@@ -30385,7 +31357,7 @@ var _AUNClient = class _AUNClient {
     } catch (exc) {
       this._clientLog.debug(`transport cleanup skipped: ${formatCaughtError2(exc)}`);
     }
-    await this._dispatcher.publish("state_change", {
+    this._dispatcher.enqueue("state_change", {
       state: this._publicState(this._state),
       error
     });
@@ -30421,7 +31393,7 @@ var _AUNClient = class _AUNClient {
       if (disconnectInfo.code !== void 0 && disconnectInfo.code !== null) {
         eventPayload.code = disconnectInfo.code;
       }
-      await this._dispatcher.publish("state_change", eventPayload);
+      this._dispatcher.enqueue("state_change", eventPayload);
       if (this._reconnectAbort === reconnectAbort) {
         this._reconnectAbort = null;
         this._reconnectActive = false;
@@ -30452,12 +31424,7 @@ var _AUNClient = class _AUNClient {
   }
   async _publishReconnectEvent(owner, event, payload) {
     if (!this._ownsReconnect(owner)) return false;
-    this._reconnectEventDispatchDepth += 1;
-    try {
-      await this._dispatcher.publish(event, payload);
-    } finally {
-      this._reconnectEventDispatchDepth -= 1;
-    }
+    this._dispatcher.enqueue(event, payload);
     return this._ownsReconnect(owner);
   }
   async _cancelReconnectAndWait() {
@@ -30470,7 +31437,7 @@ var _AUNClient = class _AUNClient {
     } catch (exc) {
       this._clientLog.debug(`reconnect cancellation transport cleanup skipped: ${formatCaughtError2(exc)}`);
     }
-    if (task && this._reconnectEventDispatchDepth === 0) {
+    if (task) {
       try {
         await task;
       } catch (exc) {
@@ -30993,7 +31960,7 @@ var _AUNClient = class _AUNClient {
             _spk_id: spkId
           };
           attachV2EnvelopeMetadata2(event, e2eeMeta);
-          await this._dispatcher.publish(undecryptableEvent, event);
+          this._dispatcher.enqueue(undecryptableEvent, event);
         } catch {
         }
       }
@@ -31034,7 +32001,7 @@ var _AUNClient = class _AUNClient {
             _suite: String(envelope.suite ?? "")
           };
           attachV2EnvelopeMetadata2(event, e2eeMeta);
-          await this._dispatcher.publish(undecryptableEvent, event);
+          this._dispatcher.enqueue(undecryptableEvent, event);
         } catch {
         }
       }
@@ -31070,7 +32037,7 @@ var _AUNClient = class _AUNClient {
             _suite: String(envelope.suite ?? "")
           };
           attachV2EnvelopeMetadata2(event, e2eeMeta);
-          await this._dispatcher.publish(undecryptableEvent, event);
+          this._dispatcher.enqueue(undecryptableEvent, event);
         } catch {
         }
       }
@@ -31645,7 +32612,7 @@ var RegisterFlow = class _RegisterFlow {
     return new Promise((resolve, reject) => {
       let ws;
       try {
-        ws = new WebSocket(gatewayUrl);
+        ws = createTransportWebSocket(gatewayUrl);
       } catch {
         reject(new AuthError(`WebSocket \u8FDE\u63A5\u5931\u8D25: ${gatewayUrl}`));
         return;
@@ -31679,7 +32646,19 @@ var RegisterFlow = class _RegisterFlow {
           if (!receivedChallenge) {
             if (!isJsonObject(msg) || msg.method !== "challenge") return;
             receivedChallenge = true;
-            ws.send(JSON.stringify({ jsonrpc: "2.0", id: requestId, method, params: params2 }));
+            const sendResult = ws.send(JSON.stringify({ jsonrpc: "2.0", id: requestId, method, params: params2 }));
+            if (sendResult && typeof sendResult.then === "function") {
+              void Promise.resolve(sendResult).catch((error) => {
+                if (settled) return;
+                settled = true;
+                globalThis.clearTimeout(timeout);
+                try {
+                  ws.close();
+                } catch {
+                }
+                reject(error instanceof Error ? error : new AuthError(String(error)));
+              });
+            }
             return;
           }
           if (!isJsonObject(msg) || msg.id !== requestId) return;
@@ -32600,8 +33579,7 @@ var AIDStore = class {
         });
       }
       await this._persistGatewayUrl(target, gatewayUrl);
-      const uploaded = await this.uploadAgentMd(target, buildDefaultAgentMd(target));
-      if (!uploaded.ok) return uploaded;
+      await this.uploadAgentMd(target, buildDefaultAgentMd(target));
       return resultOk({ registered: true });
     } catch (exc) {
       if (exc instanceof IdentityConflictError) {