@agentunion/fastaun-browser 0.4.8 → 0.4.10

package/dist/bundle.js

@@ -454,7 +454,7 @@ var init_indexeddb_store = __esm({
 });
 
 // src/version.ts
-var VERSION = "0.4.8";
+var VERSION = "0.4.10";
 
 // src/types.ts
 var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
@@ -1236,6 +1236,7 @@ var EVENT_NAME_MAP = {
   "message.ack": "message.ack",
   "group.changed": "group.changed",
   "group.message_created": "group.message_created",
+  "group.message_recalled": "group.message_recalled",
   "group.state_committed": "group.state_committed",
   "storage.object_changed": "storage.object_changed"
 };
@@ -1579,6 +1580,34 @@ var RPCTransport = class {
       this._drainRpcQueue();
     });
   }
+  /** 发送 JSON-RPC 2.0 Notification，不分配 id，也不等待响应。 */
+  async notify(method, params) {
+    if (this._closed || !this._ws) {
+      throw this._notConnectedError();
+    }
+    const normalizedMethod = String(method ?? "").trim();
+    if (!normalizedMethod.startsWith("notification/") && !normalizedMethod.startsWith("event/")) {
+      throw new ValidationError("notify method must start with notification/ or event/");
+    }
+    if (params !== void 0 && params !== null && !isJsonObject(params)) {
+      throw new ValidationError("notify params must be an object");
+    }
+    const payload = JSON.stringify({
+      jsonrpc: "2.0",
+      method: normalizedMethod,
+      params: params ?? {}
+    });
+    const payloadSize = new TextEncoder().encode(payload).length;
+    if (payloadSize > MAX_WS_PAYLOAD_SIZE) {
+      throw new ValidationError("payload is too large");
+    }
+    try {
+      this._ws.send(payload);
+      this._log.debug(`notification sent: method=${normalizedMethod}, size=${payloadSize}`);
+    } catch (err) {
+      throw new ConnectionError(`failed to send notification ${normalizedMethod}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   /** 从 pending / queue 中移除指定 RPC */
   _removeRpc(rpcId, pending) {
     const current = this._pending.get(rpcId);
@@ -1747,6 +1776,10 @@ var RPCTransport = class {
           this._log.info(`[trace=${String(traceObj.trace_id ?? "")}] event_recv event=${sdkEvent}`);
         }
       }
+      if (sdkEvent.startsWith("app.")) {
+        this._dispatcher.publish(sdkEvent, params);
+        return;
+      }
       this._dispatcher.publish(`_raw.${sdkEvent}`, params);
       return;
     }
@@ -3421,16 +3454,262 @@ var SeqTracker = class {
 };
 
 // src/client/runtime.ts
+var RuntimeSection = class {
+  constructor(runtime) {
+    __publicField(this, "runtime");
+    this.runtime = runtime;
+  }
+  get client() {
+    return this.runtime.client;
+  }
+};
+var RuntimeIdentityState = class extends RuntimeSection {
+  get aid() {
+    return this.client._aid ?? null;
+  }
+  get currentAid() {
+    return this.client._currentAid ?? null;
+  }
+  get identity() {
+    return this.client._identity ?? null;
+  }
+  get deviceId() {
+    return String(this.client._deviceId ?? "");
+  }
+  get slotId() {
+    return String(this.client._slotId ?? "");
+  }
+  setLoadedIdentity(aid, identity) {
+    this.client._currentAid = aid;
+    this.client._aid = aid.aid;
+    this.client._identity = identity;
+    this.client._auth?.setIdentity?.(identity);
+  }
+  setIdentity(identity) {
+    this.client._identity = identity;
+  }
+  setAid(aid) {
+    this.client._aid = aid;
+  }
+  setInstanceContext(deviceId, slotId) {
+    this.client._deviceId = deviceId;
+    this.client._slotId = slotId;
+    this.client._auth?.setInstanceContext?.(deviceId, slotId);
+  }
+  clear() {
+    this.client._currentAid = null;
+    this.client._aid = null;
+    this.client._identity = null;
+  }
+};
+var RuntimeLifecycleState = class extends RuntimeSection {
+  get state() {
+    return String(this.client._state ?? "");
+  }
+  setState(state) {
+    this.client._state = state;
+  }
+  setClosing(closing) {
+    this.client._closing = closing;
+  }
+  setGatewayUrl(gatewayUrl) {
+    this.client._gatewayUrl = gatewayUrl;
+  }
+  setSession(params, options) {
+    this.client._sessionParams = params;
+    if (options !== void 0) this.client._sessionOptions = options;
+  }
+  clearRetryState() {
+    this.client._nextRetryAt = null;
+    this.client._retryAttempt = 0;
+    this.client._lastError = null;
+    this.client._lastErrorCode = null;
+  }
+  setNextRetryAt(nextRetryAt) {
+    this.client._nextRetryAt = nextRetryAt;
+  }
+  setRetryAttempt(attempt) {
+    this.client._retryAttempt = attempt;
+  }
+  setError(error, code) {
+    this.client._lastError = error;
+    this.client._lastErrorCode = code;
+  }
+  clearReconnectState() {
+    this.client._reconnectAbort = null;
+    this.client._reconnectActive = false;
+  }
+  resetForDisconnect(nextState) {
+    this.client._state = nextState;
+    this.client._nextRetryAt = null;
+    this.client._retryAttempt = 0;
+    this.client._lastError = null;
+    this.client._lastErrorCode = null;
+  }
+  resetForClose() {
+    this.client._state = "closed";
+    this.client._currentAid = null;
+    this.client._aid = null;
+    this.client._identity = null;
+    this.client._gatewayUrl = null;
+    this.client._sessionParams = null;
+    this.clearRetryState();
+  }
+};
+var RuntimeRpcState = class extends RuntimeSection {
+  get protectedHeaders() {
+    return this.client._instanceProtectedHeaders ?? null;
+  }
+  set protectedHeaders(value) {
+    this.client._instanceProtectedHeaders = value;
+  }
+  get pullGates() {
+    if (!this.client._pullGates) {
+      this.client._pullGates = /* @__PURE__ */ new Map();
+    }
+    return this.client._pullGates;
+  }
+};
+var RuntimeDeliveryState = class extends RuntimeSection {
+  get seqTracker() {
+    return this.client._seqTracker;
+  }
+  set seqTracker(value) {
+    this.client._seqTracker = value;
+  }
+  setGapFillActive(active) {
+    this.client._gapFillActive = active;
+  }
+  setOnlineUnreadHintTimer(timer) {
+    this.client._onlineUnreadHintTimer = timer;
+  }
+  setOnlineUnreadHintDrainActive(active) {
+    this.client._onlineUnreadHintDrainActive = active;
+  }
+  setV2PullPending(pending) {
+    this.client._v2PullPending = pending;
+  }
+  setV2PullInflight(inflight) {
+    this.client._v2PullInflight = inflight;
+  }
+};
+var RuntimeV2State = class extends RuntimeSection {
+  get session() {
+    return this.client._v2Session;
+  }
+  set session(value) {
+    this.client._v2Session = value;
+  }
+  get bootstrapCache() {
+    if (!this.client._v2BootstrapCache) {
+      this.client._v2BootstrapCache = /* @__PURE__ */ new Map();
+    }
+    return this.client._v2BootstrapCache;
+  }
+  setBootstrapCache(cache) {
+    this.client._v2BootstrapCache = cache;
+  }
+  setSessionState(keyStore, session) {
+    this.client._v2KeyStore = keyStore;
+    this.client._v2Session = session;
+  }
+  resetForIdentity() {
+    this.client._v2Session = void 0;
+    this.client._v2KeyStore = void 0;
+    this.client._v2SessionInitInFlight = null;
+    this.client._v2BootstrapCache = /* @__PURE__ */ new Map();
+    this.client._v2SigCache = /* @__PURE__ */ new Map();
+    this.client._v2SenderIKPending = /* @__PURE__ */ new Map();
+    this.client._v2SenderIKFetching = /* @__PURE__ */ new Set();
+  }
+  get groupSpkRegistrationInflight() {
+    if (!this.client._groupSpkRegistrationInflight) {
+      this.client._groupSpkRegistrationInflight = /* @__PURE__ */ new Set();
+    }
+    return this.client._groupSpkRegistrationInflight;
+  }
+  get groupSpkRotationInflight() {
+    if (!this.client._groupSpkRotationInflight) {
+      this.client._groupSpkRotationInflight = /* @__PURE__ */ new Set();
+    }
+    return this.client._groupSpkRotationInflight;
+  }
+  get groupSpkPeerFallbackRegistered() {
+    if (!this.client._groupSpkPeerFallbackRegistered) {
+      this.client._groupSpkPeerFallbackRegistered = /* @__PURE__ */ new Set();
+    }
+    return this.client._groupSpkPeerFallbackRegistered;
+  }
+};
+var RuntimeGroupState = class extends RuntimeSection {
+  get chains() {
+    if (!this.client._v2StateChains) this.client._v2StateChains = /* @__PURE__ */ new Map();
+    return this.client._v2StateChains;
+  }
+  get securityLevels() {
+    if (!this.client._v2GroupSecurityLevels) this.client._v2GroupSecurityLevels = /* @__PURE__ */ new Map();
+    return this.client._v2GroupSecurityLevels;
+  }
+  get sigCache() {
+    if (!this.client._v2SigCache) this.client._v2SigCache = /* @__PURE__ */ new Map();
+    return this.client._v2SigCache;
+  }
+  get lazyProposeTriggered() {
+    if (!this.client._v2LazyProposeTriggered) this.client._v2LazyProposeTriggered = /* @__PURE__ */ new Map();
+    return this.client._v2LazyProposeTriggered;
+  }
+};
+var RuntimeServices = class extends RuntimeSection {
+  get logger() {
+    return this.client._logger;
+  }
+  get clientLog() {
+    return this.client._clientLog;
+  }
+  get dispatcher() {
+    return this.client._dispatcher;
+  }
+  get tokenStore() {
+    return this.client._tokenStore;
+  }
+  get auth() {
+    return this.client._auth;
+  }
+  get transport() {
+    return this.client._transport;
+  }
+  get discovery() {
+    return this.client._discovery;
+  }
+  get agentMdManager() {
+    return this.client._agentMdManager;
+  }
+};
 var ClientRuntime = class {
   constructor(client) {
     __publicField(this, "client");
+    __publicField(this, "identity");
+    __publicField(this, "lifecycle");
+    __publicField(this, "rpc");
+    __publicField(this, "delivery");
+    __publicField(this, "v2");
+    __publicField(this, "groupState");
+    __publicField(this, "services");
     this.client = client;
+    this.identity = new RuntimeIdentityState(this);
+    this.lifecycle = new RuntimeLifecycleState(this);
+    this.rpc = new RuntimeRpcState(this);
+    this.delivery = new RuntimeDeliveryState(this);
+    this.v2 = new RuntimeV2State(this);
+    this.groupState = new RuntimeGroupState(this);
+    this.services = new RuntimeServices(this);
   }
 };
 
 // src/client/delivery.ts
 var PUSHED_SEQS_LIMIT = 5e4;
 var PENDING_ORDERED_LIMIT = 5e4;
+var GROUP_RECALL_SEEN_LIMIT = 1e4;
 function formatDeliveryError(error) {
   return error instanceof Error ? error : String(error);
 }
@@ -3475,7 +3754,7 @@ var MessageDeliveryEngine = class {
     }
   }
   isInstanceScopedMessageEvent(event) {
-    return event === "message.received" || event === "message.recalled" || event === "message.undecryptable" || event === "group.message_created" || event === "group.message_undecryptable";
+    return event === "message.received" || event === "message.recalled" || event === "message.undecryptable" || event === "group.message_created" || event === "group.message_recalled" || event === "group.message_undecryptable";
   }
   attachCurrentInstanceContext(payload) {
     if (!isJsonObject(payload)) return payload;
@@ -3539,6 +3818,121 @@ var MessageDeliveryEngine = class {
     if (recall) return { event: "message.recalled", payload: recall };
     return { event: "message.received", payload: message };
   }
+  recallEventFromGroupMessage(message) {
+    if (!isJsonObject(message)) return null;
+    const msg = message;
+    const rawPayload = msg.payload;
+    const payload = isJsonObject(rawPayload) ? rawPayload : {};
+    const msgType = String(msg.type ?? msg.kind ?? msg.message_type ?? "").trim();
+    const payloadType = String(payload.type ?? payload.kind ?? "").trim();
+    if (msgType !== "group.message_recalled" && payloadType !== "group.message_recalled") return null;
+    const event = { ...payload };
+    const rawIds = event.message_ids;
+    let messageIds = Array.isArray(rawIds) ? rawIds.map((item) => String(item ?? "").trim()).filter(Boolean) : [];
+    if (messageIds.length === 0) {
+      for (const key of ["recalled_message_id", "target_message_id", "original_message_id"]) {
+        const value = String(event[key] ?? "").trim();
+        if (value) {
+          messageIds = [value];
+          break;
+        }
+      }
+    }
+    event.type = "group.message_recalled";
+    event.kind = "group.message_recalled";
+    event.message_ids = messageIds;
+    if (!("group_id" in event)) event.group_id = msg.group_id ?? "";
+    if (!("timestamp" in event)) event.timestamp = msg.timestamp ?? msg.t_server ?? event.recalled_at ?? 0;
+    if ("seq" in msg) event.seq = msg.seq;
+    if ("message_id" in msg && !("tombstone_message_id" in event)) event.tombstone_message_id = msg.message_id;
+    return event;
+  }
+  groupRecallDedupKey(groupId, payload) {
+    const ids = payload.message_ids;
+    const idPart = Array.isArray(ids) ? ids.map((i) => String(i ?? "").trim()).filter(Boolean).sort().join(",") : String(ids ?? "");
+    return `${groupId}|${idPart}`;
+  }
+  async publishGroupRecallTombstone(groupId, seq, message) {
+    const client = this.runtime.client;
+    const eventPayload = this.recallEventFromGroupMessage(message);
+    if (!eventPayload) return false;
+    const dedupKey = this.groupRecallDedupKey(groupId, eventPayload);
+    let seen = client._groupRecallSeen;
+    if (!seen) {
+      seen = /* @__PURE__ */ new Map();
+      client._groupRecallSeen = seen;
+    }
+    if (seen.has(dedupKey)) {
+      client._clientLog.debug(`group.message_recalled dedup suppressed: group=${groupId} seq=${String(seq)} key=${dedupKey}`);
+      return false;
+    }
+    seen.set(dedupKey, Date.now());
+    if (seen.size > GROUP_RECALL_SEEN_LIMIT) {
+      const drop = [...seen.entries()].sort((a, b) => a[1] - b[1]).slice(0, seen.size - GROUP_RECALL_SEEN_LIMIT);
+      for (const [oldKey] of drop) seen.delete(oldKey);
+    }
+    await client._publishAppEvent("group.message_recalled", eventPayload);
+    client._clientLog.debug(`group.message_recalled published: group=${groupId} seq=${String(seq)} ids=${JSON.stringify(eventPayload.message_ids)}`);
+    return true;
+  }
+  async onRawGroupMessageRecalled(data) {
+    const client = this.runtime.client;
+    if (!isJsonObject(data)) return;
+    const src = data;
+    const groupId = String(src.group_id ?? "").trim();
+    const wrapped = { ...src };
+    if (!("type" in wrapped)) wrapped.type = "group.message_recalled";
+    if (!("payload" in wrapped)) {
+      wrapped.payload = {
+        type: "group.message_recalled",
+        message_ids: src.message_ids ?? [],
+        target_message_seqs: src.target_message_seqs ?? [],
+        sender_aid: src.sender_aid ?? "",
+        recalled_by: src.recalled_by ?? "",
+        recalled_at: src.recalled_at ?? src.timestamp ?? 0,
+        reason: src.reason ?? "",
+        group_id: groupId
+      };
+    }
+    const seq = src.seq;
+    const seqNum = Number(seq);
+    if (!groupId || seq === void 0 || seq === null || !Number.isFinite(seqNum) || !Number.isInteger(seqNum)) {
+      await this.publishGroupRecallTombstone(groupId, seq, wrapped);
+      return;
+    }
+    const ns = `group:${groupId}`;
+    if (seqNum > 0) {
+      client._seqTracker.updateMaxSeen(ns, seqNum);
+      if (client._seqTracker.getContiguousSeq(ns) === seqNum) {
+        await this.publishGroupRecallTombstone(groupId, seq, wrapped);
+        return;
+      }
+      client._repairPushContiguousBound(ns, seqNum, true, "_raw.group.message_recalled");
+    }
+    const pushed = client._pushedSeqs.get(ns);
+    const pending = client._pendingOrderedMsgs.get(ns);
+    if (pushed?.has(seqNum) || pending?.has(seqNum)) {
+      await this.publishGroupRecallTombstone(groupId, seq, wrapped);
+      return;
+    }
+    const contigBefore = client._seqTracker.getContiguousSeq(ns);
+    client._seqTracker.onMessageSeq(ns, seqNum);
+    await this.publishGroupRecallTombstone(groupId, seq, wrapped);
+    this.markPublishedSeq(ns, seqNum);
+    const contig = client._seqTracker.getContiguousSeq(ns);
+    if (contig > 0) {
+      const ackSeq = this.clampAckSeq("group.ack_messages", "msg_seq", ns, contig);
+      client._transport.call("group.ack_messages", {
+        group_id: groupId,
+        msg_seq: ackSeq,
+        device_id: client._deviceId,
+        slot_id: client._slotId
+      }).catch((e) => {
+        client._clientLog.warn("group recall auto-ack failed: group=" + groupId, e);
+      });
+    }
+    if (contig !== contigBefore) this.saveSeqTrackerState();
+  }
   async publishAppEvent(event, payload) {
     const client = this.runtime.client;
     if ((event === "message.received" || event === "group.message_created") && isJsonObject(payload)) {
@@ -3675,6 +4069,25 @@ var MessageDeliveryEngine = class {
         if (seq > 0) client._seqTracker.updateMaxSeen(ns, seq);
         const contigBefore = client._seqTracker.getContiguousSeq(ns);
         const seqNeedsPull = client._seqTracker.onMessageSeq(ns, seq);
+        if (!encryptedPush && this.recallEventFromGroupMessage(msg)) {
+          await this.publishGroupRecallTombstone(groupId, seq, msg);
+          this.markPublishedSeq(ns, Number(seq));
+          const contigAfter2 = client._seqTracker.getContiguousSeq(ns);
+          const contig2 = client._seqTracker.getContiguousSeq(ns);
+          if (contig2 > 0) {
+            const ackSeq = this.clampAckSeq("group.ack_messages", "msg_seq", ns, contig2);
+            client._transport.call("group.ack_messages", {
+              group_id: groupId,
+              msg_seq: ackSeq,
+              device_id: client._deviceId,
+              slot_id: client._slotId
+            }).catch((e) => {
+              client._clientLog.warn("group recall auto-ack failed: group=" + groupId, e);
+            });
+          }
+          if (contigAfter2 !== contigBefore) this.saveSeqTrackerState();
+          return;
+        }
         const published = encryptedPush ? await client._publishEncryptedPushMessage("group.message_created", "group.message_undecryptable", ns, seq, msg, true) : await this.publishOrderedMessage("group.message_created", ns, seq, msg);
         const contigAfter = client._seqTracker.getContiguousSeq(ns);
         const needPull = seqNeedsPull && !published;
@@ -3749,6 +4162,11 @@ var MessageDeliveryEngine = class {
               if (pushed && s !== void 0 && s !== null && pushed.has(s)) {
                 continue;
               }
+              if (s !== void 0 && s !== null && this.recallEventFromGroupMessage(msg)) {
+                await this.publishGroupRecallTombstone(groupId, s, msg);
+                this.markPublishedSeq(ns, Number(s));
+                continue;
+              }
               if (s !== void 0 && s !== null) {
                 await client._publishPulledMessage("group.message_created", ns, s, msg);
               } else {
@@ -3774,7 +4192,7 @@ var MessageDeliveryEngine = class {
     const dedupKey = `p2p_pull:${ns}`;
     if (client._gapFillDone.has(dedupKey)) return;
     client._gapFillDone.add(dedupKey);
-    client._gapFillActive = true;
+    this.runtime.delivery.setGapFillActive(true);
     let filled = 0;
     try {
       const messages = await client._pullV2(afterSeq, 50);
@@ -3784,7 +4202,7 @@ var MessageDeliveryEngine = class {
       client._clientLog.warn(`P2P message gap-fill failed:${String(formatDeliveryError(exc))}`);
     } finally {
       client._gapFillDone.delete(dedupKey);
-      client._gapFillActive = false;
+      this.runtime.delivery.setGapFillActive(false);
       if (filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
         client._safeAsync(this.fillP2pGap());
       }
@@ -3800,7 +4218,7 @@ var MessageDeliveryEngine = class {
     const dedupKey = `group_pull:${ns}`;
     if (client._gapFillDone.has(dedupKey)) return;
     client._gapFillDone.add(dedupKey);
-    client._gapFillActive = true;
+    this.runtime.delivery.setGapFillActive(true);
     let filled = 0;
     try {
       const messages = await client._pullGroupV2(groupId, afterSeq, 50);
@@ -3810,7 +4228,7 @@ var MessageDeliveryEngine = class {
       client._clientLog.warn(`group message gap-fill failed:${String(exc)}`);
     } finally {
       client._gapFillDone.delete(dedupKey);
-      client._gapFillActive = false;
+      this.runtime.delivery.setGapFillActive(false);
       if (filled > 0 && client._seqTracker.getContiguousSeq(ns) > afterSeq) {
         client._safeAsync(this.fillGroupGap(groupId));
       }
@@ -3824,7 +4242,7 @@ var MessageDeliveryEngine = class {
     const dedupKey = `group_event_pull:${ns}`;
     if (client._gapFillDone.has(dedupKey)) return;
     client._gapFillDone.add(dedupKey);
-    client._gapFillActive = true;
+    this.runtime.delivery.setGapFillActive(true);
     try {
       let nextAfterSeq = afterSeq;
       const maxPages = 100;
@@ -3897,7 +4315,7 @@ var MessageDeliveryEngine = class {
       client._clientLog.warn(`group event gap-fill failed:${String(exc)}`);
     } finally {
       client._gapFillDone.delete(dedupKey);
-      client._gapFillActive = false;
+      this.runtime.delivery.setGapFillActive(false);
     }
   }
   handleGroupChangedEventSeq(data, groupId) {
@@ -3921,15 +4339,15 @@ var MessageDeliveryEngine = class {
     client._onlineUnreadHintQueue.set(groupId, { ...data });
     if (client._onlineUnreadHintTimer || client._onlineUnreadHintDrainActive) return;
     const delayMs = Math.max(0, Number(client._onlineUnreadHintInitialDelayMs ?? 750) || 0);
-    client._onlineUnreadHintTimer = setTimeout(() => {
-      client._onlineUnreadHintTimer = null;
+    this.runtime.delivery.setOnlineUnreadHintTimer(setTimeout(() => {
+      this.runtime.delivery.setOnlineUnreadHintTimer(null);
       client._safeAsync(this.drainOnlineUnreadHints());
-    }, delayMs);
+    }, delayMs));
   }
   async drainOnlineUnreadHints() {
     const client = this.runtime.client;
     if (client._onlineUnreadHintDrainActive) return;
-    client._onlineUnreadHintDrainActive = true;
+    this.runtime.delivery.setOnlineUnreadHintDrainActive(true);
     try {
       while (client._onlineUnreadHintQueue.size > 0) {
         if (client.state !== "ready") return;
@@ -3948,7 +4366,7 @@ var MessageDeliveryEngine = class {
     } catch (exc) {
       client._clientLog.debug(`online unread hint drain failed: ${formatDeliveryError(exc)}`);
     } finally {
-      client._onlineUnreadHintDrainActive = false;
+      this.runtime.delivery.setOnlineUnreadHintDrainActive(false);
     }
   }
   async onRawGroupV2MessageCreated(data) {
@@ -4079,15 +4497,15 @@ var MessageDeliveryEngine = class {
       );
     }
     if (client._v2PullInflight) {
-      client._v2PullPending = true;
+      this.runtime.delivery.setV2PullPending(true);
       return;
     }
-    client._v2PullInflight = true;
+    this.runtime.delivery.setV2PullInflight(true);
     const dedupKey = `p2p_pull:${ns}`;
     client._gapFillDone.add(dedupKey);
     try {
       do {
-        client._v2PullPending = false;
+        this.runtime.delivery.setV2PullPending(false);
         await client._pullV2();
         const newContig = ns ? client._seqTracker.getContiguousSeq(ns) : -1;
         client._clientLog.debug(
@@ -4100,7 +4518,7 @@ var MessageDeliveryEngine = class {
         `V2 push auto-pull failed: contiguous_seq=${contigBefore}->${newContig} err=${exc}`
       );
     } finally {
-      client._v2PullInflight = false;
+      this.runtime.delivery.setV2PullInflight(false);
       client._gapFillDone.delete(dedupKey);
     }
   }
@@ -4399,21 +4817,15 @@ var IdentityRuntimeManager = class {
       throw new StateError(`loadIdentity not allowed in state ${publicState}`);
     }
     client._applyAidRuntimeContext(aid);
-    client._currentAid = aid;
-    client._aid = aid.aid;
-    client._identity = {
+    this.runtime.identity.setLoadedIdentity(aid, {
       aid: aid.aid,
       private_key_pem: aid.privateKeyPem,
       public_key_der_b64: aid.publicKey,
       cert: aid.certPem
-    };
-    client._auth.setIdentity(client._identity);
-    client._state = "standby";
-    client._closing = false;
-    client._lastError = null;
-    client._lastErrorCode = null;
-    client._retryAttempt = 0;
-    client._nextRetryAt = null;
+    });
+    this.runtime.lifecycle.setState("standby");
+    this.runtime.lifecycle.setClosing(false);
+    this.runtime.lifecycle.clearRetryState();
   }
 };
 
@@ -4421,6 +4833,7 @@ var IdentityRuntimeManager = class {
 var PUBLIC_CONNECTION_OPTION_KEYS = /* @__PURE__ */ new Set([
   "auto_reconnect",
   "connect_timeout",
+  "retry",
   "retry_initial_delay",
   "retry_max_delay",
   "retry_max_attempts",
@@ -4494,27 +4907,25 @@ var LifecycleController = class {
     if ("aid" in options || "access_token" in options || "token" in options || "kite_token" in options) {
       throw new ValidationError("authenticate options must not include aid or token fields; load an AID object first");
     }
-    client._state = "connecting";
+    this.runtime.lifecycle.setState("connecting");
     try {
       const gateway = String(client._gatewayUrl ?? await client._resolveGatewayForAid(target)).trim();
       const result = await client._auth.authenticate(gateway, target);
-      client._gatewayUrl = gatewayFromAuthResult(result, gateway);
+      this.runtime.lifecycle.setGatewayUrl(gatewayFromAuthResult(result, gateway));
       let loadedIdentity = null;
       try {
         loadedIdentity = await client._auth.loadIdentityOrNone(target);
       } catch (exc) {
         client._clientLog.debug(`authenticate identity reload skipped: ${exc instanceof Error ? exc.message : String(exc)}`);
       }
-      client._identity = loadedIdentity ?? identityFromAuthResult(client, result, target);
-      client._state = "authenticated";
-      client._lastError = null;
-      client._lastErrorCode = null;
+      this.runtime.identity.setIdentity(loadedIdentity ?? identityFromAuthResult(client, result, target));
+      this.runtime.lifecycle.setState("authenticated");
+      this.runtime.lifecycle.setError(null, null);
       client._clientLog.debug(`authenticate exit: elapsed=${Date.now() - tStart}ms aid=${target}`);
       return result;
     } catch (err) {
-      client._state = "standby";
-      client._lastError = err instanceof Error ? err : new Error(String(err));
-      client._lastErrorCode = "AUTHENTICATE_FAILED";
+      this.runtime.lifecycle.setState("standby");
+      this.runtime.lifecycle.setError(err instanceof Error ? err : new Error(String(err)), "AUTHENTICATE_FAILED");
       client._clientLog.debug(`authenticate exit (error): elapsed=${Date.now() - tStart}ms err=${err instanceof Error ? err.message : String(err)}`);
       throw err;
     }
@@ -4542,11 +4953,14 @@ var LifecycleController = class {
         ...opts.call_timeout !== void 0 ? { call: opts.call_timeout } : {}
       };
     }
+    if (opts?.retry !== void 0) options.retry = opts.retry;
     if (opts?.retry_initial_delay !== void 0 || opts?.retry_max_delay !== void 0 || opts?.retry_max_attempts !== void 0) {
+      const baseRetry = isRecord(options.retry) ? { ...options.retry } : { initial_delay: 1, max_delay: 64, max_attempts: 0 };
       options.retry = {
-        initial_delay: opts.retry_initial_delay ?? 1,
-        max_delay: opts.retry_max_delay ?? 64,
-        max_attempts: opts.retry_max_attempts ?? 0
+        ...baseRetry,
+        ...opts.retry_initial_delay !== void 0 ? { initial_delay: opts.retry_initial_delay } : {},
+        ...opts.retry_max_delay !== void 0 ? { max_delay: opts.retry_max_delay } : {},
+        ...opts.retry_max_attempts !== void 0 ? { max_attempts: opts.retry_max_attempts } : {}
       };
     }
     if (opts?.connection_kind !== void 0) options.connection_kind = opts.connection_kind;
@@ -4568,28 +4982,25 @@ var LifecycleController = class {
     }
     if (publicState === "retry_backoff" /* RETRY_BACKOFF */ && client._reconnectAbort) {
       client._reconnectAbort.abort();
-      client._reconnectAbort = null;
-      client._reconnectActive = false;
+      this.runtime.lifecycle.clearReconnectState();
     }
     if (publicState === "connection_failed" /* CONNECTION_FAILED */) {
-      client._retryAttempt = 0;
-      client._lastError = null;
-      client._lastErrorCode = null;
+      this.runtime.lifecycle.setRetryAttempt(0);
+      this.runtime.lifecycle.setError(null, null);
     }
-    client._nextRetryAt = null;
+    this.runtime.lifecycle.setNextRetryAt(null);
     let authResult = null;
     if (!client._gatewayUrl) {
       authResult = await client.authenticate();
     }
-    client._state = "connecting";
+    this.runtime.lifecycle.setState("connecting");
     const gateway = String(client._gatewayUrl ?? "").trim();
     const accessToken = accessTokenFromAuthResult(authResult) || cachedAccessToken(client);
     const params = { ...options, gateway, ...accessToken ? { access_token: accessToken } : {} };
     const normalized = client._normalizeConnectParams(params);
-    client._sessionParams = normalized;
-    client._sessionOptions = client._buildSessionOptions(normalized);
+    this.runtime.lifecycle.setSession(normalized, client._buildSessionOptions(normalized));
     client._transport.setTimeout(client._sessionOptions.timeouts.call);
-    client._closing = false;
+    this.runtime.lifecycle.setClosing(false);
     const gateways = client._resolveGateways(normalized);
     let lastErr = null;
     for (const gw of gateways) {
@@ -4604,18 +5015,74 @@ var LifecycleController = class {
           client._clientLog.warn(`connect: gateway ${gw} failed, trying next: ${err instanceof Error ? err.message : String(err)}`);
         }
         if (client._state === "connecting" || client._state === "authenticating") {
-          client._state = "connecting";
+          this.runtime.lifecycle.setState("connecting");
         }
       }
     }
     if (client._state === "connecting" || client._state === "authenticating") {
-      client._state = client._currentAid || client._aid ? "standby" : "idle";
+      this.runtime.lifecycle.setState(client._currentAid || client._aid ? "standby" : "idle");
     }
-    client._lastError = lastErr instanceof Error ? lastErr : new Error(String(lastErr));
-    client._lastErrorCode = "CONNECT_FAILED";
+    this.runtime.lifecycle.setError(lastErr instanceof Error ? lastErr : new Error(String(lastErr)), "CONNECT_FAILED");
     client._clientLog.debug(`connect exit (error): elapsed=${Date.now() - tStart}ms err=${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
     throw lastErr;
   }
+  async disconnect() {
+    const client = this.runtime.client;
+    const tStart = Date.now();
+    client._clientLog.debug(`disconnect enter: state=${client._state}`);
+    if (client._closing) {
+      client._clientLog.debug(`disconnect exit: elapsed=${Date.now() - tStart}ms reason=closing`);
+      return;
+    }
+    if (![
+      "authenticated" /* AUTHENTICATED */,
+      "connecting" /* CONNECTING */,
+      "ready" /* READY */,
+      "retry_backoff" /* RETRY_BACKOFF */,
+      "reconnecting" /* RECONNECTING */,
+      "connection_failed" /* CONNECTION_FAILED */
+    ].includes(client.state)) {
+      client._clientLog.debug(`disconnect exit: elapsed=${Date.now() - tStart}ms reason=not_connected`);
+      return;
+    }
+    client._saveSeqTrackerState();
+    client._stopBackgroundTasks();
+    if (client._reconnectAbort) {
+      client._reconnectAbort.abort();
+      this.runtime.lifecycle.clearReconnectState();
+    }
+    await client._transport.close();
+    this.runtime.lifecycle.resetForDisconnect("standby");
+    await client._dispatcher.publish("state_change", { state: client._publicState(client._state) });
+    client._clientLog.debug(`disconnect exit: elapsed=${Date.now() - tStart}ms`);
+  }
+  async close() {
+    const client = this.runtime.client;
+    const tStart = Date.now();
+    client._clientLog.debug(`close enter: state=${client._state}`);
+    this.runtime.lifecycle.setClosing(true);
+    client._saveSeqTrackerState();
+    client._stopBackgroundTasks();
+    if (client._reconnectAbort) {
+      client._reconnectAbort.abort();
+      this.runtime.lifecycle.clearReconnectState();
+    }
+    if (client._state === "idle" || client._state === "closed") {
+      this.runtime.lifecycle.setState("closed");
+      client._resetSeqTrackingState();
+      client._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms reason=already_idle`);
+      return;
+    }
+    try {
+      await client._transport.call("auth.logout", {});
+    } catch {
+    }
+    await client._transport.close();
+    this.runtime.lifecycle.setState("closed");
+    await client._dispatcher.publish("state_change", { state: client._publicState(client._state) });
+    client._resetSeqTrackingState();
+    client._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms`);
+  }
 };
 
 // src/client/peers.ts
@@ -4720,56 +5187,214 @@ var SIGNED_METHODS = /* @__PURE__ */ new Set([
   "group.resume"
 ]);
 var PULL_GATE_STALE_MS = 3e4;
+var NON_IDEMPOTENT_TIMEOUT = 35;
+var NON_IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+  "message.send",
+  "group.send",
+  "group.create",
+  "group.invite",
+  "group.kick",
+  "group.remove_member",
+  "group.leave",
+  "group.dissolve",
+  "group.update_name",
+  "group.update_avatar",
+  "group.update_announcement",
+  "group.update_settings",
+  "storage.create_upload_session",
+  "storage.complete_upload",
+  "storage.delete_object",
+  "auth.create_aid",
+  "auth.renew_cert",
+  "auth.rekey",
+  "message.thought.put",
+  "group.thought.put",
+  "group.add_member"
+]);
 var RpcPipeline = class {
   constructor(runtime) {
     __publicField(this, "runtime");
     this.runtime = runtime;
   }
-  preflight(method, params) {
+  async call(method, params) {
     const client = this.runtime.client;
-    if (client._state !== "connected") {
-      throw new ConnectionError("client is not connected");
-    }
-    if (INTERNAL_ONLY_METHODS.has(method)) {
-      throw new PermissionError(`method is internal_only: ${method}`);
-    }
-    if (method.startsWith("message.e2ee.") || method.startsWith("group.e2ee.") || REMOVED_E2EE_METHODS.has(method)) {
-      throw new PermissionError(`legacy E2EE method is removed in this SDK: ${method}`);
-    }
-    const p = { ...params ?? {} };
-    this.mergeInstanceProtectedHeaders(method, p);
-    if (method === "message.send" || method === "group.send") {
-      this.normalizeOutboundMessagePayload(p, method);
+    const tStart = Date.now();
+    client._clientLog.debug(`call enter: method=${method}`);
+    try {
+      const result = await this.callImpl(method, params);
+      client._clientLog.debug(`call exit: elapsed=${Date.now() - tStart}ms method=${method}`);
+      return result;
+    } catch (err) {
+      client._clientLog.debug(`call exit (error): elapsed=${Date.now() - tStart}ms method=${method} err=${err instanceof Error ? err.message : String(err)}`);
+      throw err;
     }
-    this.validateOutboundCall(method, p);
-    this.injectMessageCursorContext(method, p);
-    this.captureGroupCursorParams(method, p);
-    this.normalizeGroupCallContext(method, p);
-    const clampedParams = typeof client._clampAckParams === "function" ? client._clampAckParams(method, p) : p;
-    return { params: clampedParams };
   }
-  mergeInstanceProtectedHeaders(method, params) {
+  async callImpl(method, params) {
     const client = this.runtime.client;
-    if (!client._instanceProtectedHeaders || !PROTECTED_HEADERS_METHODS.has(method)) {
-      return;
-    }
-    const existing = isJsonObject(params.protected_headers) ? params.protected_headers : {};
-    params.protected_headers = { ...client._instanceProtectedHeaders, ...existing };
-  }
-  normalizeOutboundMessagePayload(params, method = "") {
-    if (!Object.prototype.hasOwnProperty.call(params, "payload") && Object.prototype.hasOwnProperty.call(params, "content")) {
-      params.payload = params.content;
-      delete params.content;
-    }
-    const payload = params.payload;
-    if (isJsonObject(payload) && !Object.prototype.hasOwnProperty.call(payload, "type") && typeof payload.text === "string") {
-      params.payload = { type: "text", ...payload };
-    }
-  }
-  validateOutboundCall(method, params) {
+    const p = this.preflight(method, params).params;
     if (method === "message.send") {
-      this.validateMessageRecipient(params.to);
-      if ("persist" in params) {
+      const encrypt = p.encrypt !== void 0 ? p.encrypt : true;
+      delete p.encrypt;
+      if (encrypt) {
+        await client._ensureV2SessionReady(
+          "message.send",
+          "V2 session not initialized; encrypted message.send requires V2 (V1 E2EE removed)"
+        );
+        client._clientLog.debug("call route: message.send -> V2 encrypted send");
+        return await client._sendV2(String(p.to ?? ""), p.payload ?? {}, {
+          messageId: String(p.message_id ?? "") || void 0,
+          timestamp: p.timestamp,
+          protectedHeaders: client._protectedHeadersFromParams(p),
+          context: isJsonObject(p.context) ? p.context : void 0
+        });
+      }
+      client._maybeAppendEchoTraceSend(p);
+    }
+    if (method === "group.send") {
+      const encrypt = p.encrypt !== void 0 ? p.encrypt : true;
+      delete p.encrypt;
+      if (encrypt) {
+        await client._ensureV2SessionReady(
+          "group.send",
+          "V2 session not initialized; encrypted group.send requires V2 (V1 E2EE removed)"
+        );
+        client._clientLog.debug("call route: group.send -> V2 encrypted send");
+        return await client._sendGroupV2(String(p.group_id ?? ""), p.payload ?? {}, {
+          messageId: String(p.message_id ?? "") || void 0,
+          timestamp: p.timestamp,
+          protectedHeaders: client._protectedHeadersFromParams(p),
+          context: isJsonObject(p.context) ? p.context : void 0
+        });
+      }
+      client._maybeAppendEchoTraceSend(p);
+    }
+    if (method === "group.thought.put") {
+      const encrypt = p.encrypt !== void 0 ? p.encrypt : true;
+      delete p.encrypt;
+      if (encrypt) {
+        await client._ensureV2SessionReady(
+          "group.thought.put",
+          "V2 session not initialized; encrypted group.thought.put requires V2 (V1 E2EE removed)"
+        );
+        client._clientLog.debug("call route: group.thought.put -> V2 encrypted put");
+        return await client._putGroupThoughtEncryptedV2(p);
+      }
+    }
+    if (method === "message.thought.put") {
+      const encrypt = p.encrypt !== void 0 ? p.encrypt : true;
+      delete p.encrypt;
+      if (encrypt) {
+        await client._ensureV2SessionReady(
+          "message.thought.put",
+          "V2 session not initialized; encrypted message.thought.put requires V2 (V1 E2EE removed)"
+        );
+        client._clientLog.debug("call route: message.thought.put -> V2 encrypted put");
+        return await client._putMessageThoughtEncryptedV2(p);
+      }
+    }
+    const pullGateKey = this.pullGateKeyForCall(method, p);
+    if (pullGateKey) {
+      return await this.runPullSerialized(pullGateKey, async () => {
+        return await this.callImplInner(method, p);
+      });
+    }
+    return await this.callImplInner(method, p);
+  }
+  async callImplInner(method, p) {
+    const client = this.runtime.client;
+    if (method === "message.pull") {
+      await client._ensureV2SessionReady("message.pull");
+      client._clientLog.debug("call route: message.pull -> V2 pull");
+      const messages = await client._pullV2(Number(p.after_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, { force: p.force === true });
+      return { messages };
+    }
+    if (method === "message.ack") {
+      await client._ensureV2SessionReady("message.ack");
+      client._clientLog.debug("call route: message.ack -> V2 ack");
+      return await client._ackV2(Number(p.seq ?? p.up_to_seq ?? 0) || void 0);
+    }
+    if (method === "group.pull" && p.group_id) {
+      await client._ensureV2SessionReady("group.pull");
+      client._clientLog.debug("call route: group.pull -> V2 pull");
+      const hasExplicitAfterSeq = "after_seq" in p || "after_message_seq" in p;
+      const cursorParams = client._explicitGroupCursorParams(p);
+      const ownsCursor = Object.keys(cursorParams).length === 0 || client._groupCursorTargetsCurrentInstance(cursorParams);
+      const pullOpts = {};
+      if (hasExplicitAfterSeq) pullOpts.explicitAfterSeq = true;
+      if (Object.keys(cursorParams).length > 0) pullOpts.cursorParams = cursorParams;
+      if (!ownsCursor) pullOpts.ownsCursor = false;
+      const messages = await client._pullGroupV2(
+        String(p.group_id),
+        Number(p.after_seq ?? p.after_message_seq ?? 0) || 0,
+        Number(p.limit ?? 50) || 50,
+        Object.keys(pullOpts).length > 0 ? pullOpts : void 0
+      );
+      return { messages };
+    }
+    if (method === "group.ack_messages" && p.group_id) {
+      await client._ensureV2SessionReady("group.ack_messages");
+      client._clientLog.debug("call route: group.ack_messages -> V2 ack");
+      const cursorParams = client._explicitGroupCursorParams(p);
+      const ownsCursor = Object.keys(cursorParams).length === 0 || client._groupCursorTargetsCurrentInstance(cursorParams);
+      if (!ownsCursor) {
+        return await client._rawGroupAckMessages(p);
+      }
+      return await client._ackGroupV2(
+        String(p.group_id),
+        Number(p.seq ?? p.msg_seq ?? p.up_to_seq ?? 0) || void 0
+      );
+    }
+    await this.applyClientSignature(method, p);
+    const callTimeout = NON_IDEMPOTENT_METHODS.has(method) ? NON_IDEMPOTENT_TIMEOUT : void 0;
+    let result = callTimeout ? await client._transport.call(method, p, callTimeout) : await client._transport.call(method, p);
+    result = await this.postprocessResult(method, p, result);
+    return result;
+  }
+  preflight(method, params) {
+    const client = this.runtime.client;
+    if (client._state !== "connected") {
+      throw new ConnectionError("client is not connected");
+    }
+    if (INTERNAL_ONLY_METHODS.has(method)) {
+      throw new PermissionError(`method is internal_only: ${method}`);
+    }
+    if (method.startsWith("message.e2ee.") || method.startsWith("group.e2ee.") || REMOVED_E2EE_METHODS.has(method)) {
+      throw new PermissionError(`legacy E2EE method is removed in this SDK: ${method}`);
+    }
+    const p = { ...params ?? {} };
+    this.mergeInstanceProtectedHeaders(method, p);
+    if (method === "message.send" || method === "group.send") {
+      this.normalizeOutboundMessagePayload(p, method);
+    }
+    this.validateOutboundCall(method, p);
+    this.injectMessageCursorContext(method, p);
+    this.captureGroupCursorParams(method, p);
+    this.normalizeGroupCallContext(method, p);
+    const clampedParams = typeof client._clampAckParams === "function" ? client._clampAckParams(method, p) : p;
+    return { params: clampedParams };
+  }
+  mergeInstanceProtectedHeaders(method, params) {
+    const client = this.runtime.client;
+    if (!client._instanceProtectedHeaders || !PROTECTED_HEADERS_METHODS.has(method)) {
+      return;
+    }
+    const existing = isJsonObject(params.protected_headers) ? params.protected_headers : {};
+    params.protected_headers = { ...client._instanceProtectedHeaders, ...existing };
+  }
+  normalizeOutboundMessagePayload(params, method = "") {
+    if (!Object.prototype.hasOwnProperty.call(params, "payload") && Object.prototype.hasOwnProperty.call(params, "content")) {
+      params.payload = params.content;
+      delete params.content;
+    }
+    const payload = params.payload;
+    if (isJsonObject(payload) && !Object.prototype.hasOwnProperty.call(payload, "type") && typeof payload.text === "string") {
+      params.payload = { type: "text", ...payload };
+    }
+  }
+  validateOutboundCall(method, params) {
+    if (method === "message.send") {
+      this.validateMessageRecipient(params.to);
+      if ("persist" in params) {
         throw new ValidationError("message.send no longer accepts 'persist'; configure delivery_mode during connect");
       }
       if ("delivery_mode" in params || "queue_routing" in params || "affinity_ttl_ms" in params) {
@@ -9478,7 +10103,7 @@ var V2E2EECoordinator = class {
   get bootstrapCache() {
     const client = this.client;
     if (!(client._v2BootstrapCache instanceof Map)) {
-      client._v2BootstrapCache = /* @__PURE__ */ new Map();
+      this.runtime.v2.setBootstrapCache(/* @__PURE__ */ new Map());
     }
     return client._v2BootstrapCache;
   }
@@ -9581,18 +10206,14 @@ var V2E2EECoordinator = class {
       if (openedKeyStore) keyStore.close();
       return;
     }
-    client._v2KeyStore = keyStore;
-    client._v2Session = session;
+    this.runtime.v2.setSessionState(keyStore, session);
     client._clientLog.debug(`V2 session initialized aid=${aidAtStart} device=${deviceIdAtStart}`);
   }
   scheduleGroupSpkRegistration(groupId, opts) {
     const client = this.client;
     const gid = String(groupId ?? "").trim();
     if (!gid || !client._v2Session) return;
-    if (!(client._groupSpkRegistrationInflight instanceof Set)) {
-      client._groupSpkRegistrationInflight = /* @__PURE__ */ new Set();
-    }
-    const inflight = client._groupSpkRegistrationInflight;
+    const inflight = this.runtime.v2.groupSpkRegistrationInflight;
     if (inflight.has(gid)) return;
     inflight.add(gid);
     client._safeAsync((async () => {
@@ -9610,10 +10231,7 @@ var V2E2EECoordinator = class {
     const client = this.client;
     const gid = String(groupId ?? "").trim();
     if (!gid || !client._v2Session) return;
-    if (!(client._groupSpkRotationInflight instanceof Set)) {
-      client._groupSpkRotationInflight = /* @__PURE__ */ new Set();
-    }
-    const inflight = client._groupSpkRotationInflight;
+    const inflight = this.runtime.v2.groupSpkRotationInflight;
     if (inflight.has(gid)) return;
     inflight.add(gid);
     client._safeAsync((async () => {
@@ -9631,10 +10249,7 @@ var V2E2EECoordinator = class {
     const client = this.client;
     const gid = String(groupId ?? "").trim();
     if (!gid) return;
-    if (!(client._groupSpkPeerFallbackRegistered instanceof Set)) {
-      client._groupSpkPeerFallbackRegistered = /* @__PURE__ */ new Set();
-    }
-    const registered = client._groupSpkPeerFallbackRegistered;
+    const registered = this.runtime.v2.groupSpkPeerFallbackRegistered;
     if (registered.has(gid)) return;
     registered.add(gid);
     this.scheduleGroupSpkRegistration(gid, { reason: "peer_device_prekey_fallback" });
@@ -9830,6 +10445,7 @@ var V2E2EECoordinator = class {
               payload: legacyPayload,
               encrypted: false
             };
+            attachGatewayProximity(v1Msg, msg);
             const appEvent = client._delivery.p2pAppEventForMessage(v1Msg);
             if (ns) await client._publishPulledMessage(appEvent.event, ns, seq, appEvent.payload);
             else await client._publishAppEvent(appEvent.event, appEvent.payload);
@@ -10008,6 +10624,12 @@ var V2E2EECoordinator = class {
         if (version === "v1") {
           const payload = msg.payload;
           const payloadObj = isJsonObject(payload) ? payload : null;
+          if (client._delivery.recallEventFromGroupMessage(msg)) {
+            await client._delivery.publishGroupRecallTombstone(gid, seq, msg);
+            client._markPublishedSeq(ns, seq);
+            client._clientLog.debug(`group.v2.pull recall tombstone delivered: group=${gid}, seq=${seq}`);
+            continue;
+          }
           if (payloadObj) {
             const payloadType = String(payloadObj.type ?? "").trim();
             if (payloadType !== "e2ee.encrypted" && payloadType !== "e2ee.group_encrypted") {
@@ -10021,6 +10643,7 @@ var V2E2EECoordinator = class {
                 payload,
                 encrypted: false
               };
+              attachGatewayProximity(v1Msg, msg);
               await client._publishPulledMessage("group.message_created", ns, seq, v1Msg);
               decrypted.push(v1Msg);
               continue;
@@ -10036,6 +10659,7 @@ var V2E2EECoordinator = class {
               payload,
               encrypted: false
             };
+            attachGatewayProximity(v1Msg, msg);
             await client._publishPulledMessage("group.message_created", ns, seq, v1Msg);
             decrypted.push(v1Msg);
             continue;
@@ -11023,12 +11647,10 @@ var GroupStateCoordinator = class {
     const gid = normalizedGroupId(groupId);
     if (!gid) return;
     const level = String(bootstrap.e2ee_security_level ?? "").trim() || "end_to_end";
-    if (!(client._v2GroupSecurityLevels instanceof Map)) {
-      client._v2GroupSecurityLevels = /* @__PURE__ */ new Map();
-    }
-    const previous = client._v2GroupSecurityLevels.get(gid);
+    const securityLevels = this.runtime.groupState.securityLevels;
+    const previous = securityLevels.get(gid);
     if (previous === level) return;
-    client._v2GroupSecurityLevels.set(gid, level);
+    securityLevels.set(gid, level);
     await client._dispatcher.publish("group.v2.security_level", {
       group_id: gid,
       level,
@@ -11068,11 +11690,9 @@ var GroupStateCoordinator = class {
       );
       const cacheHash = new Uint8Array(await crypto.subtle.digest("SHA-256", cacheInput));
       const cacheKey = bytesToHex6(cacheHash);
-      if (!(client._v2SigCache instanceof Map)) {
-        client._v2SigCache = /* @__PURE__ */ new Map();
-      }
+      const sigCache = this.runtime.groupState.sigCache;
       const now = Date.now();
-      const cachedExp = client._v2SigCache.get(cacheKey);
+      const cachedExp = sigCache.get(cacheKey);
       if (cachedExp !== void 0 && cachedExp > now) {
         client._clientLog.debug(`V2 state signature cache hit: group=${gid} sv=${stateVersion}`);
       } else {
@@ -11087,7 +11707,7 @@ var GroupStateCoordinator = class {
           client._clientLog.warn(`V2 state signature verification FAILED: group=${gid} sv=${stateVersion} actor=${actorAid}`);
           throw new E2EEError("V2 state signature verification failed");
         }
-        client._v2SigCache.set(cacheKey, now + V2_SIG_CACHE_TTL_MS);
+        sigCache.set(cacheKey, now + V2_SIG_CACHE_TTL_MS);
         this.pruneSigCache(now);
         client._clientLog.debug(`V2 state signature verified: group=${gid} sv=${stateVersion} actor=${actorAid}`);
       }
@@ -11103,12 +11723,10 @@ var GroupStateCoordinator = class {
     const gid = normalizedGroupId(groupId);
     if (!gid || !serverChain) return;
     try {
-      if (!(client._v2StateChains instanceof Map)) {
-        client._v2StateChains = /* @__PURE__ */ new Map();
-      }
-      const local = client._v2StateChains.get(gid);
+      const stateChains = this.runtime.groupState.chains;
+      const local = stateChains.get(gid);
       if (local === void 0) {
-        client._v2StateChains.set(gid, [0, serverChain]);
+        stateChains.set(gid, [0, serverChain]);
         return;
       }
       const [localSv, localChain] = local;
@@ -11118,7 +11736,7 @@ var GroupStateCoordinator = class {
         if (stateResp) {
           const serverSv = Number(stateResp.state_version ?? 0);
           if (serverSv > localSv) {
-            client._v2StateChains.set(gid, [serverSv, serverChain]);
+            stateChains.set(gid, [serverSv, serverChain]);
             return;
           }
           if (serverSv < localSv) {
@@ -11141,13 +11759,11 @@ var GroupStateCoordinator = class {
     const client = this.client;
     const gid = normalizedGroupId(groupId);
     if (!gid) return;
-    if (!(client._v2LazyProposeTriggered instanceof Map)) {
-      client._v2LazyProposeTriggered = /* @__PURE__ */ new Map();
-    }
+    const lazyProposeTriggered = this.runtime.groupState.lazyProposeTriggered;
     const now = Date.now();
-    const last = client._v2LazyProposeTriggered.get(gid) ?? 0;
+    const last = lazyProposeTriggered.get(gid) ?? 0;
     if (now - last < 1e4) return;
-    client._v2LazyProposeTriggered.set(gid, now);
+    lazyProposeTriggered.set(gid, now);
     client._safeAsync(client._v2AutoProposeState(gid, { leaderDelay: true }));
   }
   async onGroupStateCommitted(data) {
@@ -14221,6 +14837,7 @@ var DEFAULT_SESSION_OPTIONS = {
 var RECONNECT_MIN_BASE_DELAY_SECONDS = 1;
 var RECONNECT_MAX_BASE_DELAY_SECONDS = 64;
 var TOKEN_REFRESH_CHECK_INTERVAL_MS = 3e4;
+var MAX_NOTIFY_PAYLOAD_SIZE = 64 * 1024;
 var HEARTBEAT_MIN_INTERVAL_SECONDS = 10;
 var HEARTBEAT_MAX_INTERVAL_SECONDS = 600;
 function clampHeartbeatInterval(value) {
@@ -14230,30 +14847,6 @@ function clampHeartbeatInterval(value) {
   if (n > HEARTBEAT_MAX_INTERVAL_SECONDS) return HEARTBEAT_MAX_INTERVAL_SECONDS;
   return n;
 }
-var NON_IDEMPOTENT_TIMEOUT = 35;
-var NON_IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
-  "message.send",
-  "group.send",
-  "group.create",
-  "group.invite",
-  "group.kick",
-  "group.remove_member",
-  "group.leave",
-  "group.dissolve",
-  "group.update_name",
-  "group.update_avatar",
-  "group.update_announcement",
-  "group.update_settings",
-  "storage.upload",
-  "storage.complete_upload",
-  "storage.delete",
-  "auth.create_aid",
-  "auth.renew_cert",
-  "auth.rekey",
-  "message.thought.put",
-  "group.thought.put",
-  "group.add_member"
-]);
 function clampReconnectDelaySeconds(value, fallback, upper = RECONNECT_MAX_BASE_DELAY_SECONDS) {
   const parsed = Number(value);
   const seconds = Number.isFinite(parsed) ? parsed : fallback;
@@ -14574,6 +15167,8 @@ var _AUNClient = class _AUNClient {
     __publicField(this, "_pendingOrderedMsgs", /* @__PURE__ */ new Map());
     /** Lazy group sync：首次发送群消息前自动拉取历史 */
     __publicField(this, "_groupSynced", /* @__PURE__ */ new Set());
+    /** 群撤回去重：group_id|sorted(message_ids)|recalled_at -> 时间戳，保证应用层只回调一次 */
+    __publicField(this, "_groupRecallSeen", /* @__PURE__ */ new Map());
     /** 在线未读 hint 队列：同一 group 只保留最后一条，延迟 drain 降低登录瞬时拉取压力。 */
     __publicField(this, "_onlineUnreadHintQueue", /* @__PURE__ */ new Map());
     __publicField(this, "_onlineUnreadHintTimer", null);
@@ -14730,6 +15325,9 @@ var _AUNClient = class _AUNClient {
     this._dispatcher.subscribe("_raw.group.message_created", (data) => {
       this._onRawGroupMessageCreated(data);
     });
+    this._dispatcher.subscribe("_raw.group.message_recalled", (data) => {
+      this._safeAsync(this._onRawGroupMessageRecalled(data));
+    });
     this._dispatcher.subscribe("_raw.group.changed", (data) => {
       this._onRawGroupChanged(data);
     });
@@ -15002,62 +15600,11 @@ var _AUNClient = class _AUNClient {
   }
   /** 断开连接但保留本地状态，可再次 connect */
   async disconnect() {
-    const tStart = Date.now();
-    this._clientLog.debug(`disconnect enter: state=${this._state}`);
-    if (this._closing) {
-      this._clientLog.debug(`disconnect exit: elapsed=${Date.now() - tStart}ms reason=closing`);
-      return;
-    }
-    if (![
-      "authenticated" /* AUTHENTICATED */,
-      "connecting" /* CONNECTING */,
-      "ready" /* READY */,
-      "retry_backoff" /* RETRY_BACKOFF */,
-      "reconnecting" /* RECONNECTING */,
-      "connection_failed" /* CONNECTION_FAILED */
-    ].includes(this.state)) {
-      this._clientLog.debug(`disconnect exit: elapsed=${Date.now() - tStart}ms reason=not_connected`);
-      return;
-    }
-    this._saveSeqTrackerState();
-    this._stopBackgroundTasks();
-    if (this._reconnectAbort) {
-      this._reconnectAbort.abort();
-      this._reconnectAbort = null;
-      this._reconnectActive = false;
-    }
-    await this._transport.close();
-    this._state = "standby";
-    await this._dispatcher.publish("state_change", { state: this._publicState(this._state) });
-    this._clientLog.debug(`disconnect exit: elapsed=${Date.now() - tStart}ms`);
+    return this._lifecycle.disconnect();
   }
   /** 关闭连接 */
   async close() {
-    const tStart = Date.now();
-    this._clientLog.debug(`close enter: state=${this._state}`);
-    this._closing = true;
-    this._saveSeqTrackerState();
-    this._stopBackgroundTasks();
-    if (this._reconnectAbort) {
-      this._reconnectAbort.abort();
-      this._reconnectAbort = null;
-      this._reconnectActive = false;
-    }
-    if (this._state === "idle" || this._state === "closed") {
-      this._state = "closed";
-      this._resetSeqTrackingState();
-      this._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms reason=already_idle`);
-      return;
-    }
-    try {
-      await this._transport.call("auth.logout", {});
-    } catch {
-    }
-    await this._transport.close();
-    this._state = "closed";
-    await this._dispatcher.publish("state_change", { state: this._publicState(this._state) });
-    this._resetSeqTrackingState();
-    this._clientLog.debug(`close exit: elapsed=${Date.now() - tStart}ms`);
+    return this._lifecycle.close();
   }
   // ── RPC ───────────────────────────────────────────
   /**
@@ -15067,151 +15614,98 @@ var _AUNClient = class _AUNClient {
    * 自动解密 message.pull/group.pull、Group E2EE 生命周期编排。
    */
   async call(method, params) {
-    const tStart = Date.now();
-    this._clientLog.debug(`call enter: method=${method}`);
-    try {
-      const result = await this._callImpl(method, params);
-      this._clientLog.debug(`call exit: elapsed=${Date.now() - tStart}ms method=${method}`);
-      return result;
-    } catch (err) {
-      this._clientLog.debug(`call exit (error): elapsed=${Date.now() - tStart}ms method=${method} err=${err instanceof Error ? err.message : String(err)}`);
-      throw err;
+    return await this._rpcPipeline.call(method, params);
+  }
+  static _notifyParamsSizeOk(params) {
+    return new TextEncoder().encode(JSON.stringify(params)).length <= MAX_NOTIFY_PAYLOAD_SIZE;
+  }
+  static _validateNotifyEventMethod(method) {
+    const normalized = String(method ?? "").trim();
+    if (!normalized.startsWith("event/app.") || normalized.length <= "event/app.".length) {
+      throw new ValidationError("routed notify method must be event/app.*");
     }
+    return normalized;
   }
-  async _callImpl(method, params) {
-    const p = this._rpcPipeline.preflight(method, params).params;
-    if (method === "message.send") {
-      const encrypt = p.encrypt !== void 0 ? p.encrypt : true;
-      delete p.encrypt;
-      if (encrypt) {
-        await this._ensureV2SessionReady(
-          "message.send",
-          "V2 session not initialized; encrypted message.send requires V2 (V1 E2EE removed)"
-        );
-        this._clientLog.debug("call route: message.send \u2192 V2 encrypted send");
-        return await this._sendV2(String(p.to ?? ""), p.payload ?? {}, {
-          messageId: String(p.message_id ?? "") || void 0,
-          timestamp: p.timestamp,
-          protectedHeaders: this._protectedHeadersFromParams(p),
-          context: isJsonObject(p.context) ? p.context : void 0
-        });
-      }
-      this._maybeAppendEchoTraceSend(p);
+  static _normalizeNotifyTtl(value) {
+    if (value === void 0 || value === null) return void 0;
+    const ttl = Number(value);
+    if (!Number.isInteger(ttl)) {
+      throw new ValidationError("ttl_ms must be an integer");
     }
-    if (method === "group.send") {
-      const encrypt = p.encrypt !== void 0 ? p.encrypt : true;
-      delete p.encrypt;
-      if (encrypt) {
-        await this._ensureV2SessionReady(
-          "group.send",
-          "V2 session not initialized; encrypted group.send requires V2 (V1 E2EE removed)"
-        );
-        this._clientLog.debug("call route: group.send \u2192 V2 encrypted send");
-        return await this._sendGroupV2(String(p.group_id ?? ""), p.payload ?? {}, {
-          messageId: String(p.message_id ?? "") || void 0,
-          timestamp: p.timestamp,
-          protectedHeaders: this._protectedHeadersFromParams(p),
-          context: isJsonObject(p.context) ? p.context : void 0
-        });
-      }
-      this._maybeAppendEchoTraceSend(p);
+    if (ttl < 0 || ttl > 6e4) {
+      throw new ValidationError("ttl_ms must be between 0 and 60000");
     }
-    if (method === "group.thought.put") {
-      const encrypt = p.encrypt !== void 0 ? p.encrypt : true;
-      delete p.encrypt;
-      if (encrypt) {
-        await this._ensureV2SessionReady(
-          "group.thought.put",
-          "V2 session not initialized; encrypted group.thought.put requires V2 (V1 E2EE removed)"
-        );
-        this._clientLog.debug("call route: group.thought.put \u2192 V2 encrypted put");
-        return this._putGroupThoughtEncryptedV2(p);
-      }
+    return ttl;
+  }
+  /**
+   * 发送轻量在线通知，不走离线存储、seq/pull 或 ack。
+   */
+  async notify(method, params, options = {}) {
+    if (params !== void 0 && params !== null && !isJsonObject(params)) {
+      throw new ValidationError("notify params must be an object");
     }
-    if (method === "message.thought.put") {
-      const encrypt = p.encrypt !== void 0 ? p.encrypt : true;
-      delete p.encrypt;
-      if (encrypt) {
-        await this._ensureV2SessionReady(
-          "message.thought.put",
-          "V2 session not initialized; encrypted message.thought.put requires V2 (V1 E2EE removed)"
-        );
-        this._clientLog.debug("call route: message.thought.put \u2192 V2 encrypted put");
-        return this._putMessageThoughtEncryptedV2(p);
+    const payload = { ...params ?? {} };
+    if (!_AUNClient._notifyParamsSizeOk(payload)) {
+      throw new ValidationError("notify payload is too large");
+    }
+    const targetAid = String(options.to ?? "").trim();
+    const targetGroupId = String(options.group_id ?? options.groupId ?? "").trim();
+    const targetDeviceId = String(options.device_id ?? options.deviceId ?? "").trim();
+    const targetSlotId = String(options.slot_id ?? options.slotId ?? "").trim();
+    const ttl = _AUNClient._normalizeNotifyTtl(options.ttl_ms ?? options.ttlMs);
+    if (targetAid && targetGroupId) {
+      throw new ValidationError("notify() cannot set both to and group_id");
+    }
+    if (targetSlotId && !targetDeviceId) {
+      throw new ValidationError("slot_id requires device_id for notify target");
+    }
+    if (targetAid) {
+      const eventMethod = _AUNClient._validateNotifyEventMethod(method);
+      const target = { type: "aid", aid: targetAid };
+      if (targetDeviceId) target.device_id = targetDeviceId;
+      if (targetSlotId) target.slot_id = targetSlotId;
+      const routeParams = {
+        target,
+        deliver: { method: eventMethod, params: payload }
+      };
+      if (ttl !== void 0) routeParams.ttl_ms = ttl;
+      await this._transport.notify("notification/route", routeParams);
+      return;
+    }
+    if (targetGroupId) {
+      const eventMethod = _AUNClient._validateNotifyEventMethod(method);
+      const normalizedGroupId2 = normalizeGroupId(targetGroupId);
+      if (!normalizedGroupId2) {
+        throw new ValidationError("group_id is required for group notify");
       }
+      const routeParams = {
+        group_id: normalizedGroupId2,
+        deliver: { method: eventMethod, params: payload }
+      };
+      if (ttl !== void 0) routeParams.ttl_ms = ttl;
+      await this._transport.notify("notification/group.route", routeParams);
+      return;
     }
-    const pullGateKey = this._pullGateKeyForCall(method, p);
-    if (pullGateKey) {
-      return await this._runPullSerialized(pullGateKey, async () => {
-        return await this._callImplInner(method, p);
-      });
+    if (targetDeviceId || targetSlotId) {
+      throw new ValidationError("device_id and slot_id require to");
     }
-    return await this._callImplInner(method, p);
+    const directMethod = String(method ?? "").trim();
+    if (!directMethod.startsWith("notification/")) {
+      throw new ValidationError("direct notify method must start with notification/");
+    }
+    await this._transport.notify(directMethod, payload);
   }
-  /**
-   * _callImpl 的内层：pull gate 之后的实际 RPC 分发逻辑。
-   * 拆分出来以便 pull gate 包裹整个操作。
-   */
-  async _callImplInner(method, p) {
-    if (method === "message.pull") {
-      await this._ensureV2SessionReady("message.pull");
-      this._clientLog.debug("call route: message.pull \u2192 V2 pull");
-      const messages = await this._pullV2(Number(p.after_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, { force: p.force === true });
-      return { messages };
+  async _callRawV2Rpc(method, params) {
+    const p = { ...params ?? {} };
+    delete p._pull_gate_locked;
+    delete p._skip_auto_ack;
+    delete p.skip_auto_ack;
+    delete p._group_cursor_params;
+    if (method.startsWith("group.") && p.group_id !== void 0 && p.group_id !== null) {
+      p.group_id = normalizeGroupId(String(p.group_id)) || String(p.group_id);
     }
-    if (method === "message.ack") {
-      await this._ensureV2SessionReady("message.ack");
-      this._clientLog.debug("call route: message.ack \u2192 V2 ack");
-      return await this._ackV2(Number(p.seq ?? p.up_to_seq ?? 0) || void 0);
-    }
-    if (method === "group.pull" && p.group_id) {
-      await this._ensureV2SessionReady("group.pull");
-      this._clientLog.debug("call route: group.pull \u2192 V2 pull");
-      const hasExplicitAfterSeq = "after_seq" in p || "after_message_seq" in p;
-      const cursorParams = this._explicitGroupCursorParams(p);
-      const ownsCursor = Object.keys(cursorParams).length === 0 || this._groupCursorTargetsCurrentInstance(cursorParams);
-      const pullOpts = {};
-      if (hasExplicitAfterSeq) pullOpts.explicitAfterSeq = true;
-      if (Object.keys(cursorParams).length > 0) pullOpts.cursorParams = cursorParams;
-      if (!ownsCursor) pullOpts.ownsCursor = false;
-      const messages = await this._pullGroupV2(
-        String(p.group_id),
-        Number(p.after_seq ?? p.after_message_seq ?? 0) || 0,
-        Number(p.limit ?? 50) || 50,
-        Object.keys(pullOpts).length > 0 ? pullOpts : void 0
-      );
-      return { messages };
-    }
-    if (method === "group.ack_messages" && p.group_id) {
-      await this._ensureV2SessionReady("group.ack_messages");
-      this._clientLog.debug("call route: group.ack_messages \u2192 V2 ack");
-      const cursorParams = this._explicitGroupCursorParams(p);
-      const ownsCursor = Object.keys(cursorParams).length === 0 || this._groupCursorTargetsCurrentInstance(cursorParams);
-      if (!ownsCursor) {
-        return await this._rawGroupAckMessages(p);
-      }
-      return await this._ackGroupV2(
-        String(p.group_id),
-        Number(p.seq ?? p.msg_seq ?? p.up_to_seq ?? 0) || void 0
-      );
-    }
-    await this._rpcPipeline.applyClientSignature(method, p);
-    const callTimeout = NON_IDEMPOTENT_METHODS.has(method) ? NON_IDEMPOTENT_TIMEOUT : void 0;
-    let result = callTimeout ? await this._transport.call(method, p, callTimeout) : await this._transport.call(method, p);
-    result = await this._rpcPipeline.postprocessResult(method, p, result);
-    return result;
-  }
-  async _callRawV2Rpc(method, params) {
-    const p = { ...params ?? {} };
-    delete p._pull_gate_locked;
-    delete p._skip_auto_ack;
-    delete p.skip_auto_ack;
-    delete p._group_cursor_params;
-    if (method.startsWith("group.") && p.group_id !== void 0 && p.group_id !== null) {
-      p.group_id = normalizeGroupId(String(p.group_id)) || String(p.group_id);
-    }
-    if (method.startsWith("group.") && p.device_id === void 0) {
-      p.device_id = this._deviceId;
+    if (method.startsWith("group.") && p.device_id === void 0) {
+      p.device_id = this._deviceId;
     }
     if (method.startsWith("group.") && p.slot_id === void 0) {
       p.slot_id = this._slotId;
@@ -15243,55 +15737,30 @@ var _AUNClient = class _AUNClient {
   _onRawMessageReceived(data) {
     this._delivery.onRawMessageReceived(data);
   }
-  /** 实际处理推送消息的异步任务（V2-only：明文消息直接透传，V2 加密消息走 _onV2PushNotification） */
-  async _processAndPublishMessage(data) {
-    return this._delivery.processAndPublishMessage(data);
-  }
   /** 处理群组消息推送：re-publish（V2 加密消息走 V2 push 路径） */
   _onRawGroupMessageCreated(data) {
     return this._delivery.onRawGroupMessageCreated(data);
   }
+  async _onRawGroupMessageRecalled(data) {
+    return this._delivery.onRawGroupMessageRecalled(data);
+  }
   /** 处理 V2 群消息通知：主动 pull V2 envelope，由 pullGroupV2 解密并发布。 */
   async _onRawGroupV2MessageCreated(data) {
     return this._delivery.onRawGroupV2MessageCreated(data);
   }
-  /**
-   * 处理群组推送消息的异步任务（V2-only：明文消息直接透传）。
-   *
-   * 带 payload 的事件（消息推送）：直接 re-publish。
-   * 不带 payload 的事件（通知）：自动 pull 最新消息。
-   */
-  async _processAndPublishGroupMessage(data) {
-    return this._delivery.processAndPublishGroupMessage(data);
-  }
   async _publishEncryptedPushMessage(normalEvent, undecryptableEvent, ns, seq, msg, group) {
     return await this._v2E2EE.publishEncryptedPushMessage(normalEvent, undecryptableEvent, ns, seq, msg, group);
   }
   async _decryptV2PushMessage(data) {
     return await this._v2E2EE.decryptV2PushMessage(data);
   }
-  /** 后台补齐群消息空洞 */
-  async _fillGroupGap(groupId) {
-    return this._delivery.fillGroupGap(groupId);
-  }
-  /** 后台补齐群事件空洞 */
-  async _fillGroupEventGap(groupId) {
-    return this._delivery.fillGroupEventGap(groupId);
-  }
   /** 后台补齐 P2P 消息空洞 */
   async _fillP2pGap() {
     return this._delivery.fillP2pGap();
   }
-  /** 只按硬上限裁剪 published guard，不能按 contiguousSeq 清理。 */
-  _prunePushedSeqs(ns) {
-    this._delivery.prunePushedSeqs(ns);
-  }
   _markPublishedSeq(ns, seq) {
     this._delivery.markPublishedSeq(ns, seq);
   }
-  _attachCurrentInstanceContext(payload) {
-    return this._delivery.attachCurrentInstanceContext(payload);
-  }
   async _publishAppEvent(event, payload) {
     await this._delivery.publishAppEvent(event, payload);
   }
@@ -15328,9 +15797,6 @@ var _AUNClient = class _AUNClient {
     const trace = `${this._echoTimestamp()} [AUN-SDK.receive] aid=${this._aid ?? "-"} conn_uptime=${uptime}s`;
     msg.payload = { ...payload, text: payload.text + "\n" + trace };
   }
-  _messageTargetsCurrentInstance(message) {
-    return this._delivery.messageTargetsCurrentInstance(message);
-  }
   async _drainOrderedMessages(ns, beforeSeq) {
     await this._delivery.drainOrderedMessages(ns, beforeSeq);
   }
@@ -15474,59 +15940,6 @@ var _AUNClient = class _AUNClient {
     const digest = await crypto.subtle.digest("SHA-256", certBytes);
     return "sha256:" + Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
   }
-  /**
-   * 从 X.509 DER 证书中提取 SubjectPublicKeyInfo 并计算其 SHA-256 指纹。
-   * 返回 "sha256:<hex>"，提取失败返回空串。
-   * 用于 H7 指纹校验（DER 证书指纹 OR SPKI 指纹任一匹配）。
-   */
-  async _spkiFingerprint(certPem) {
-    try {
-      const der = new Uint8Array(pemToArrayBuffer(certPem));
-      const readLen = (buf, pos) => {
-        const first = buf[pos];
-        if (first < 128) return { len: first, next: pos + 1 };
-        const n = first & 127;
-        let len = 0;
-        for (let i = 0; i < n; i++) len = len << 8 | buf[pos + 1 + i];
-        return { len, next: pos + 1 + n };
-      };
-      if (der[0] !== 48) return "";
-      const outer = readLen(der, 1);
-      const tbsStart = outer.next;
-      if (der[tbsStart] !== 48) return "";
-      const tbsLen = readLen(der, tbsStart + 1);
-      let p = tbsLen.next;
-      const tbsEnd = tbsLen.next + tbsLen.len;
-      if (der[p] === 160) {
-        const lv2 = readLen(der, p + 1);
-        p = lv2.next + lv2.len;
-      }
-      if (der[p] !== 2) return "";
-      let lv = readLen(der, p + 1);
-      p = lv.next + lv.len;
-      if (der[p] !== 48) return "";
-      lv = readLen(der, p + 1);
-      p = lv.next + lv.len;
-      if (der[p] !== 48) return "";
-      lv = readLen(der, p + 1);
-      p = lv.next + lv.len;
-      if (der[p] !== 48) return "";
-      lv = readLen(der, p + 1);
-      p = lv.next + lv.len;
-      if (der[p] !== 48) return "";
-      lv = readLen(der, p + 1);
-      p = lv.next + lv.len;
-      if (der[p] !== 48 || p >= tbsEnd) return "";
-      const spkiStart = p;
-      const spkiLV = readLen(der, p + 1);
-      const spkiEnd = spkiLV.next + spkiLV.len;
-      const spkiDer = der.subarray(spkiStart, spkiEnd);
-      const digest = await crypto.subtle.digest("SHA-256", spkiDer);
-      return "sha256:" + Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
-    } catch {
-      return "";
-    }
-  }
   async _decryptGroupThoughts(result) {
     return await this._v2E2EE.decryptGroupThoughts(result);
   }
@@ -16030,12 +16443,6 @@ var _AUNClient = class _AUNClient {
   _validateMessageRecipient(toAid) {
     this._rpcPipeline.validateMessageRecipient(toAid);
   }
-  _validateOutboundCall(method, params) {
-    this._rpcPipeline.validateOutboundCall(method, params);
-  }
-  _injectMessageCursorContext(method, params) {
-    this._rpcPipeline.injectMessageCursorContext(method, params);
-  }
   /** 处理服务端主动断开通知 event/gateway.disconnect
    *
    * 服务端可能附带结构化 detail 字段（如配额超限时含 aid/device_id/slot_id/quota_kind/evicted_by）。
@@ -16276,7 +16683,7 @@ var _AUNClient = class _AUNClient {
     );
     return repaired;
   }
-  async _ensureV2SessionReady(method, errorMessage) {
+  async _ensureV2SessionReady(method, errorMessage2) {
     if (!this._v2SessionMatchesIdentity()) {
       if (!this._v2SessionInitInFlight) {
         this._v2SessionInitInFlight = this._initV2Session().finally(() => {
@@ -16286,7 +16693,7 @@ var _AUNClient = class _AUNClient {
       await this._v2SessionInitInFlight;
     }
     if (!this._v2SessionMatchesIdentity()) {
-      throw new StateError(errorMessage ?? `V2 session not initialized; encrypted ${method} requires E2EE V2`);
+      throw new StateError(errorMessage2 ?? `V2 session not initialized; encrypted ${method} requires E2EE V2`);
     }
   }
   _v2CallFn() {
@@ -16414,9 +16821,6 @@ var _AUNClient = class _AUNClient {
   _scheduleV2SenderIKPending(args) {
     return this._v2E2EE.scheduleSenderIKPending(args);
   }
-  async _resolveV2SenderIKPending(fromAid, senderDeviceId, groupId, fetchKey) {
-    return await this._v2E2EE.resolveSenderIKPending(fromAid, senderDeviceId, groupId, fetchKey);
-  }
   /**
    * V2 P2P 加密发送（推测性：用缓存 bootstrap 直接发，失败刷新重试一次）。
    *
@@ -16769,9 +17173,6 @@ var _AUNClient = class _AUNClient {
     return (!deviceId || deviceId === (this._deviceId ?? "")) && (!slotId || slotId === (this._slotId ?? ""));
   }
   // ── Pull Gate（序列化同一 key 的并发 pull）──────────────────
-  _pullGateKeyForCall(method, params) {
-    return this._rpcPipeline.pullGateKeyForCall(method, params);
-  }
   async _runPullSerialized(key, operation) {
     return await this._rpcPipeline.runPullSerialized(key, operation);
   }
@@ -18332,6 +18733,1176 @@ var AIDStore = class {
 // src/index.ts
 init_crypto();
 
+// src/service-proxy.ts
+var PROXY_DISCOVERY_CACHE_KEY = "service_proxy_discovery";
+var PROXY_DISCOVERY_CACHE_TTL_MS = 36e5;
+var TOKEN_EXPIRY_SKEW_SECONDS = 30;
+var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "upgrade",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding"
+]);
+var AUTO_RESPONSE_HEADERS = /* @__PURE__ */ new Set(["content-length", "date", "server"]);
+var ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "ws:", "wss:"]);
+var RESERVED_SERVICE_NAMES = /* @__PURE__ */ new Set([
+  "api",
+  "health",
+  "metrics",
+  "status",
+  "proxy",
+  "admin",
+  "ws",
+  "wss",
+  "static",
+  "favicon.ico"
+]);
+var SENSITIVE_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "endpoint",
+  "url",
+  "uri",
+  "token",
+  "access_token",
+  "authorization",
+  "cookie",
+  "secret",
+  "password",
+  "private_key",
+  "key",
+  "cert",
+  "certificate"
+]);
+var SERVICE_NAME_RE = /^[a-z0-9_-]+$/;
+var STREAMING_SERVICE_TYPES = /* @__PURE__ */ new Set(["mcp", "mcp-sse", "mcp-streamable-http", "sse", "stream", "file", "ws", "websocket"]);
+var VALID_STREAM_MODES = /* @__PURE__ */ new Set(["auto", "stream", "always", "no_stream"]);
+var FILE_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "application/octet-stream",
+  "application/pdf",
+  "application/zip",
+  "application/x-zip-compressed",
+  "application/gzip",
+  "application/x-tar"
+]);
+var ServiceRecord = class {
+  constructor(params) {
+    __publicField(this, "service_name");
+    __publicField(this, "endpoint");
+    __publicField(this, "service_type");
+    __publicField(this, "visibility");
+    __publicField(this, "metadata");
+    this.service_name = params.service_name;
+    this.endpoint = params.endpoint;
+    this.service_type = String(params.service_type ?? "http").trim() || "http";
+    this.visibility = String(params.visibility ?? "private").trim() || "private";
+    this.metadata = sanitizeMetadata(params.metadata ?? {});
+  }
+  summary() {
+    return {
+      service_name: this.service_name,
+      service_type: this.service_type,
+      visibility: this.visibility,
+      metadata: sanitizeMetadata(this.metadata)
+    };
+  }
+};
+var EndpointPolicy = class {
+  constructor(opts = {}) {
+    __publicField(this, "allowedHosts");
+    this.allowedHosts = new Set(Array.from(opts.allowedHosts ?? []).map(normalizeHost).filter(Boolean));
+  }
+  isAllowed(endpoint) {
+    let parsed;
+    try {
+      parsed = new URL(String(endpoint ?? "").trim());
+    } catch {
+      return false;
+    }
+    if (!ALLOWED_SCHEMES.has(parsed.protocol)) return false;
+    const host = normalizeHost(parsed.hostname);
+    if (!host) return false;
+    if (this.allowedHosts.has(host)) return true;
+    if (host === "localhost") return true;
+    return isIPv4LoopbackHost(host);
+  }
+};
+var EmbeddedServiceRegistry = class {
+  constructor(opts = {}) {
+    __publicField(this, "_endpointPolicy");
+    __publicField(this, "_replaceExisting");
+    __publicField(this, "_records", /* @__PURE__ */ new Map());
+    this._endpointPolicy = opts.endpointPolicy ?? new EndpointPolicy();
+    this._replaceExisting = opts.replaceExisting ?? true;
+  }
+  register(serviceName, endpoint, opts = {}) {
+    const normalizedName = normalizeServiceName(serviceName);
+    const endpointText = String(endpoint ?? "").trim();
+    if (!this._endpointPolicy.isAllowed(endpointText)) {
+      throw new ValidationError("endpoint is not allowed");
+    }
+    if (this._records.has(normalizedName) && !this._replaceExisting) {
+      throw new ValidationError(`service already registered: ${normalizedName}`);
+    }
+    const record = new ServiceRecord({
+      service_name: normalizedName,
+      endpoint: endpointText,
+      service_type: opts.serviceType,
+      visibility: opts.visibility,
+      metadata: opts.metadata
+    });
+    this._records.set(normalizedName, record);
+    return record;
+  }
+  unregister(serviceName) {
+    return this._records.delete(normalizeServiceName(serviceName));
+  }
+  get(serviceName) {
+    return this._records.get(normalizeServiceName(serviceName)) ?? null;
+  }
+  listRecords() {
+    return Array.from(this._records.values()).sort((a, b) => a.service_name.localeCompare(b.service_name));
+  }
+  listSummaries() {
+    return this.listRecords().map((record) => record.summary());
+  }
+};
+var AsyncQueue = class {
+  constructor() {
+    __publicField(this, "_items", []);
+    __publicField(this, "_waiters", []);
+    __publicField(this, "_closed", false);
+  }
+  push(value) {
+    if (this._closed) return;
+    const waiter = this._waiters.shift();
+    if (waiter) waiter(value);
+    else this._items.push(value);
+  }
+  close() {
+    this._closed = true;
+    for (const waiter of this._waiters.splice(0)) waiter(null);
+  }
+  shift(timeoutMs) {
+    if (this._items.length > 0) return Promise.resolve(this._items.shift());
+    if (this._closed) return Promise.resolve(null);
+    return new Promise((resolve) => {
+      let timer = null;
+      const done = (value) => {
+        if (timer !== null) clearTimeout(timer);
+        resolve(value);
+      };
+      this._waiters.push(done);
+      if (timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          const idx = this._waiters.indexOf(done);
+          if (idx >= 0) this._waiters.splice(idx, 1);
+          resolve(null);
+        }, Math.max(0, timeoutMs));
+      }
+    });
+  }
+};
+var TunnelSocket = class {
+  constructor(ws) {
+    __publicField(this, "_ws");
+    __publicField(this, "_queue", new AsyncQueue());
+    this._ws = ws;
+    try {
+      this._ws.binaryType = "arraybuffer";
+    } catch {
+    }
+    ws.addEventListener("message", (event) => {
+      const data = event.data;
+      if (typeof data === "string") {
+        this._queue.push(data);
+      } else if (data instanceof ArrayBuffer) {
+        this._queue.push(new TextDecoder().decode(new Uint8Array(data)));
+      } else if (ArrayBuffer.isView(data)) {
+        this._queue.push(new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength)));
+      } else {
+        this._queue.push(String(data ?? ""));
+      }
+    });
+    ws.addEventListener("close", () => this._queue.close());
+    ws.addEventListener("error", () => this._queue.close());
+  }
+  async send(message) {
+    this._ws.send(JSON.stringify(message));
+  }
+  recv(timeoutMs) {
+    return this._queue.shift(timeoutMs);
+  }
+  close() {
+    try {
+      this._ws.close();
+    } catch {
+    }
+    this._queue.close();
+  }
+};
+var ServiceProxyClient = class {
+  constructor(opts) {
+    __publicField(this, "providerAid");
+    __publicField(this, "registry");
+    __publicField(this, "maxResponseBodyBytes");
+    __publicField(this, "maxTunnelMessageBytes");
+    __publicField(this, "_logger");
+    __publicField(this, "_aunClient");
+    __publicField(this, "_webSocketFactory");
+    __publicField(this, "_running", false);
+    __publicField(this, "_activeTunnel", null);
+    this.providerAid = String(opts.providerAid ?? "").trim();
+    this.registry = opts.registry ?? new EmbeddedServiceRegistry({ endpointPolicy: opts.endpointPolicy });
+    this._logger = opts.logger ?? null;
+    this._aunClient = opts.aunClient ?? null;
+    this._webSocketFactory = opts.webSocketFactory ?? null;
+    this.maxResponseBodyBytes = Math.max(1, Math.floor(opts.maxResponseBodyBytes ?? 16 * 1024 * 1024));
+    this.maxTunnelMessageBytes = Math.max(1, Math.floor(opts.maxTunnelMessageBytes ?? 64 * 1024 * 1024));
+  }
+  get isRunning() {
+    return this._running;
+  }
+  get is_running() {
+    return this.isRunning;
+  }
+  stop() {
+    this._running = false;
+    this._activeTunnel?.close();
+  }
+  registerService(serviceName, endpoint, opts = {}) {
+    return this.registry.register(serviceName, endpoint, {
+      serviceType: opts.serviceType ?? opts.service_type,
+      visibility: opts.visibility,
+      metadata: opts.metadata
+    });
+  }
+  register_service(serviceName, endpoint, opts = {}) {
+    return this.registerService(serviceName, endpoint, opts);
+  }
+  unregisterService(serviceName) {
+    return this.registry.unregister(serviceName);
+  }
+  unregister_service(serviceName) {
+    return this.unregisterService(serviceName);
+  }
+  listServiceSummaries() {
+    return this.registry.listSummaries();
+  }
+  list_service_summaries() {
+    return this.listServiceSummaries();
+  }
+  async registerServicesWithGateway(services) {
+    const call = this._gatewayCallMethod(true);
+    const result = await call("proxy.register_services", {
+      provider_aid: this.providerAid,
+      services: services ?? this.listServiceSummaries()
+    });
+    if (!isRecord4(result)) return {};
+    if (result.ok === false) throw new ValidationError(String(result.error ?? "Gateway service registration failed"));
+    return result;
+  }
+  register_services_with_gateway(services) {
+    return this.registerServicesWithGateway(services);
+  }
+  async unregisterServicesFromGateway(serviceNames) {
+    const call = this._gatewayCallMethod(true);
+    const params = { provider_aid: this.providerAid };
+    if (typeof serviceNames === "string") params.service_names = [serviceNames];
+    else if (Array.isArray(serviceNames)) params.service_names = serviceNames.map(String);
+    const result = await call("proxy.unregister_services", params);
+    return isRecord4(result) ? result : {};
+  }
+  unregister_services_from_gateway(serviceNames) {
+    return this.unregisterServicesFromGateway(serviceNames);
+  }
+  async listGatewayServices() {
+    const call = this._gatewayCallMethod(true);
+    const result = await call("proxy.list_services", { provider_aid: this.providerAid });
+    return isRecord4(result) ? result : {};
+  }
+  list_gateway_services() {
+    return this.listGatewayServices();
+  }
+  async discoverProxyServer(opts = {}) {
+    const forceRefresh = Boolean(opts.forceRefresh ?? opts.force_refresh ?? false);
+    if (!forceRefresh) {
+      const cached = await this._loadCachedProxyDiscovery();
+      if (cached) return cached;
+    }
+    const errors = [];
+    for (const url of this._proxyWellKnownUrls()) {
+      try {
+        const discovery = await this._fetchProxyWellKnown(url, opts.timeout ?? 5);
+        await this._persistProxyDiscovery(discovery);
+        return discovery;
+      } catch (exc) {
+        errors.push(`${url}: ${formatError(exc)}`);
+        this._logWarn(`Service Proxy discovery failed: url=${url} err=${formatError(exc)}`);
+      }
+    }
+    throw new ConnectionError(`Service Proxy discovery failed: ${errors.join("; ")}`, { retryable: true });
+  }
+  discover_proxy_server(opts = {}) {
+    return this.discoverProxyServer(opts);
+  }
+  async discoverProxyWsUrl(opts = {}) {
+    const discovery = await this.discoverProxyServer(opts);
+    return String(discovery.ws_url ?? "").trim();
+  }
+  discover_proxy_ws_url(opts = {}) {
+    return this.discoverProxyWsUrl(opts);
+  }
+  async connectOnce(opts = {}) {
+    this._running = true;
+    try {
+      await this._autoRegisterServicesWithGateway();
+      const tunnel = await this._connectProxyWs();
+      this._activeTunnel = tunnel;
+      await tunnel.send({
+        type: "service_proxy_auth",
+        request_id: opts.authRequestId ?? "auth",
+        provider_aid: this.providerAid,
+        client_version: "js"
+      });
+      const authResponse = parseTunnelMessage(await tunnel.recv());
+      if (!authResponse.ok) {
+        const err = isRecord4(authResponse.error) ? authResponse.error : {};
+        throw new AuthError(String(err.message ?? "Service Proxy auth failed"));
+      }
+      const registered = await this.registerServicesWithProxyServer(tunnel, {
+        registerRequestId: opts.registerRequestId ?? "register-services"
+      });
+      let heartbeat = false;
+      if (opts.heartbeatRequestId) {
+        await tunnel.send({ type: "heartbeat", request_id: opts.heartbeatRequestId });
+        heartbeat = Boolean(parseTunnelMessage(await tunnel.recv()).ok);
+      }
+      return { registered, heartbeat };
+    } finally {
+      this._running = false;
+      this._activeTunnel?.close();
+      this._activeTunnel = null;
+    }
+  }
+  connect_once(opts = {}) {
+    return this.connectOnce({
+      authRequestId: opts.auth_request_id,
+      registerRequestId: opts.register_request_id,
+      heartbeatRequestId: opts.heartbeat_request_id
+    });
+  }
+  async serveOnce(opts = {}) {
+    this._running = true;
+    try {
+      await this._autoRegisterServicesWithGateway();
+      const tunnel = await this._connectProxyWs();
+      this._activeTunnel = tunnel;
+      return await this._serveTunnel(tunnel, {
+        authRequestId: opts.authRequestId ?? "auth",
+        registerRequestId: opts.registerRequestId ?? "register-services",
+        maxRequests: opts.maxRequests ?? 1
+      });
+    } finally {
+      this._running = false;
+      this._activeTunnel?.close();
+      this._activeTunnel = null;
+    }
+  }
+  serve_once(opts = {}) {
+    return this.serveOnce({
+      authRequestId: opts.auth_request_id,
+      registerRequestId: opts.register_request_id,
+      maxRequests: opts.max_requests
+    });
+  }
+  async serveForever(opts = {}) {
+    const mode = opts.connectionMode ?? "persistent";
+    if (mode !== "persistent" && mode !== "on_demand") {
+      throw new ValidationError("connectionMode must be persistent or on_demand");
+    }
+    this._running = true;
+    const stats = { connection_mode: mode, connections: 0, registered: 0, handled_requests: 0, wakeup_count: 0 };
+    try {
+      if (mode === "persistent") {
+        while (this._running) {
+          try {
+            await this._autoRegisterServicesWithGateway();
+            const tunnel = await this._connectProxyWs();
+            this._activeTunnel = tunnel;
+            const result = await this._serveTunnel(tunnel, {
+              authRequestId: opts.authRequestId ?? "auth",
+              registerRequestId: opts.registerRequestId ?? "register-services"
+            });
+            stats.connections = Number(stats.connections) + 1;
+            stats.registered = Number(result.registered ?? stats.registered);
+            stats.handled_requests = Number(stats.handled_requests) + Number(result.handled_requests ?? 0);
+          } catch (exc) {
+            if (!this._running) break;
+            this._logWarn(`persistent tunnel reconnect scheduled after error: ${formatError(exc)}`);
+            await sleep(Math.max(0, opts.reconnectDelaySeconds ?? 1) * 1e3);
+          } finally {
+            this._activeTunnel?.close();
+            this._activeTunnel = null;
+          }
+        }
+        return stats;
+      }
+      return await this._serveOnDemand(stats, opts);
+    } finally {
+      this._running = false;
+      this._activeTunnel?.close();
+      this._activeTunnel = null;
+    }
+  }
+  serve_forever(opts = {}) {
+    return this.serveForever({
+      connectionMode: opts.connection_mode,
+      authRequestId: opts.auth_request_id,
+      registerRequestId: opts.register_request_id,
+      idleTimeoutSeconds: opts.idle_timeout_seconds,
+      reconnectDelaySeconds: opts.reconnect_delay_seconds
+    });
+  }
+  async registerServicesWithProxyServer(tunnel, opts = {}) {
+    const services = opts.services ?? this.listServiceSummaries();
+    await tunnel.send({ type: "register_services", request_id: opts.registerRequestId ?? "register-services", services });
+    const response = parseTunnelMessage(await tunnel.recv());
+    if (!response.ok) throw new ValidationError("Service Proxy service registration failed");
+    return Number(response.count ?? services.length);
+  }
+  register_services_with_proxy_server(tunnel, opts = {}) {
+    return this.registerServicesWithProxyServer(tunnel, { registerRequestId: opts.register_request_id, services: opts.services });
+  }
+  async *iterRequestMessages(message, opts = {}) {
+    const requestId = String(message.request_id ?? "");
+    const serviceName = String(message.service_name ?? "");
+    let record = null;
+    try {
+      record = this.registry.get(serviceName);
+    } catch {
+      record = null;
+    }
+    if (!record) {
+      yield errorMessage(requestId, "service_not_registered", "service is not registered");
+      return;
+    }
+    const method = String(message.method ?? "GET").toUpperCase();
+    const path = normalizePath(String(message.path ?? "/"));
+    const targetUrl = buildTargetUrl(record.endpoint, path, String(message.query_string ?? ""));
+    const bodyStream = message.body_stream === true;
+    let body;
+    if (bodyStream) {
+      if (!opts.bodyIter) {
+        yield errorMessage(requestId, "missing_body_stream", "request body stream is missing");
+        return;
+      }
+      body = readableStreamFromAsyncIterable(opts.bodyIter);
+    } else if (message.body_base64) {
+      try {
+        body = toExactArrayBuffer(decodeBase64Strict(String(message.body_base64)));
+      } catch {
+        yield errorMessage(requestId, "invalid_body", "body_base64 is invalid");
+        return;
+      }
+    }
+    const headers = backendHeaders(isRecord4(message.headers) ? message.headers : {});
+    let response;
+    try {
+      const init = { method, headers };
+      if (method !== "GET" && method !== "HEAD") {
+        init.body = body;
+        if (bodyStream) init.duplex = "half";
+      }
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 3e4);
+      try {
+        response = await fetch(targetUrl, { ...init, signal: controller.signal });
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch (exc) {
+      this._logWarn(`backend request failed: request_id=${requestId} service_name=${serviceName} err=${formatError(exc)}`);
+      yield errorMessage(requestId, "backend_unreachable", "backend request failed");
+      return;
+    }
+    const responseHeaders = responseHeadersMap(response.headers);
+    const detection = detectRequestProtocol(message, record);
+    const shouldStream = detection.isStream || detection.streamMode !== "no_stream" && isStreamResponseHeaders(responseHeaders);
+    if (!shouldStream) {
+      try {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.length > this.maxResponseBodyBytes) throw new Error("too large");
+        yield {
+          type: "service_proxy_response",
+          request_id: requestId,
+          status: response.status,
+          headers: responseHeaders,
+          body_base64: encodeBase64(bytes)
+        };
+      } catch {
+        yield errorMessage(requestId, "response_body_too_large", "backend response body is too large");
+      }
+      return;
+    }
+    const streamType = streamTypeFromResponse(responseHeaders, detection.serviceType);
+    if (!responseHeaders["x-stream-type"]) responseHeaders["x-stream-type"] = streamType;
+    const chunkSize = Math.max(1, Math.floor(opts.chunkSize ?? 65536));
+    let index = 0;
+    let pending = null;
+    for await (const chunk of responseChunks(response, chunkSize)) {
+      if (pending) {
+        yield streamMessage(requestId, index, response.status, responseHeaders, pending, false);
+        index += 1;
+      }
+      pending = chunk;
+    }
+    if (pending) {
+      yield streamMessage(requestId, index, response.status, responseHeaders, pending, true);
+    } else if (index === 0) {
+      yield { type: "service_proxy_stream", request_id: requestId, index: 0, status: response.status, headers: responseHeaders, data_base64: "", done: true };
+    }
+  }
+  async handleWsConnectMessage(message, tunnel, inboundQueue) {
+    const connectionId = String(message.connection_id ?? "");
+    const serviceName = String(message.service_name ?? "");
+    let record = null;
+    try {
+      record = this.registry.get(serviceName);
+    } catch {
+      record = null;
+    }
+    if (!record) {
+      await tunnel.send(wsErrorMessage(connectionId, "service_not_registered", "service is not registered"));
+      return;
+    }
+    const protocols = Array.isArray(message.subprotocols) ? message.subprotocols.map(String).map((item) => item.trim()).filter(Boolean) : [];
+    let backend;
+    try {
+      backend = this._createWebSocket(
+        buildTargetUrl(record.endpoint, normalizePath(String(message.path ?? "/")), String(message.query_string ?? "")),
+        protocols,
+        { headers: backendHeaders(isRecord4(message.headers) ? message.headers : {}), verifySsl: this._shouldVerifySsl() },
+        false
+      );
+      await waitForWsOpen(backend);
+      await tunnel.send({ type: "ws_connected", connection_id: connectionId, subprotocol: backend.protocol || "" });
+    } catch (exc) {
+      this._logWarn(`backend websocket bridge failed: connection_id=${connectionId} err=${formatError(exc)}`);
+      await tunnel.send(wsErrorMessage(connectionId, "backend_ws_unreachable", "backend websocket request failed"));
+      return;
+    }
+    backend.binaryType = "arraybuffer";
+    const backendClosed = new Promise((resolve) => {
+      backend.addEventListener("message", (event) => {
+        const data = event.data;
+        if (typeof data === "string") {
+          tunnel.send({ type: "ws_message", connection_id: connectionId, text: data }).catch(() => {
+          });
+        } else {
+          bytesFromWsData(data).then((bytes) => {
+            tunnel.send({ type: "ws_message", connection_id: connectionId, data_base64: encodeBase64(bytes) }).catch(() => {
+            });
+          }).catch(() => {
+          });
+        }
+      });
+      backend.addEventListener("close", (event) => {
+        tunnel.send({ type: "ws_close", connection_id: connectionId, code: event.code || 1e3, reason: "" }).catch(() => {
+        });
+        resolve();
+      });
+      backend.addEventListener("error", () => resolve());
+    });
+    const tunnelToBackend = (async () => {
+      while (this._running) {
+        const item = await inboundQueue.shift();
+        if (!item) return;
+        const msgType = String(item.type ?? "");
+        if (msgType === "ws_message") {
+          if (item.text !== void 0 && item.text !== null) {
+            backend.send(String(item.text));
+          } else if (item.data_base64 !== void 0) {
+            try {
+              backend.send(decodeBase64Strict(String(item.data_base64 ?? "")));
+            } catch {
+              await tunnel.send(wsErrorMessage(connectionId, "invalid_ws_frame", "data_base64 is invalid"));
+              backend.close();
+              return;
+            }
+          }
+        } else if (msgType === "ws_close" || msgType === "ws_error") {
+          backend.close(Number(item.code ?? 1e3), String(item.reason ?? ""));
+          return;
+        }
+      }
+    })();
+    await Promise.race([backendClosed, tunnelToBackend]);
+    try {
+      backend.close();
+    } catch {
+    }
+  }
+  async _serveOnDemand(stats, opts) {
+    const client = this._aunClient;
+    if (!client || typeof client.on !== "function") throw new ValidationError("on_demand mode requires aunClient with on()");
+    await this._autoRegisterServicesWithGateway();
+    const queue = new AsyncQueue();
+    const subscription = client.on("app.service_proxy.wakeup", (payload) => {
+      if (!isRecord4(payload)) return;
+      if (String(payload.type ?? "") !== "aun.service_proxy.wakeup") return;
+      const providerAid = String(payload.provider_aid ?? "").trim();
+      if (providerAid && providerAid !== this.providerAid) return;
+      queue.push({ ...payload });
+    });
+    try {
+      while (this._running) {
+        const wakeup = await queue.shift(100);
+        if (!this._running) break;
+        if (!wakeup) continue;
+        stats.wakeup_count = Number(stats.wakeup_count) + 1;
+        try {
+          await this._autoRegisterServicesWithGateway();
+          const tunnel = await this._connectProxyWs();
+          this._activeTunnel = tunnel;
+          const result = await this._serveTunnel(tunnel, {
+            authRequestId: opts.authRequestId ?? "auth",
+            registerRequestId: opts.registerRequestId ?? "register-services",
+            idleTimeoutSeconds: opts.idleTimeoutSeconds ?? 60
+          });
+          stats.connections = Number(stats.connections) + 1;
+          stats.registered = Number(result.registered ?? stats.registered);
+          stats.handled_requests = Number(stats.handled_requests) + Number(result.handled_requests ?? 0);
+        } catch (exc) {
+          if (!this._running) break;
+          this._logWarn(`on-demand tunnel connection failed after wakeup: ${formatError(exc)}`);
+          await sleep(Math.max(0, opts.reconnectDelaySeconds ?? 1) * 1e3);
+        } finally {
+          this._activeTunnel?.close();
+          this._activeTunnel = null;
+        }
+      }
+      return stats;
+    } finally {
+      subscription?.unsubscribe?.();
+      queue.close();
+    }
+  }
+  async _serveTunnel(tunnel, opts) {
+    let handledRequests = 0;
+    const activeWsQueues = /* @__PURE__ */ new Map();
+    const registered = await this._authAndRegister(tunnel, opts.authRequestId, opts.registerRequestId);
+    try {
+      while (this._running) {
+        if (opts.maxRequests !== void 0 && handledRequests >= opts.maxRequests && activeWsQueues.size === 0) break;
+        const waitForWsTasks = opts.maxRequests !== void 0 && handledRequests >= opts.maxRequests && activeWsQueues.size > 0;
+        const timeoutMs = waitForWsTasks ? 50 : opts.idleTimeoutSeconds === void 0 ? void 0 : opts.idleTimeoutSeconds * 1e3;
+        const raw = await tunnel.recv(timeoutMs);
+        if (raw === null) {
+          if (timeoutMs !== void 0 && activeWsQueues.size > 0) continue;
+          break;
+        }
+        let message;
+        try {
+          const parsed = JSON.parse(raw);
+          if (!isRecord4(parsed)) continue;
+          message = parsed;
+        } catch {
+          continue;
+        }
+        const msgType = String(message.type ?? "");
+        if (msgType === "service_proxy_request") {
+          const requestId = String(message.request_id ?? "");
+          const bodyIter = message.body_stream === true ? this._iterRequestBodyChunks(tunnel, requestId, activeWsQueues) : void 0;
+          for await (const response of this.iterRequestMessages(message, { bodyIter })) await tunnel.send(response);
+          handledRequests += 1;
+        } else if (msgType === "ws_connect") {
+          const connectionId = String(message.connection_id ?? "");
+          if (!connectionId) {
+            await tunnel.send(wsErrorMessage("", "missing_connection_id", "connection_id is required"));
+            continue;
+          }
+          const queue = new AsyncQueue();
+          activeWsQueues.set(connectionId, queue);
+          this.handleWsConnectMessage(message, tunnel, queue).finally(() => {
+            queue.close();
+            activeWsQueues.delete(connectionId);
+          });
+          handledRequests += 1;
+        } else if (msgType === "ws_message" || msgType === "ws_close" || msgType === "ws_error") {
+          const connectionId = String(message.connection_id ?? "");
+          const queue = activeWsQueues.get(connectionId);
+          if (queue) queue.push(message);
+          else if (connectionId) await tunnel.send(wsErrorMessage(connectionId, "unknown_ws_connection", "WebSocket connection is not active"));
+        } else if (msgType !== "heartbeat_ack") {
+          await tunnel.send(errorMessage(String(message.request_id ?? ""), "unsupported_message", "unsupported Service Proxy tunnel message"));
+        }
+      }
+      return { registered, handled_requests: handledRequests };
+    } finally {
+      for (const queue of activeWsQueues.values()) queue.close();
+    }
+  }
+  async _authAndRegister(tunnel, authRequestId, registerRequestId) {
+    await tunnel.send({ type: "service_proxy_auth", request_id: authRequestId, provider_aid: this.providerAid, client_version: "js" });
+    const authResponse = parseTunnelMessage(await tunnel.recv());
+    if (!authResponse.ok) {
+      const err = isRecord4(authResponse.error) ? authResponse.error : {};
+      throw new AuthError(String(err.message ?? "Service Proxy auth failed"));
+    }
+    return this.registerServicesWithProxyServer(tunnel, { registerRequestId });
+  }
+  async *_iterRequestBodyChunks(tunnel, requestId, activeWsQueues) {
+    while (true) {
+      const message = parseTunnelMessage(await tunnel.recv());
+      const msgType = String(message.type ?? "");
+      if (msgType === "ws_message" || msgType === "ws_close" || msgType === "ws_error") {
+        const queue = activeWsQueues.get(String(message.connection_id ?? ""));
+        if (queue) {
+          queue.push(message);
+          continue;
+        }
+      }
+      if (msgType !== "service_proxy_request_body") throw new Error("invalid_body_stream");
+      if (String(message.request_id ?? "") !== requestId) throw new Error("request body stream request_id mismatch");
+      if (isRecord4(message.error)) throw new Error(String(message.error.message ?? "request body stream failed"));
+      const dataText = String(message.data_base64 ?? "");
+      if (dataText) yield decodeBase64Strict(dataText);
+      if (message.done === true) return;
+    }
+  }
+  _createWebSocket(url, protocols, options, requireHeaders) {
+    if (this._webSocketFactory) return this._webSocketFactory(url, protocols, options);
+    if (requireHeaders && options.headers && Object.keys(options.headers).length > 0) {
+      throw new AuthError("Browser WebSocket cannot set Authorization header; pass webSocketFactory to ServiceProxyClient");
+    }
+    return new WebSocket(url, protocols);
+  }
+  async _connectProxyWs() {
+    const proxyUrl = await this.discoverProxyWsUrl();
+    const token = await this._ensureAccessToken();
+    if (!token) throw new AuthError("AUN access_token is required for Service Proxy tunnel");
+    const ws = this._createWebSocket(
+      proxyUrl,
+      void 0,
+      {
+        headers: { Authorization: `Bearer ${token}` },
+        maxPayloadBytes: this.maxTunnelMessageBytes,
+        verifySsl: this._shouldVerifySsl()
+      },
+      true
+    );
+    await waitForWsOpen(ws);
+    return new TunnelSocket(ws);
+  }
+  _gatewayCallMethod(required) {
+    const call = this._aunClient?.call;
+    if (typeof call === "function") return (method, params) => Promise.resolve(call.call(this._aunClient, method, params ?? {}));
+    if (required) throw new ValidationError("Gateway service registration requires aunClient with call()");
+    return async () => ({ skipped: true });
+  }
+  async _autoRegisterServicesWithGateway() {
+    const call = this._aunClient?.call;
+    if (typeof call !== "function") return { skipped: true };
+    return this.registerServicesWithGateway();
+  }
+  _issuerDomainForAid(aid) {
+    const target = String(aid ?? "").trim().toLowerCase();
+    if (!target.includes(".")) return "";
+    return target.split(".").slice(1).join(".").replace(/^\.+|\.+$/g, "");
+  }
+  _proxyWellKnownUrls() {
+    const issuer = this._issuerDomainForAid(this.providerAid);
+    if (!this.providerAid || !issuer) throw new ValidationError("providerAid must be a full AID for Service Proxy discovery");
+    return [`https://${this.providerAid}/.well-known/aun-proxy`, `https://proxy.${issuer}/.well-known/aun-proxy`];
+  }
+  _normalizeProxyWsUrl(rawUrl) {
+    const value = String(rawUrl ?? "").trim();
+    if (!value) return "";
+    let parsed;
+    try {
+      parsed = new URL(value);
+    } catch {
+      return "";
+    }
+    if (parsed.protocol === "ws:" && this._shouldVerifySsl()) return "";
+    if (parsed.protocol !== "wss:" && parsed.protocol !== "ws:") return "";
+    if (parsed.username || parsed.password || !parsed.hostname || parsed.pathname === "/") return "";
+    parsed.hash = "";
+    return parsed.toString();
+  }
+  _selectProxyWsUrl(payload) {
+    const direct = this._normalizeProxyWsUrl(String(payload.ws_url ?? ""));
+    if (direct) return direct;
+    const servers = Array.isArray(payload.proxy_servers) ? payload.proxy_servers.filter(isRecord4) : [];
+    servers.sort((a, b) => Number(a.priority ?? 999) - Number(b.priority ?? 999));
+    for (const item of servers) {
+      const url = this._normalizeProxyWsUrl(String(item.ws_url ?? ""));
+      if (url) return url;
+    }
+    return "";
+  }
+  async _fetchProxyWellKnown(wellKnownUrl, timeoutSeconds) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.max(100, timeoutSeconds * 1e3));
+    try {
+      const response = await fetch(wellKnownUrl, { signal: controller.signal });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const payload = await response.json();
+      if (!isRecord4(payload)) throw new ValidationError("Service Proxy well-known returned invalid payload");
+      const wsUrl = this._selectProxyWsUrl(payload);
+      if (!wsUrl) throw new ValidationError("Service Proxy well-known missing valid ws_url");
+      return { ...payload, ws_url: wsUrl, source_url: wellKnownUrl, discovered_at: Date.now() / 1e3 };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async _loadCachedProxyDiscovery() {
+    const tokenStore = this._aunClient?._tokenStore;
+    if (!tokenStore) return null;
+    try {
+      let raw = "";
+      if (typeof tokenStore.getMetadata === "function") raw = await tokenStore.getMetadata(this.providerAid, PROXY_DISCOVERY_CACHE_KEY);
+      else if (typeof tokenStore.loadMetadata === "function") raw = (await tokenStore.loadMetadata(this.providerAid))?.[PROXY_DISCOVERY_CACHE_KEY];
+      const cached = typeof raw === "string" ? JSON.parse(raw) : raw;
+      if (!isRecord4(cached)) return null;
+      const wsUrl = this._normalizeProxyWsUrl(String(cached.ws_url ?? ""));
+      if (!wsUrl) return null;
+      const discoveredAt = Number(cached.discovered_at ?? 0);
+      if (!Number.isFinite(discoveredAt) || Date.now() - discoveredAt * 1e3 >= PROXY_DISCOVERY_CACHE_TTL_MS) return null;
+      return { ...cached, ws_url: wsUrl, cached: true };
+    } catch {
+      return null;
+    }
+  }
+  async _persistProxyDiscovery(discovery) {
+    const tokenStore = this._aunClient?._tokenStore;
+    if (!tokenStore || typeof tokenStore.setMetadata !== "function" || !this.providerAid) return;
+    try {
+      await tokenStore.setMetadata(this.providerAid, PROXY_DISCOVERY_CACHE_KEY, JSON.stringify(discovery));
+    } catch (exc) {
+      this._logWarn(`Service Proxy discovery cache write failed: ${formatError(exc)}`);
+    }
+  }
+  _shouldVerifySsl() {
+    const client = this._aunClient;
+    const cfg = client?.configModel ?? client?._configModel;
+    if (cfg && (typeof cfg.verifySsl === "boolean" || typeof cfg.verify_ssl === "boolean")) return Boolean(cfg.verifySsl ?? cfg.verify_ssl);
+    const aid = client?.currentAid ?? client?._currentAid;
+    if (aid && (typeof aid.verifySsl === "boolean" || typeof aid.verify_ssl === "boolean")) return Boolean(aid.verifySsl ?? aid.verify_ssl);
+    return true;
+  }
+  _mappingAccessToken(mapping) {
+    if (!mapping) return "";
+    const token = String(mapping.access_token ?? mapping.token ?? mapping.kite_token ?? "").trim();
+    if (!token) return "";
+    const expiresAt = Number(mapping.access_token_expires_at ?? mapping.expires_at ?? 0);
+    if (Number.isFinite(expiresAt) && expiresAt > 0 && expiresAt <= Date.now() / 1e3 + TOKEN_EXPIRY_SKEW_SECONDS) return "";
+    return token;
+  }
+  async _resolveCachedAccessToken() {
+    const client = this._aunClient;
+    if (!client) return "";
+    const direct = this._mappingAccessToken(client);
+    if (direct) return direct;
+    if (isRecord4(client._identity)) {
+      const token = this._mappingAccessToken(client._identity);
+      if (token) return token;
+    }
+    const auth = client._auth;
+    if (auth && typeof auth.loadIdentityOrNone === "function") {
+      try {
+        const token = this._mappingAccessToken(await auth.loadIdentityOrNone(this.providerAid));
+        if (token) return token;
+      } catch {
+      }
+    }
+    const tokenStore = client._tokenStore;
+    if (tokenStore && typeof tokenStore.loadInstanceState === "function") {
+      try {
+        const deviceId = String(client.deviceId ?? client.device_id ?? client._deviceId ?? client._device_id ?? "");
+        const slotId = String(client.slotId ?? client.slot_id ?? client._slotId ?? client._slot_id ?? "");
+        const token = this._mappingAccessToken(await tokenStore.loadInstanceState(this.providerAid, deviceId, slotId));
+        if (token) return token;
+      } catch {
+      }
+    }
+    return "";
+  }
+  async _authenticateForAccessToken() {
+    const authenticate = this._aunClient?.authenticate;
+    if (typeof authenticate !== "function") throw new AuthError("Service Proxy tunnel requires aunClient.authenticate() for AUN token authentication");
+    let result;
+    try {
+      result = await authenticate.call(this._aunClient);
+    } catch (exc) {
+      throw new AuthError(`AUNClient authenticate failed for Service Proxy tunnel: ${formatError(exc)}`);
+    }
+    const token = this._mappingAccessToken(isRecord4(result) ? result : null);
+    if (token) return token;
+    throw new AuthError("AUNClient authenticate did not return a valid access_token");
+  }
+  async _ensureAccessToken() {
+    return await this._resolveCachedAccessToken() || await this._authenticateForAccessToken();
+  }
+  _logWarn(message) {
+    try {
+      this._logger?.warn(message);
+    } catch {
+    }
+  }
+};
+function normalizeServiceName(serviceName) {
+  const value = String(serviceName ?? "").trim();
+  if (!value) throw new ValidationError("service_name is required");
+  if (RESERVED_SERVICE_NAMES.has(value)) throw new ValidationError("service_name is reserved");
+  if (!SERVICE_NAME_RE.test(value)) throw new ValidationError("service_name must match [a-z0-9_-]+");
+  return value;
+}
+function normalizeHost(host) {
+  return String(host ?? "").trim().toLowerCase().replace(/\.+$/g, "");
+}
+function isIPv4LoopbackHost(host) {
+  const parts = host.split(".");
+  if (parts.length !== 4 || parts[0] !== "127") return false;
+  return parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) >= 0 && Number(part) <= 255);
+}
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isSensitiveMetadataKey(key) {
+  const normalized = key.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return SENSITIVE_METADATA_KEYS.has(normalized) || /(_token|_secret|_password|_private_key)$/.test(normalized);
+}
+function sanitizeMetadata(metadata) {
+  const out = {};
+  for (const [key, value] of Object.entries(metadata ?? {})) {
+    if (isSensitiveMetadataKey(key)) continue;
+    if (isRecord4(value)) out[key] = sanitizeMetadata(value);
+    else if (Array.isArray(value)) out[key] = value.map((item) => isRecord4(item) ? sanitizeMetadata(item) : item);
+    else out[key] = value;
+  }
+  return out;
+}
+function headersMap(headers) {
+  const result = {};
+  if (!isRecord4(headers)) return result;
+  for (const [key, value] of Object.entries(headers)) result[key.toLowerCase()] = String(value);
+  return result;
+}
+function streamModeFrom(headers, record, message) {
+  let value = String(message.stream_mode ?? "").trim().toLowerCase();
+  if (!value) value = String(headers["x-stream-mode"] ?? "").trim().toLowerCase();
+  if (!value) value = String(record.metadata.stream_mode ?? "").trim().toLowerCase();
+  if (value === "always") return "stream";
+  return VALID_STREAM_MODES.has(value) ? value : "auto";
+}
+function detectRequestProtocol(message, record) {
+  const headers = headersMap(isRecord4(message.headers) ? message.headers : {});
+  const streamMode = streamModeFrom(headers, record, message);
+  let serviceType = String(message.service_type ?? "").trim().toLowerCase() || record.service_type.toLowerCase() || "http";
+  if (streamMode === "no_stream") {
+    serviceType = "http";
+  } else if (!message.service_type) {
+    const explicitType = String(headers["x-service-type"] ?? "").trim().toLowerCase();
+    const method = String(message.method ?? "").toUpperCase();
+    const path = String(message.path ?? "").toLowerCase();
+    const accept = String(headers.accept ?? "").toLowerCase();
+    const contentType = String(headers["content-type"] ?? "").toLowerCase();
+    if (explicitType) serviceType = explicitType;
+    else if (accept.includes("text/event-stream")) serviceType = "sse";
+    else if ("mcp-session-id" in headers) serviceType = "mcp";
+    else if (method === "POST" && bodyHasJsonRpc(message)) serviceType = "mcp";
+    else if (contentType.startsWith("application/grpc")) serviceType = "ws";
+    else if (path.includes("/mcp")) serviceType = "mcp";
+    else if (path.includes("/sse") || path.includes("/events")) serviceType = "sse";
+    else if (path.includes("/download") || path.includes("/files/")) serviceType = "file";
+  }
+  let isStream;
+  if (streamMode === "stream") isStream = true;
+  else if (streamMode === "no_stream") isStream = false;
+  else if ("is_stream" in message) isStream = Boolean(message.is_stream);
+  else if ("stream" in message) isStream = Boolean(message.stream);
+  else isStream = STREAMING_SERVICE_TYPES.has(serviceType);
+  return { serviceType, streamMode, isStream };
+}
+function bodyHasJsonRpc(message) {
+  const raw = String(message.body_base64 ?? "");
+  if (!raw) return false;
+  let text = "";
+  try {
+    text = new TextDecoder().decode(decodeBase64Strict(raw));
+  } catch {
+    return false;
+  }
+  if (text.includes('"jsonrpc"') || text.includes("'jsonrpc'")) return true;
+  try {
+    const parsed = JSON.parse(text);
+    if (isRecord4(parsed)) return String(parsed.jsonrpc ?? "") === "2.0";
+    if (Array.isArray(parsed)) return parsed.some((item) => isRecord4(item) && String(item.jsonrpc ?? "") === "2.0");
+  } catch {
+  }
+  return false;
+}
+function backendHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const name = key.toLowerCase();
+    if (HOP_BY_HOP_HEADERS.has(name) || name === "host") continue;
+    result[name] = String(value);
+  }
+  return result;
+}
+function responseHeadersMap(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    const name = key.toLowerCase();
+    if (HOP_BY_HOP_HEADERS.has(name) || AUTO_RESPONSE_HEADERS.has(name)) return;
+    result[name] = value;
+  });
+  return result;
+}
+function isStreamResponseHeaders(headers) {
+  const contentType = String(headers["content-type"] ?? "").split(";", 1)[0].trim().toLowerCase();
+  const contentDisposition = String(headers["content-disposition"] ?? "").toLowerCase();
+  if (String(headers["content-type"] ?? "").toLowerCase().includes("text/event-stream")) return true;
+  if (FILE_CONTENT_TYPES.has(contentType)) return true;
+  if (contentType.startsWith("image/") || contentType.startsWith("video/")) return true;
+  return contentDisposition.includes("attachment");
+}
+function streamTypeFromResponse(headers, fallback) {
+  const contentType = String(headers["content-type"] ?? "").toLowerCase();
+  if (contentType.includes("text/event-stream")) return "sse";
+  if (isStreamResponseHeaders(headers)) return "file";
+  return String(fallback || "stream").trim().toLowerCase() || "stream";
+}
+function normalizePath(path) {
+  const text = String(path || "/");
+  return text.startsWith("/") ? text : `/${text}`;
+}
+function buildTargetUrl(endpoint, path, queryString) {
+  const base = endpoint.replace(/\/+$/g, "") + "/";
+  const url = new URL(path.replace(/^\/+/g, ""), base);
+  if (queryString) url.search = queryString.startsWith("?") ? queryString : `?${queryString}`;
+  return url.toString();
+}
+function errorMessage(requestId, code, message) {
+  return { type: "service_proxy_error", request_id: requestId, error: { code, message } };
+}
+function wsErrorMessage(connectionId, code, message) {
+  return { type: "ws_error", connection_id: connectionId, error: { code, message } };
+}
+function streamMessage(requestId, index, status, headers, data, done) {
+  return { type: "service_proxy_stream", request_id: requestId, index, status: index === 0 ? status : null, headers: index === 0 ? headers : {}, data_base64: encodeBase64(data), done };
+}
+function parseTunnelMessage(raw) {
+  if (raw === null) throw new ConnectionError("Service Proxy tunnel closed");
+  const parsed = JSON.parse(raw);
+  return isRecord4(parsed) ? parsed : {};
+}
+function waitForWsOpen(ws) {
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      ws.removeEventListener("open", onOpen);
+      ws.removeEventListener("error", onError);
+    };
+    const onOpen = (_event) => {
+      cleanup();
+      resolve();
+    };
+    const onError = (_event) => {
+      cleanup();
+      reject(new ConnectionError("websocket connect failed"));
+    };
+    ws.addEventListener("open", onOpen);
+    ws.addEventListener("error", onError);
+  });
+}
+async function* responseChunks(response, chunkSize) {
+  if (!response.body) {
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    for (let offset = 0; offset < bytes.length; offset += chunkSize) yield bytes.slice(offset, offset + chunkSize);
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      if (!value) continue;
+      for (let offset = 0; offset < value.length; offset += chunkSize) yield value.slice(offset, offset + chunkSize);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function readableStreamFromAsyncIterable(iterable) {
+  const iterator = iterable[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await iterator.next();
+      if (done) controller.close();
+      else controller.enqueue(value);
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  });
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeBase64(bytes) {
+  let out = "";
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + B64[n >> 6 & 63] + B64[n & 63];
+  }
+  if (i < bytes.length) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const n = a << 16 | b << 8;
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + (i + 1 < bytes.length ? B64[n >> 6 & 63] : "=") + "=";
+  }
+  return out;
+}
+function decodeBase64Strict(value) {
+  const text = String(value ?? "").trim();
+  if (!text) return new Uint8Array();
+  if (text.length % 4 === 1 || !/^[A-Za-z0-9+/]*={0,2}$/.test(text)) throw new Error("invalid base64");
+  const clean2 = text.replace(/=+$/g, "");
+  const bytes = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const ch of clean2) {
+    const v = B64.indexOf(ch);
+    if (v < 0) throw new Error("invalid base64");
+    buffer = buffer << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(buffer >> bits & 255);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function toExactArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+async function bytesFromWsData(data) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
+  return new TextEncoder().encode(String(data ?? ""));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/secret-store/index.ts
 async function createDefaultSecretStore(encryptionSeed) {
   const { IndexedDBSecretStore: IndexedDBSecretStore2 } = await Promise.resolve().then(() => (init_indexeddb_store(), indexeddb_store_exports));
@@ -18404,6 +19975,8 @@ export {
   E2EEGroupEpochMismatchError,
   E2EEGroupNotMemberError,
   E2EEGroupSecretMissingError,
+  EmbeddedServiceRegistry,
+  EndpointPolicy,
   EventDispatcher,
   GatewayDiscovery,
   GroupError,
@@ -18423,6 +19996,8 @@ export {
   STATE_PREFIX,
   SeedMigrationError,
   SerializationError,
+  ServiceProxyClient,
+  ServiceRecord,
   SessionError,
   StateError,
   Subscription,