grpc-libp2p-client 0.0.38 → 0.0.40

package/dist/index.esm.js

@@ -239,7 +239,6 @@ class HPACK {
             this.dynamicTable.unshift([name, value]);
             this.dynamicTableSize += size;
         }
-        this.dynamicTable.push([name, value]);
     }
     // 获取索引的头部
     getIndexedHeader(index) {
@@ -356,22 +355,29 @@ class HPACK {
     // Huffman编码实现  
     huffmanEncode(bytes) {
         const result = [];
+        // 使用高精度浮点数累积位，避免 JS 32-bit 有符号整数在位数 >31 时溢出。
+        // Huffman 码最长 30 bits，加上未输出的最多 7 bits = 37 bits，超过 32-bit 安全范围。
+        // Number 可精确表示 2^53 以内的整数，足够累积多个码字。
         let current = 0;
         let bits = 0;
         for (let i = 0; i < bytes.length; i++) {
             const b = bytes[i];
             const code = this.huffmanTable.codes[b];
             const length = this.huffmanTable.lengths[b];
+            // 用乘法左移替代 <<，避免 32-bit 截断
+            current = current * (1 << length) + code;
             bits += length;
-            current = (current << length) | code;
             while (bits >= 8) {
                 bits -= 8;
-                result.push((current >> bits) & 0xFF);
+                result.push(Math.floor(current / (1 << bits)) & 0xFF);
+                // 保留低 bits 位
+                current = current % (1 << bits);
             }
         }
-        // 处理剩余的位  
+        // 处理剩余的位（用 EOS 填充 1）
         if (bits > 0) {
-            current = (current << (8 - bits)) | ((1 << (8 - bits)) - 1);
+            const pad = 8 - bits;
+            current = current * (1 << pad) + ((1 << pad) - 1);
             result.push(current & 0xFF);
         }
         return new Uint8Array(result);
@@ -394,8 +400,16 @@ class HPACK {
                     headers.set(name, value);
                 index = newIndex;
             }
-            else if ((firstByte & 0x20) !== 0) { // 001xxxxx - Dynamic Table Size Update  
-                index++; // 简单跳过，实际应该更新动态表大小  
+            else if ((firstByte & 0x20) !== 0) { // 001xxxxx - Dynamic Table Size Update (RFC 7541 §6.3)
+                const [newSize, newIndex] = this.decodeInteger(buffer, index, 5);
+                this.maxDynamicTableSize = newSize;
+                // evict entries that exceed the new limit
+                while (this.dynamicTableSize > this.maxDynamicTableSize && this.dynamicTable.length > 0) {
+                    const entry = this.dynamicTable.pop();
+                    if (entry)
+                        this.dynamicTableSize -= entry[0].length + entry[1].length + 32;
+                }
+                index = newIndex;
             }
             else if ((firstByte & 0x10) !== 0) { // 0001xxxx - Literal Header Field Never Indexed  
                 const [name, value, newIndex] = this.decodeLiteralHeaderWithoutIndexing(buffer, index);
@@ -467,18 +481,18 @@ class HPACK {
         if (staticIndex <= 0) {
             return ['', '', newIndex];
         }
-        const headerField = this.staticTable[staticIndex];
+        const headerField = this.getIndexedHeader(staticIndex);
         if (!headerField) {
             return ['', '', newIndex];
         }
         return [headerField[0], headerField[1], newIndex];
     }
     decodeLiteralHeaderWithIndexing(buffer, index) {
-        const [staticIndex, nameIndex] = this.decodeInteger(buffer, index, 6);
-        index = nameIndex;
+        const [nameIndex, nextIndex] = this.decodeInteger(buffer, index, 6);
+        index = nextIndex;
         let name;
-        if (staticIndex > 0) {
-            const headerField = this.staticTable[staticIndex];
+        if (nameIndex > 0) {
+            const headerField = this.getIndexedHeader(nameIndex);
             name = headerField ? headerField[0] : '';
         }
         else {
@@ -487,10 +501,26 @@ class HPACK {
             index = newIndex;
         }
         const [value, finalIndex] = this.decodeLiteralString(buffer, index);
+        // RFC 7541 §6.2.1: Literal Header Field with Incremental Indexing must add to dynamic table
+        this.addToDynamicTable(name, value);
         return [name, value, finalIndex];
     }
     decodeLiteralHeaderWithoutIndexing(buffer, index) {
-        return this.decodeLiteralHeaderWithIndexing(buffer, index);
+        // RFC 7541 §6.2.2 / §6.2.3: 4-bit prefix, do NOT add to dynamic table
+        const [nameIndex, nextIndex] = this.decodeInteger(buffer, index, 4);
+        index = nextIndex;
+        let name;
+        if (nameIndex > 0) {
+            const headerField = this.getIndexedHeader(nameIndex);
+            name = headerField ? headerField[0] : '';
+        }
+        else {
+            const [decodedName, newIndex] = this.decodeLiteralString(buffer, index);
+            name = decodedName;
+            index = newIndex;
+        }
+        const [value, finalIndex] = this.decodeLiteralString(buffer, index);
+        return [name, value, finalIndex];
     }
     // 直接转换为字符串的方法  
     huffmanDecodeToString(bytes) {
@@ -578,9 +608,11 @@ const SETTINGS_PARAMETERS = {
 };
 const defaultSettings = {
     [SETTINGS_PARAMETERS.HEADER_TABLE_SIZE]: 4096,
-    [SETTINGS_PARAMETERS.ENABLE_PUSH]: 1,
+    // gRPC 客户端不使用 Server Push，禁用以避免无效的 PUSH_PROMISE 处理
+    [SETTINGS_PARAMETERS.ENABLE_PUSH]: 0,
     [SETTINGS_PARAMETERS.MAX_CONCURRENT_STREAMS]: 100,
-    [SETTINGS_PARAMETERS.INITIAL_WINDOW_SIZE]: 16 << 10, // 16k
+    // 匹配 parser 的实际接收缓冲区大小（4MB），避免服务端在单流上过早被限速
+    [SETTINGS_PARAMETERS.INITIAL_WINDOW_SIZE]: 4 << 20, // 4MB
     [SETTINGS_PARAMETERS.MAX_FRAME_SIZE]: 16 << 10, // 16k
     [SETTINGS_PARAMETERS.MAX_HEADER_LIST_SIZE]: 8192
 };
@@ -641,8 +673,8 @@ class Http2Frame {
         // Message-Data
         grpcMessage.set(data, 5);
         // 然后将完整的 gRPC 消息分割成多个 HTTP/2 DATA 帧
-        // HTTP/2 帧头为 9 字节
-        const maxDataPerFrame = maxFrameSize - 9;
+        // maxFrameSize 是 payload 上限（RFC 7540 §6.5.2 MAX_FRAME_SIZE），不含 9 字节帧头
+        const maxDataPerFrame = maxFrameSize;
         for (let offset = 0; offset < grpcMessage.length; offset += maxDataPerFrame) {
             const remaining = grpcMessage.length - offset;
             const chunkSize = Math.min(maxDataPerFrame, remaining);
@@ -674,13 +706,13 @@ class Http2Frame {
         const flags = endStream ? 0x01 : 0x0; // END_STREAM flag  
         return Http2Frame.createFrame(0x0, flags, streamId, framedData);
     }
-    static createHeadersFrame(streamId, path, endHeaders = true, token) {
+    static createHeadersFrame(streamId, path, endHeaders = true, token, authority = 'localhost') {
         // gRPC-Web 需要的标准 headers  
         const headersList = {
             ':path': path,
             ':method': 'POST',
             ':scheme': 'http',
-            ':authority': 'localhost',
+            ':authority': authority,
             'content-type': 'application/grpc+proto',
             'user-agent': 'grpc-web-client/0.1',
             'accept': 'application/grpc+proto',
@@ -807,8 +839,15 @@ function _createPayload(settings) {
 
 const HTTP2_PREFACE = new TextEncoder().encode("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
 class HTTP2Parser {
+    /** 兼容旧代码读取 buffer —— 仅在必须全量访问时调用 _flattenBuffer() */
+    get buffer() { return this._flattenBuffer(); }
+    set buffer(v) { this.bufferChunks = v.length ? [v] : []; this.bufferTotalLength = v.length; }
     constructor(writer, options) {
-        this.buffer = new Uint8Array(0);
+        /** 分段缓冲：避免每次 chunk 到达时 O(n) 全量拷贝 */
+        this.bufferChunks = [];
+        this.bufferTotalLength = 0;
+        this.bufferChunks = [];
+        this.bufferTotalLength = 0;
         this.settingsAckReceived = false;
         this.peerSettingsReceived = false;
         // 初始化连接级别的流控制窗口大小（默认值：65,535）
@@ -822,11 +861,38 @@ class HTTP2Parser {
         this.sendStreamWindows = new Map();
         this.peerInitialStreamWindow = 65535;
         this.sendWindowWaiters = [];
+        this.settingsAckWaiters = [];
+        this.peerSettingsWaiters = [];
+        this.endOfStreamWaiters = [];
         // 结束标志
         this.endFlag = false;
         this.writer = writer;
         this.compatibilityMode = options?.compatibilityMode ?? false;
     }
+    /** 将所有分段合并为一个连续 Uint8Array（仅在必要时调用）*/
+    _flattenBuffer() {
+        if (this.bufferChunks.length === 0)
+            return new Uint8Array(0);
+        if (this.bufferChunks.length === 1)
+            return this.bufferChunks[0];
+        const out = new Uint8Array(this.bufferTotalLength);
+        let off = 0;
+        for (const c of this.bufferChunks) {
+            out.set(c, off);
+            off += c.length;
+        }
+        return out;
+    }
+    /** 唤醒所有发送窗口等待者 */
+    _wakeWindowWaiters() {
+        const ws = this.sendWindowWaiters.splice(0);
+        for (const w of ws) {
+            try {
+                w.resolve();
+            }
+            catch { /* ignore */ }
+        }
+    }
     // 持续处理流数据
     async processStream(stream) {
         try {
@@ -836,7 +902,6 @@ class HTTP2Parser {
             }
             // Stream 结束后的清理工作
             if (!this.compatibilityMode && !this.endFlag) {
-                this.endFlag = true;
                 try {
                     this.onEnd?.();
                 }
@@ -844,51 +909,84 @@ class HTTP2Parser {
                     console.error("Error during onEnd callback:", err);
                 }
             }
+            // 无论何种模式，stream 结束时都通知 waitForEndOfStream 等待者，
+            // 防止 compatibilityMode=true（server-streaming）时 waitForEndOfStream(0) 永久挂死
+            if (!this.endFlag) {
+                this._notifyEndOfStream();
+            }
         }
         catch (error) {
-            console.error("Error processing stream:", error);
+            // abort() 触发的清理错误（如 'Call cleanup' / 'unaryCall cleanup'）属于预期行为，降级为 debug 日志
+            const errMsg = error instanceof Error ? error.message : String(error);
+            const isAbortCleanup = /cleanup/i.test(errMsg) || /aborted/i.test(errMsg);
+            if (isAbortCleanup) {
+                console.debug("[processStream] stream aborted (expected):", errMsg);
+            }
+            else {
+                console.error("Error processing stream:", error);
+            }
+            // 确保 waitForEndOfStream 等待者得到通知，防止 operationPromise 后台挂死
+            if (!this.endFlag) {
+                this._notifyEndOfStream();
+            }
             throw error;
         }
     }
-    // 处理单个数据块
+    // 处理单个数据块 — 分段列表追加，避免每次 O(n) 全量拷贝
     _processChunk(chunk) {
         // chunk 是 Uint8ArrayList 或 Uint8Array
         const newData = 'subarray' in chunk && typeof chunk.subarray === 'function'
             ? chunk.subarray()
             : chunk;
-        // 原作者之前的 O(N) 内存拷贝优化被保留，去掉了存在 onEnd 竞态的 setTimeout
-        const newBuffer = new Uint8Array(this.buffer.length + newData.length);
-        newBuffer.set(this.buffer);
-        newBuffer.set(newData, this.buffer.length);
-        this.buffer = newBuffer;
+        // 追加到分段列表，O(1)，不拷贝历史数据
+        if (newData.length > 0) {
+            this.bufferChunks.push(newData);
+            this.bufferTotalLength += newData.length;
+        }
+        // 将所有分段合并为一块后处理帧（只合并一次，后续 slice 替换）
+        // 仅在确实有完整帧时才触发合并，碎片仅 push 不合并
+        if (this.bufferTotalLength < 9)
+            return;
+        // 合并一次
+        const flat = this._flattenBuffer();
+        this.bufferChunks = [flat];
+        // bufferTotalLength 保持不变
         // 持续处理所有完整的帧
         let readOffset = 0;
-        while (this.buffer.length - readOffset >= 9) {
+        while (flat.length - readOffset >= 9) {
             // 判断是否有HTTP/2前导
-            if (this.buffer.length - readOffset >= 24 && this.isHttp2Preface(this.buffer.subarray(readOffset))) {
+            if (flat.length - readOffset >= 24 && this.isHttp2Preface(flat.subarray(readOffset))) {
                 readOffset += 24;
                 // 发送SETTINGS帧
                 const settingFrame = Http2Frame.createSettingsFrame();
                 this.writer.write(settingFrame);
                 continue;
             }
-            const frameHeader = this._parseFrameHeader(this.buffer.subarray(readOffset));
+            const frameHeader = this._parseFrameHeader(flat.subarray(readOffset));
             const totalFrameLength = 9 + frameHeader.length;
             // 检查是否有完整的帧
-            if (this.buffer.length - readOffset < totalFrameLength) {
+            if (flat.length - readOffset < totalFrameLength) {
                 break;
             }
-            // 获取完整帧数据
-            const frameData = this.buffer.subarray(readOffset, readOffset + totalFrameLength);
+            // 获取完整帧数据（subarray 视图，零拷贝）
+            const frameData = flat.subarray(readOffset, readOffset + totalFrameLength);
             // 处理不同类型的帧
             this._handleFrame(frameHeader, frameData).catch((err) => {
                 console.error("Error handling frame:", err);
             });
-            // 移动偏移量
             readOffset += totalFrameLength;
         }
+        // 保留未消费的尾部字节（slice 一次，后续仍分段追加）
         if (readOffset > 0) {
-            this.buffer = this.buffer.slice(readOffset);
+            if (readOffset >= flat.length) {
+                this.bufferChunks = [];
+                this.bufferTotalLength = 0;
+            }
+            else {
+                const remaining = flat.slice(readOffset);
+                this.bufferChunks = [remaining];
+                this.bufferTotalLength = remaining.length;
+            }
         }
     }
     isHttp2Preface(buffer) {
@@ -900,50 +998,67 @@ class HTTP2Parser {
         }
         return true;
     }
-    // 移除之前的 for await 循环代码
-    _oldProcessStream_removed() {
-        // 这个方法已被上面的事件驱动实现替代
-    }
-    // 等待SETTINGS ACK
+    // 等待SETTINGS ACK — 事件驱动，无轮询
     waitForSettingsAck() {
         return new Promise((resolve, reject) => {
             if (this.settingsAckReceived) {
                 resolve();
                 return;
             }
-            const interval = setInterval(() => {
-                if (this.settingsAckReceived) {
-                    clearInterval(interval);
-                    clearTimeout(timeout);
-                    resolve();
-                }
-            }, 100);
+            const waiter = { resolve, reject };
+            this.settingsAckWaiters.push(waiter);
             const timeout = setTimeout(() => {
-                clearInterval(interval);
+                const idx = this.settingsAckWaiters.indexOf(waiter);
+                if (idx >= 0)
+                    this.settingsAckWaiters.splice(idx, 1);
                 reject(new Error("Settings ACK timeout"));
             }, 30000);
+            // 覆盖 resolve 以便超时前自动清理定时器
+            waiter.resolve = () => { clearTimeout(timeout); resolve(); };
+            waiter.reject = (e) => { clearTimeout(timeout); reject(e); };
         });
     }
-    // 等待接收来自对端的 SETTINGS（非 ACK）
+    /** 内部调用：SETTINGS ACK 收到时唤醒所有等待者 */
+    _notifySettingsAck() {
+        this.settingsAckReceived = true;
+        const ws = this.settingsAckWaiters.splice(0);
+        for (const w of ws) {
+            try {
+                w.resolve();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    // 等待接收来自对端的 SETTINGS（非 ACK）— 事件驱动，无轮询
     waitForPeerSettings(timeoutMs = 30000) {
         return new Promise((resolve, reject) => {
             if (this.peerSettingsReceived) {
                 resolve();
                 return;
             }
-            const interval = setInterval(() => {
-                if (this.peerSettingsReceived) {
-                    clearInterval(interval);
-                    clearTimeout(timeout);
-                    resolve();
-                }
-            }, 100);
+            const waiter = { resolve, reject };
+            this.peerSettingsWaiters.push(waiter);
             const timeout = setTimeout(() => {
-                clearInterval(interval);
+                const idx = this.peerSettingsWaiters.indexOf(waiter);
+                if (idx >= 0)
+                    this.peerSettingsWaiters.splice(idx, 1);
                 reject(new Error("Peer SETTINGS timeout"));
             }, timeoutMs);
+            waiter.resolve = () => { clearTimeout(timeout); resolve(); };
+            waiter.reject = (e) => { clearTimeout(timeout); reject(e); };
         });
     }
+    /** 内部调用：收到对端 SETTINGS（非 ACK）时唤醒等待者 */
+    _notifyPeerSettings() {
+        this.peerSettingsReceived = true;
+        const ws = this.peerSettingsWaiters.splice(0);
+        for (const w of ws) {
+            try {
+                w.resolve();
+            }
+            catch { /* ignore */ }
+        }
+    }
     // 注册我们要发送数据的出站流（用于初始化该流的对端窗口）
     registerOutboundStream(streamId) {
         if (!this.sendStreamWindows.has(streamId)) {
@@ -970,54 +1085,51 @@ class HTTP2Parser {
         this.sendConnWindow = Math.min(0x7fffffff, this.sendConnWindow + bytes);
         const cur = this.sendStreamWindows.get(streamId) ?? 0;
         this.sendStreamWindows.set(streamId, Math.min(0x7fffffff, cur + bytes));
+        // 窗口增大，唤醒等待者
+        this._wakeWindowWaiters();
     }
-    // 等待可用发送窗口（两个窗口都需要 >0）
-    async waitForSendWindow(streamId, minBytes = 1, timeoutMs = 30000) {
-        const start = Date.now();
+    // 等待可用发送窗口 — 事件驱动，WINDOW_UPDATE/SETTINGS 收到时直接唤醒
+    waitForSendWindow(streamId, minBytes = 1, timeoutMs = 30000) {
+        const { conn, stream } = this.getSendWindows(streamId);
+        if (conn >= minBytes && stream >= minBytes)
+            return Promise.resolve();
         return new Promise((resolve, reject) => {
-            let interval = null;
             let settled = false;
-            const check = () => {
-                const { conn, stream } = this.getSendWindows(streamId);
-                if (conn >= minBytes && stream >= minBytes) {
-                    if (!settled) {
-                        settled = true;
-                        if (interval) {
-                            clearInterval(interval);
-                            interval = null;
-                        }
-                        resolve();
-                    }
-                    return true;
-                }
-                if (Date.now() - start > timeoutMs) {
-                    if (!settled) {
-                        settled = true;
-                        if (interval) {
-                            clearInterval(interval);
-                            interval = null;
-                        }
-                        reject(new Error('Send window wait timeout'));
-                    }
-                    return true;
+            const timeout = timeoutMs > 0
+                ? setTimeout(() => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    const idx = this.sendWindowWaiters.findIndex(w => w.resolve === resolveWrap);
+                    if (idx >= 0)
+                        this.sendWindowWaiters.splice(idx, 1);
+                    reject(new Error('Send window wait timeout'));
+                }, timeoutMs)
+                : undefined;
+            const resolveWrap = () => {
+                if (settled)
+                    return;
+                const { conn: c2, stream: s2 } = this.getSendWindows(streamId);
+                if (c2 >= minBytes && s2 >= minBytes) {
+                    settled = true;
+                    if (timeout)
+                        clearTimeout(timeout);
+                    resolve();
+                }
+                else {
+                    // 窗口仍不够，重新入队等待下一次更新
+                    this.sendWindowWaiters.push({ resolve: resolveWrap, reject: rejectWrap });
                 }
-                return false;
             };
-            if (check())
-                return;
-            const tick = () => {
-                if (!check()) ;
+            const rejectWrap = (e) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                reject(e);
             };
-            const wake = () => { tick(); };
-            // 简单的等待模型：依赖 WINDOW_UPDATE 到达时调用 wake
-            this.sendWindowWaiters.push(wake);
-            // 同时做一个轻微的轮询，防止错过唤醒
-            interval = setInterval(() => {
-                if (check() && interval) {
-                    clearInterval(interval);
-                    interval = null;
-                }
-            }, 50);
+            this.sendWindowWaiters.push({ resolve: resolveWrap, reject: rejectWrap });
         });
     }
     // 处理单个帧
@@ -1025,7 +1137,7 @@ class HTTP2Parser {
         switch (frameHeader.type) {
             case FRAME_TYPES.SETTINGS:
                 if ((frameHeader.flags & FRAME_FLAGS.ACK) === FRAME_FLAGS.ACK) {
-                    this.settingsAckReceived = true;
+                    this._notifySettingsAck();
                 }
                 else {
                     //接收到Setting请求,进行解析
@@ -1035,10 +1147,12 @@ class HTTP2Parser {
                     for (let i = 0; i < settingsPayload.length; i += 6) {
                         // 正确解析：2字节ID + 4字节值
                         const id = (settingsPayload[i] << 8) | settingsPayload[i + 1];
-                        const value = (settingsPayload[i + 2] << 24) |
+                        // >>> 0 将结果转为无符号 32 位整数，防止高位为 1 时（如 0xffffffff）
+                        // 被 JS 按有符号解读为负数，导致 maxConcurrentStreams 等字段为负值
+                        const value = ((settingsPayload[i + 2] << 24) |
                             (settingsPayload[i + 3] << 16) |
                             (settingsPayload[i + 4] << 8) |
-                            settingsPayload[i + 5];
+                            settingsPayload[i + 5]) >>> 0;
                         if (id === 4) {
                             // SETTINGS_INITIAL_WINDOW_SIZE
                             this.defaultStreamWindowSize = value; // 我方接收窗口（入站）
@@ -1075,47 +1189,47 @@ class HTTP2Parser {
                     if (this.onSettings) {
                         this.onSettings(frameHeader);
                     }
-                    // 标记已收到对端 SETTINGS
-                    this.peerSettingsReceived = true;
-                    // 唤醒等待窗口（以防部分实现通过 SETTINGS 改变有效窗口）
-                    const waiters = this.sendWindowWaiters.splice(0);
-                    waiters.forEach(fn => { try {
-                        fn();
-                    }
-                    catch (e) {
-                        console.debug('waiter error', e);
-                    } });
+                    // 标记已收到对端 SETTINGS 并唤醒等待者
+                    this._notifyPeerSettings();
+                    // 唤醒发送窗口等待者（以防部分实现通过 SETTINGS 改变有效窗口）
+                    this._wakeWindowWaiters();
                 }
                 break;
-            case FRAME_TYPES.DATA:
+            case FRAME_TYPES.DATA: {
                 // 处理数据帧
                 if (this.onData) {
                     this.onData(frameData.slice(9), frameHeader); // 跳过帧头
                 }
                 // 更新流窗口和连接窗口
-                try {
-                    // 更新流级别的窗口
-                    if (frameHeader.streamId !== 0) {
-                        const streamWindowUpdate = Http2Frame.createWindowUpdateFrame(frameHeader.streamId, frameHeader.length ?? 0);
-                        this.writer.write(streamWindowUpdate);
+                // 仅在帧有实际数据时才发送 WINDOW_UPDATE：
+                // RFC 7540 §6.9.1 明确禁止 increment=0 的 WINDOW_UPDATE，
+                // 服务端必须以 PROTOCOL_ERROR 响应，会导致连接被强制关闭。
+                // 空 DATA 帧（如纯 END_STREAM 帧）length=0，不需要归还窗口。
+                const dataLength = frameHeader.length ?? 0;
+                if (dataLength > 0) {
+                    try {
+                        // 更新流级别的窗口
+                        if (frameHeader.streamId !== 0) {
+                            const streamWindowUpdate = Http2Frame.createWindowUpdateFrame(frameHeader.streamId, dataLength);
+                            this.writer.write(streamWindowUpdate);
+                        }
+                        // 更新连接级别的窗口
+                        const connWindowUpdate = Http2Frame.createWindowUpdateFrame(0, dataLength);
+                        this.writer.write(connWindowUpdate);
+                    }
+                    catch (err) {
+                        console.error("[HTTP2] Error sending window update:", err);
                     }
-                    // 更新连接级别的窗口
-                    const connWindowUpdate = Http2Frame.createWindowUpdateFrame(0, frameHeader.length ?? 0);
-                    this.writer.write(connWindowUpdate);
-                }
-                catch (err) {
-                    console.error("[HTTP2] Error sending window update:", err);
                 }
                 //判断是否是最后一个帧
                 if ((frameHeader.flags & FRAME_FLAGS.END_STREAM) ===
                     FRAME_FLAGS.END_STREAM) {
-                    this.endFlag = true;
-                    if (this.onEnd) {
-                        this.onEnd();
-                    }
+                    this.onEnd?.();
+                    this._notifyEndOfStream();
                     return;
                 }
                 break;
+            }
             case FRAME_TYPES.HEADERS:
                 // 处理头部帧
                 if (this.onHeaders) {
@@ -1124,35 +1238,26 @@ class HTTP2Parser {
                 //判断是否是最后一个帧
                 if ((frameHeader.flags & FRAME_FLAGS.END_STREAM) ===
                     FRAME_FLAGS.END_STREAM) {
-                    this.endFlag = true;
-                    if (this.onEnd) {
-                        this.onEnd();
-                    }
+                    this.onEnd?.();
+                    this._notifyEndOfStream();
                     return;
                 }
                 break;
             case FRAME_TYPES.WINDOW_UPDATE:
-                // 处理窗口更新帧
-                this.handleWindowUpdateFrame(frameHeader, frameData);
-                // 更新发送窗口（对端接收窗口）
+                // 处理窗口更新帧（同时更新接收侧诊断计数器和发送侧流控窗口，只解析一次）
                 try {
-                    const inc = this.parseWindowUpdateFrame(frameData, frameHeader).windowSizeIncrement;
+                    const result = this.handleWindowUpdateFrame(frameHeader, frameData);
+                    // 更新发送方向窗口（对端的接收窗口）
                     if (frameHeader.streamId === 0) {
-                        this.sendConnWindow += inc;
+                        this.sendConnWindow += result.windowSizeIncrement;
                     }
                     else {
                         const cur = this.sendStreamWindows.get(frameHeader.streamId) ?? this.peerInitialStreamWindow;
-                        this.sendStreamWindows.set(frameHeader.streamId, cur + inc);
+                        this.sendStreamWindows.set(frameHeader.streamId, cur + result.windowSizeIncrement);
                     }
-                    const waiters = this.sendWindowWaiters.splice(0);
-                    waiters.forEach(fn => { try {
-                        fn();
-                    }
-                    catch (e) {
-                        console.debug('waiter error', e);
-                    } });
+                    this._wakeWindowWaiters();
                 }
-                catch { /* ignore WINDOW_UPDATE parse errors */ }
+                catch { /* ignore WINDOW_UPDATE parse errors (e.g. increment=0 is RFC PROTOCOL_ERROR) */ }
                 break;
             case FRAME_TYPES.PING:
                 // 处理PING帧
@@ -1181,13 +1286,13 @@ class HTTP2Parser {
                 catch (err) {
                     console.error('Error during GOAWAY callback:', err);
                 }
-                this.endFlag = true;
                 try {
                     this.onEnd?.();
                 }
                 catch (err) {
                     console.error('Error during GOAWAY onEnd callback:', err);
                 }
+                this._notifyEndOfStream();
                 break;
             }
             // case FRAME_TYPES.PUSH_PROMISE:
@@ -1195,10 +1300,8 @@ class HTTP2Parser {
             //     this.handlePushPromiseFrame(frameHeader, frameData);
             //     break;
             case FRAME_TYPES.RST_STREAM:
-                this.endFlag = true;
-                if (this.onEnd) {
-                    this.onEnd();
-                }
+                this.onEnd?.();
+                this._notifyEndOfStream();
                 break;
             default:
                 console.debug("Unknown frame type:", frameHeader.type);
@@ -1208,7 +1311,8 @@ class HTTP2Parser {
         const length = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
         const type = buffer[3];
         const flags = buffer[4];
-        const streamId = (buffer[5] << 24) | (buffer[6] << 16) | (buffer[7] << 8) | buffer[8];
+        // RFC 7540 §4.1: most significant bit is reserved and MUST be ignored on receipt
+        const streamId = ((buffer[5] << 24) | (buffer[6] << 16) | (buffer[7] << 8) | buffer[8]) & 0x7fffffff;
         return {
             length,
             type,
@@ -1237,52 +1341,40 @@ class HTTP2Parser {
             throw error;
         }
     }
-    //等待流结束
+    // 等待流结束 — 事件驱动，onEnd 触发时直接唤醒，无 setInterval 轮询
     waitForEndOfStream(waitTime) {
         return new Promise((resolve, reject) => {
-            // If the stream has already ended, resolve immediately
             if (this.endFlag) {
                 resolve();
                 return;
             }
-            // 如果是0 ,则不设置超时
-            let timeout = null;
-            if (waitTime > 0) {
-                timeout = setTimeout(() => {
-                    clearInterval(interval);
+            const waiter = { resolve, reject };
+            this.endOfStreamWaiters.push(waiter);
+            const timeout = waitTime > 0
+                ? setTimeout(() => {
+                    const idx = this.endOfStreamWaiters.indexOf(waiter);
+                    if (idx >= 0)
+                        this.endOfStreamWaiters.splice(idx, 1);
                     reject(new Error("End of stream timeout"));
-                }, waitTime);
-            }
-            // Check interval for real-time endFlag monitoring
-            const checkInterval = 100; // Check every 100 milliseconds
-            // Set an interval to check the endFlag regularly
-            const interval = setInterval(() => {
-                if (this.endFlag) {
-                    if (timeout !== null) {
-                        clearTimeout(timeout);
-                    }
-                    clearInterval(interval);
-                    resolve();
-                }
-            }, checkInterval);
-            // If the onEnd is triggered externally, it should now be marked manually
-            const originalOnEnd = this.onEnd;
-            this.onEnd = () => {
-                if (!this.endFlag) {
-                    // The external trigger may set endFlag; if not, handle here
-                    this.endFlag = true;
-                }
-                if (timeout !== null) {
-                    clearTimeout(timeout);
-                }
-                clearInterval(interval);
-                resolve();
-                if (originalOnEnd) {
-                    originalOnEnd(); // Call the original onEnd function if set
-                }
-            };
+                }, waitTime)
+                : null;
+            waiter.resolve = () => { if (timeout)
+                clearTimeout(timeout); resolve(); };
+            waiter.reject = (e) => { if (timeout)
+                clearTimeout(timeout); reject(e); };
         });
     }
+    /** 内部调用：流结束时唤醒所有 waitForEndOfStream 等待者 */
+    _notifyEndOfStream() {
+        this.endFlag = true;
+        const ws = this.endOfStreamWaiters.splice(0);
+        for (const w of ws) {
+            try {
+                w.resolve();
+            }
+            catch { /* ignore */ }
+        }
+    }
     // 解析 WINDOW_UPDATE 帧
     parseWindowUpdateFrame(frameBuffer, frameHeader) {
         // WINDOW_UPDATE帧的payload固定为4字节
@@ -1341,6 +1433,8 @@ class StreamWriter {
         this.lastBytesDrainedSeen = 0;
         this.lastBpWarnAt = 0;
         this.isHandlingError = false; // 防止重复错误处理
+        /** drain 事件驱动等待者，替代 flush() 中的 setInterval 轮询 */
+        this.drainWaiters = [];
         // 事件系统  
         this.listeners = new Map();
         // 验证 stream 参数
@@ -1442,8 +1536,9 @@ class StreamWriter {
                 // 使用 stream.send() 发送数据，返回 false 表示需要等待 drain
                 const canContinue = this.stream.send(chunk);
                 if (!canContinue) {
-                    // 等待 drain 事件
-                    await this.stream.onDrain();
+                    // 传入 abort signal，当流被 abort 时 onDrain() 会立即 reject，
+                    // 避免在 abort 路径下永久挂住
+                    await this.stream.onDrain({ signal: this.abortController.signal });
                 }
             }
             catch (err) {
@@ -1459,6 +1554,9 @@ class StreamWriter {
                 throw err;
             }
         }
+        // pipeline 正常结束（stream 关闭或 pushable 耗尽）—— 确保资源清理
+        // 若已通过 abort() 触发则 cleanup() 内部幂等处理
+        this.cleanup();
     }
     createTransform() {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -1480,6 +1578,16 @@ class StreamWriter {
                         self.lastDrainEventAt = now;
                         self.dispatchEvent(new CustomEvent('drain', { detail: { drained: self.bytesDrained, queueSize: self.queueSize } }));
                     }
+                    // 唤醒所有在等 flush() 或背压解除 的 drainWaiters（队列降低时就可唤醒）
+                    if (self.drainWaiters.length > 0) {
+                        const ws = self.drainWaiters.splice(0);
+                        for (const fn of ws) {
+                            try {
+                                fn();
+                            }
+                            catch { /* ignore */ }
+                        }
+                    }
                     // 记录本次已消耗字节，用于看门狗判断是否前进
                     self.lastBytesDrainedSeen = self.bytesDrained;
                 }
@@ -1491,10 +1599,11 @@ class StreamWriter {
         };
     }
     // 简单的卡顿看门狗：当队列长期高位且 bytesDrained 无进展时发出 stalled 事件
+    // 使用递归 setTimeout 而非 setInterval，避免标签页后台恢复时回调堆积导致 Violation
     startWatchdog(intervalMs = 500, stallMs = 1500) {
         if (this.watchdogTimer)
             return;
-        this.watchdogTimer = setInterval(() => {
+        const tick = () => {
             if (this.abortController.signal.aborted)
                 return;
             const baseThreshold = this.options.bufferSize * 0.7;
@@ -1505,7 +1614,13 @@ class StreamWriter {
                     if (!this.stallStartAt)
                         this.stallStartAt = now;
                     if (now - this.stallStartAt >= stallMs) {
-                        this.dispatchEvent(new CustomEvent('stalled', { detail: { queueSize: q, drained: this.bytesDrained, sinceMs: now - this.stallStartAt } }));
+                        // 异步触发事件，让当前 tick 立即返回，避免同步事件处理器阻塞主线程
+                        const detail = { queueSize: q, drained: this.bytesDrained, sinceMs: now - this.stallStartAt };
+                        setTimeout(() => {
+                            if (!this.abortController.signal.aborted) {
+                                this.dispatchEvent(new CustomEvent('stalled', { detail }));
+                            }
+                        }, 0);
                         // 避免持续触发，推进起点
                         this.stallStartAt = now;
                     }
@@ -1520,7 +1635,10 @@ class StreamWriter {
                 // 队列回落，重置
                 this.stallStartAt = 0;
             }
-        }, intervalMs);
+            // 本次 tick 完成后再安排下一次，不会因主线程繁忙而堆积
+            this.watchdogTimer = setTimeout(tick, intervalMs);
+        };
+        this.watchdogTimer = setTimeout(tick, intervalMs);
     }
     async write(data) {
         // 静默处理 aborted 状态，避免在正常的流关闭场景下抛出错误
@@ -1557,10 +1675,11 @@ class StreamWriter {
         return data;
     }
     async writeChunks(buffer) {
-        for (let offset = 0; offset < buffer.byteLength; offset += this.options.chunkSize) {
-            const end = Math.min(offset + this.options.chunkSize, buffer.byteLength);
-            const chunk = new Uint8Array(end - offset);
-            chunk.set(new Uint8Array(buffer.slice(offset, end)));
+        const src = new Uint8Array(buffer);
+        for (let offset = 0; offset < src.byteLength; offset += this.options.chunkSize) {
+            const end = Math.min(offset + this.options.chunkSize, src.byteLength);
+            // subarray 创建视图，不拷贝内存。pushable.push 不修改内容，安全。
+            const chunk = src.subarray(offset, end);
             await this.retryableWrite(chunk);
             this.updateProgress(chunk.byteLength);
         }
@@ -1581,18 +1700,12 @@ class StreamWriter {
             if (this.abortController.signal.aborted) {
                 throw new Error('Stream aborted during backpressure monitoring');
             }
-            await new Promise((resolve, reject) => {
-                try {
-                    this.p.push(chunk);
-                }
-                catch (err) {
-                    reject(err);
-                }
-                resolve();
-            });
+            // push 是同步操作，直接调用即可
+            this.p.push(chunk);
         }
         catch (err) {
-            if (attempt < this.options.retries) {
+            // aborted 时不重试，立即抛出
+            if (!this.abortController.signal.aborted && attempt < this.options.retries) {
                 const delay = this.calculateRetryDelay(attempt);
                 await new Promise(r => setTimeout(r, delay));
                 return this.retryableWrite(chunk, attempt + 1);
@@ -1601,58 +1714,45 @@ class StreamWriter {
         }
     }
     async monitorBackpressure() {
-        const currentSize = this.queueSize;
-        const baseThreshold = this.options.bufferSize * 0.7; // 降低基础阈值，更早检测
-        const criticalThreshold = this.options.bufferSize * 0.9; // 临界阈值
-        // 快速路径：无背压时直接返回
-        if (currentSize < baseThreshold) {
+        const baseThreshold = this.options.bufferSize * 0.7;
+        const criticalThreshold = this.options.bufferSize * 0.9;
+        // 快速路径
+        if (this.queueSize < baseThreshold) {
             if (this.isBackpressure) {
                 this.isBackpressure = false;
-                this.dispatchBackpressureEvent({
-                    currentSize,
-                    averageSize: this.getAverageQueueSize(),
-                    threshold: baseThreshold,
-                    waitingTime: 0
-                });
+                this.dispatchBackpressureEvent({ currentSize: this.queueSize, averageSize: this.getAverageQueueSize(), threshold: baseThreshold, waitingTime: 0 });
             }
             return;
         }
-        // 进入背压状态
         if (!this.isBackpressure) {
             this.isBackpressure = true;
-            this.dispatchBackpressureEvent({
-                currentSize,
-                averageSize: this.getAverageQueueSize(),
-                threshold: baseThreshold,
-                waitingTime: 0
-            });
-        }
-        // 智能等待策略
-        const pressure = currentSize / this.options.bufferSize;
-        let waitTime;
-        if (currentSize >= criticalThreshold) {
-            // 临界状态：长时间等待
-            waitTime = 50 + Math.min(200, pressure * 100);
-        }
-        else {
-            // 轻度背压：短时间等待
-            waitTime = Math.min(20, pressure * 30);
+            this.dispatchBackpressureEvent({ currentSize: this.queueSize, averageSize: this.getAverageQueueSize(), threshold: baseThreshold, waitingTime: 0 });
         }
-        // 使用指数退避，但最多等待3次
-        let retryCount = 0;
-        const maxRetries = 3;
-        while (this.queueSize >= baseThreshold && retryCount < maxRetries) {
+        // 事件驱动等待：每轮等到 drain 触发或超时，最多 3 轮
+        const maxRounds = 3;
+        for (let i = 0; i < maxRounds; i++) {
             if (this.abortController.signal.aborted)
                 break;
-            await new Promise(r => setTimeout(r, waitTime));
-            retryCount++;
-            // 动态调整等待时间
-            waitTime = Math.min(waitTime * 1.5, 100);
+            if (this.queueSize < baseThreshold)
+                break;
+            const isCritical = this.queueSize >= criticalThreshold;
+            const waitMs = isCritical ? 100 : 30;
+            await new Promise(resolve => {
+                let done = false;
+                const timer = setTimeout(() => { if (!done) {
+                    done = true;
+                    resolve();
+                } }, waitMs);
+                this.drainWaiters.push(() => { if (!done) {
+                    done = true;
+                    clearTimeout(timer);
+                    resolve();
+                } });
+            });
         }
-        // 如果仍然背压但达到最大重试次数，记录警告但继续执行
         if (this.queueSize >= baseThreshold) {
             const now = Date.now();
-            if (now - this.lastBpWarnAt > 1000) { // 节流警告
+            if (now - this.lastBpWarnAt > 1000) {
                 this.lastBpWarnAt = now;
                 console.warn(`Stream writer: High backpressure detected (${this.queueSize} bytes), continuing anyway`);
             }
@@ -1744,11 +1844,21 @@ class StreamWriter {
         if (!this.abortController.signal.aborted) {
             this.abortController.abort();
         }
-        // 立即拒绝所有待处理的写入任务，避免它们继续执行
+        // 执行所有待处理的写入任务：它们会检查 signal.aborted 并立即 resolve，
+        // 不执行的话调用方的 Promise 会永远挂住
         const pendingTasks = this.writeQueue.splice(0);
-        pendingTasks.forEach(() => {
-            // 这些任务的 Promise 会在执行时因为检查到 aborted 而被拒绝
-        });
+        for (const task of pendingTasks) {
+            task().catch(() => { });
+        }
+        // 唤醒所有 drainWaiters（flush / monitorBackpressure 中的等待者），
+        // 让它们检查 signal.aborted 并立即 resolve，不必等到各自的超时
+        const ws = this.drainWaiters.splice(0);
+        for (const fn of ws) {
+            try {
+                fn();
+            }
+            catch { /* ignore */ }
+        }
         try {
             this.p.end();
         }
@@ -1756,29 +1866,48 @@ class StreamWriter {
             // Ignore errors when ending pushable
         }
         if (this.watchdogTimer) {
-            clearInterval(this.watchdogTimer);
+            clearTimeout(this.watchdogTimer);
             this.watchdogTimer = undefined;
         }
     }
     // 等待内部队列被下游完全消费（用于在结束前确保尽量发送完数据）
     // 默认超时 10s，避免无限等待
     async flush(timeoutMs = 10000) {
-        const start = Date.now();
         // 快速路径
         if (this.queueSize <= 0 && !this.isProcessingQueue && this.writeQueue.length === 0)
             return;
-        // 轮询等待队列清空
-        while (true) {
-            if (this.abortController.signal.aborted)
-                return;
-            if (this.queueSize <= 0 && !this.isProcessingQueue && this.writeQueue.length === 0)
-                return;
-            if (Date.now() - start > timeoutMs) {
-                console.warn(`Stream writer: flush timeout with ${this.queueSize} bytes still queued`);
+        if (this.abortController.signal.aborted)
+            return;
+        await new Promise((resolve) => {
+            // 已经清空
+            if (this.queueSize <= 0 && !this.isProcessingQueue && this.writeQueue.length === 0) {
+                resolve();
                 return;
             }
-            await new Promise(r => setTimeout(r, 10));
-        }
+            let done = false;
+            const timer = setTimeout(() => {
+                if (!done) {
+                    done = true;
+                    console.warn(`Stream writer: flush timeout with ${this.queueSize} bytes still queued`);
+                    resolve();
+                }
+            }, timeoutMs);
+            // 由 createTransform 在每个 chunk 被下游消耗后唤醒
+            const check = () => {
+                if (this.abortController.signal.aborted || (this.queueSize <= 0 && !this.isProcessingQueue && this.writeQueue.length === 0)) {
+                    if (!done) {
+                        done = true;
+                        clearTimeout(timer);
+                        resolve();
+                    }
+                }
+                else {
+                    // 下次 drain 时再检查
+                    this.drainWaiters.push(check);
+                }
+            };
+            this.drainWaiters.push(check);
+        });
     }
     addEventListener(type, callback) {
         const handlers = this.listeners.get(type) || [];
@@ -2037,18 +2166,41 @@ class Libp2pGrpcClient {
     setToken(token) {
         this.token = token;
     }
+    /** 从 peerAddr 提取 HTTP/2 :authority 字段（host:port 格式） */
+    getAuthority() {
+        try {
+            const addr = this.peerAddr.toString();
+            const ip4 = addr.match(/\/ip4\/(\d[\d.]+)\/tcp\/(\d+)/);
+            if (ip4)
+                return `${ip4[1]}:${ip4[2]}`;
+            const ip6 = addr.match(/\/ip6\/([^/]+)\/tcp\/(\d+)/);
+            if (ip6)
+                return `[${ip6[1]}]:${ip6[2]}`;
+            const dns = addr.match(/\/dns(?:4|6)?\/([.\w-]+)\/tcp\/(\d+)/);
+            if (dns)
+                return `${dns[1]}:${dns[2]}`;
+        }
+        catch { /* ignore */ }
+        return 'localhost';
+    }
     async unaryCall(method, requestData, timeout = 30000) {
         let stream = null;
         let responseData = null;
         let responseBuffer = []; // 添加缓冲区来累积数据
         let responseDataExpectedLength = -1; // 当前响应的期望长度
+        /** 跨 DATA 帧的部分 gRPC 消息头缓冲（当一帧的 payload < 5 字节时积累） */
+        let headerPartialBuffer = [];
         const hpack = new HPACK();
         let exitFlag = false;
         let errMsg = "";
         let isResponseComplete = false; // 添加标志来标识响应是否完成
+        /** 事件驱动：响应完成时的唤醒函数 */
+        let notifyResponseComplete = null;
         let connection = null;
         let state = null;
         let streamSlotAcquired = false;
+        // 提升 writer 作用域到 finally 可访问，确保错误路径下也能调用 abort() 清理资源
+        let writerRef = null;
         try {
             // const stream = await this.node.dialProtocol(this.peerAddr, this.protocol)
             connection = await this.acquireConnection(false);
@@ -2072,6 +2224,7 @@ class Libp2pGrpcClient {
             const writer = new StreamWriter(stream, {
                 bufferSize: 16 * 1024 * 1024,
             });
+            writerRef = writer;
             try {
                 writer.addEventListener("backpressure", (e) => {
                     const d = e.detail || {};
@@ -2102,6 +2255,7 @@ class Libp2pGrpcClient {
                 }
                 exitFlag = true;
                 errMsg = `GOAWAY received: code=${info.errorCode}`;
+                notifyResponseComplete?.(); // 唤醒等待中的 Promise
                 try {
                     connection?.close();
                 }
@@ -2120,41 +2274,59 @@ class Libp2pGrpcClient {
             parser.registerOutboundStream(streamId);
             responseDataExpectedLength = -1; // 重置期望长度
             responseBuffer = []; // 重置缓冲区
+            headerPartialBuffer = []; // 重置跨帧头部缓冲
             parser.onData = (payload, frameHeader) => {
                 //接收数据
                 if (responseDataExpectedLength === -1) {
                     //grpc消息头部未读取
+                    // 如果有跨帧积累的部分头字节，先与本帧 payload 合并
+                    let effectivePayload = payload;
+                    if (headerPartialBuffer.length > 0) {
+                        headerPartialBuffer.push(payload);
+                        const totalLen = headerPartialBuffer.reduce((s, c) => s + c.length, 0);
+                        effectivePayload = new Uint8Array(totalLen);
+                        let off = 0;
+                        for (const c of headerPartialBuffer) {
+                            effectivePayload.set(c, off);
+                            off += c.length;
+                        }
+                        headerPartialBuffer = [];
+                    }
                     //提取gRPC消息头部
-                    if (payload.length < 5) {
+                    if (effectivePayload.length < 5) {
+                        // 头部字节不足 5，先缓存，等待后续帧补全
+                        headerPartialBuffer.push(effectivePayload);
                         return;
                     }
-                    const lengthBytes = payload.slice(1, 5); // 消息长度的4字节
-                    responseDataExpectedLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false); // big-endian
-                    if (responseDataExpectedLength < 0) {
-                        throw new Error("Invalid gRPC message length");
-                    }
-                    if (responseDataExpectedLength + 5 > payload.length) {
+                    const lengthBytes = effectivePayload.slice(1, 5); // 消息长度的4字节
+                    responseDataExpectedLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false); // big-endian（getUint32 返回无符号整数，结果不会为负）
+                    if (responseDataExpectedLength + 5 > effectivePayload.length) {
                         // 如果当前 payload 不足以包含完整的 gRPC 消息，缓存数据
-                        const grpcData = payload.subarray(5);
+                        const grpcData = effectivePayload.subarray(5);
                         responseBuffer.push(grpcData);
                         responseDataExpectedLength -= grpcData.length; // 更新期望长度
                         return;
                     }
                     else {
-                        // 如果当前 payload 足以包含完整的 gRPC 消息，重置缓冲区
-                        const grpcData = payload.subarray(5); // 提取完整的 gRPC 消息
+                        // payload 已包含完整的 gRPC 消息体，精确截取（避免尾部多余字节污染）
+                        const msgLen = responseDataExpectedLength;
+                        const grpcData = effectivePayload.slice(5, 5 + msgLen);
                         responseBuffer.push(grpcData);
                         responseData = grpcData;
                         isResponseComplete = true;
-                        responseDataExpectedLength = -1; // 重置期望长度
+                        responseDataExpectedLength = -1;
+                        notifyResponseComplete?.();
                     }
                 }
                 else if (responseDataExpectedLength > 0) {
                     //grpc消息头部已读取
-                    responseBuffer.push(payload); // 将数据添加到缓冲区
-                    responseDataExpectedLength -= payload.length; // 更新期望长度
+                    responseDataExpectedLength -= payload.length;
                     if (responseDataExpectedLength <= 0) {
-                        // 如果缓冲区中的数据已经完全处理，重置缓冲区
+                        // 超收时截掉多余字节
+                        const exactPayload = responseDataExpectedLength < 0
+                            ? payload.slice(0, payload.length + responseDataExpectedLength)
+                            : payload;
+                        responseBuffer.push(exactPayload);
                         responseData = new Uint8Array(responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0));
                         let offset = 0;
                         for (const chunk of responseBuffer) {
@@ -2162,41 +2334,36 @@ class Libp2pGrpcClient {
                             offset += chunk.length;
                         }
                         responseDataExpectedLength = -1;
-                        isResponseComplete = true; // 设置响应完成标志
+                        isResponseComplete = true;
+                        notifyResponseComplete?.();
                     }
-                }
-                // 检查是否是流的最后一个帧（END_STREAM 标志）
-                if (frameHeader && frameHeader.flags & 0x1 && !isResponseComplete) {
-                    // END_STREAM flag
-                    // 合并所有缓冲的数据
-                    const totalLength = responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0);
-                    responseData = new Uint8Array(totalLength);
-                    let offset = 0;
-                    for (const chunk of responseBuffer) {
-                        responseData.set(chunk, offset);
-                        offset += chunk.length;
+                    else {
+                        responseBuffer.push(payload); // 还不完整，继续累积
                     }
-                    isResponseComplete = true;
                 }
-            };
-            parser.onEnd = () => {
-                //接收结束
-                if (!isResponseComplete) {
-                    isResponseComplete = true; // 设置响应完成标志
-                    if (responseBuffer.length === 0) {
-                        responseData = new Uint8Array(); // 如果没有数据，返回空数组
-                    }
-                    else {
-                        // 合并所有缓冲的数据
-                        const totalLength = responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0);
+                // END_STREAM 兜底：数据路径已处理大多数情况；此分支仅在边缘情况下触发
+                if (frameHeader && frameHeader.flags & 0x1 && !isResponseComplete) {
+                    if (responseBuffer.length > 0) {
+                        const totalLength = responseBuffer.reduce((sum, c) => sum + c.length, 0);
                         responseData = new Uint8Array(totalLength);
                         let offset = 0;
                         for (const chunk of responseBuffer) {
                             responseData.set(chunk, offset);
                             offset += chunk.length;
                         }
-                        isResponseComplete = true;
                     }
+                    else {
+                        responseData = new Uint8Array(0);
+                    }
+                    isResponseComplete = true;
+                    notifyResponseComplete?.();
+                }
+            };
+            parser.onEnd = () => {
+                // 流结束时若响应未标记完成（空响应 / 纯 trailers），强制标记并唤醒等待者
+                if (!isResponseComplete) {
+                    isResponseComplete = true;
+                    notifyResponseComplete?.();
                 }
             };
             parser.onSettings = () => {
@@ -2212,6 +2379,7 @@ class Libp2pGrpcClient {
                 else if (plainHeaders.get("grpc-status") !== undefined) {
                     exitFlag = true;
                     errMsg = plainHeaders.get("grpc-message") || "gRPC call failed";
+                    notifyResponseComplete?.(); // 唤醒等待中的 Promise
                 }
             };
             // 启动后台流处理，捕获任何异步错误
@@ -2221,6 +2389,7 @@ class Libp2pGrpcClient {
                 if (!errMsg) {
                     errMsg = error instanceof Error ? error.message : 'Stream processing failed';
                 }
+                notifyResponseComplete?.(); // 流处理异常也需唤醒等待者
             });
             // 握手
             const preface = Http2Frame.createPreface();
@@ -2229,14 +2398,16 @@ class Libp2pGrpcClient {
             const settingFrme = Http2Frame.createSettingsFrame();
             await writer.write(settingFrme);
             // 等待对端 SETTINGS 或 ACK，择一即可，避免偶发握手竞态
+            // 注意：未胜出的 promise 内部有超时定时器，它们最终会 reject。
+            // 必须绑定 .catch(…) 消除错误，否则在 Node.js 新版本中会导致 UnhandledPromiseRejection 崩溃。
             await Promise.race([
-                parser.waitForPeerSettings(1000),
-                parser.waitForSettingsAck(),
+                parser.waitForPeerSettings(1000).catch(() => { }),
+                parser.waitForSettingsAck().catch(() => { }),
                 new Promise((res) => setTimeout(res, 300)),
             ]);
             // 即使未等到，也继续；多数实现会随后发送
             // 创建头部帧
-            const headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token);
+            const headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token, this.getAuthority());
             await writer.write(headerFrame);
             // 直接按帧大小分片发送（保持与之前一致的稳定路径）
             const dataFrames = Http2Frame.createDataFrames(streamId, requestData, true);
@@ -2244,22 +2415,21 @@ class Libp2pGrpcClient {
             for (const df of dataFrames) {
                 await this.sendFrameWithFlowControl(parser, streamId, df, writer, undefined, frameSendTimeout);
             }
-            // 等待responseData 不为空,或超时
+            // 等待 responseData 不为空，或超时（事件驱动，不轮询）
             await new Promise((resolve, reject) => {
+                if (isResponseComplete || exitFlag) {
+                    resolve();
+                    return;
+                }
                 const t = setTimeout(() => {
+                    notifyResponseComplete = null;
                     reject(new Error("gRPC response timeout"));
                 }, timeout);
-                const checkResponse = () => {
-                    if (isResponseComplete || exitFlag) {
-                        // 使用新的完成标志
-                        clearTimeout(t);
-                        resolve(responseData);
-                    }
-                    else {
-                        setTimeout(checkResponse, 50);
-                    }
+                notifyResponseComplete = () => {
+                    clearTimeout(t);
+                    notifyResponseComplete = null;
+                    resolve();
                 };
-                checkResponse();
             });
             try {
                 await writer.flush(timeout);
@@ -2272,8 +2442,18 @@ class Libp2pGrpcClient {
             throw err;
         }
         finally {
+            // 必须先 abort writer（立即强制停止 pushable + stream），再 close stream。
+            // 若顺序颠倒：stream.close() 会等待服务端半关闭确认，网络异常时永久挂住，
+            // 导致 writer.abort() 永远不执行 → watchdog 定时器 / pushable 泄漏。
+            // writer.abort() 内部幂等，成功路径下 writer.end() 已调用 cleanup()，安全。
+            writerRef?.abort('unaryCall cleanup');
             if (stream) {
-                await stream.close();
+                try {
+                    await stream.close();
+                }
+                catch {
+                    // 流已被 abort，close() 会立即抛出，忽略即可。
+                }
             }
             if (streamSlotAcquired && state) {
                 state.activeStreams = Math.max(0, state.activeStreams - 1);
@@ -2308,6 +2488,8 @@ class Libp2pGrpcClient {
         const internalController = new AbortController();
         let timeoutHandle;
         let stream = null;
+        // 保存外部 abort 监听器引用，以便操作结束后移除，防止内存泄漏
+        let contextAbortHandler;
         const profile = options?.transportProfile ?? this.getDefaultTransportProfile(mode);
         const useFlowControl = profile === "flow-control";
         // 取消函数 - 将在最后返回给调用者
@@ -2327,17 +2509,16 @@ class Libp2pGrpcClient {
         };
         // 如果提供了外部信号，监听它
         if (context?.signal) {
-            // 如果外部信号已经触发中止，立即返回
+            // 如果外部信号已经触发中止，立即返回——避免启动 IIFE 后在 catch 中再次调用 onErrorCallback
             if (context.signal.aborted) {
                 if (onErrorCallback) {
                     onErrorCallback(new Error("Operation aborted by context"));
                 }
-                cancelOperation();
+                return cancelOperation;
             }
-            // 监听外部的abort事件
-            context.signal.addEventListener("abort", () => {
-                cancelOperation();
-            });
+            // 监听外部的abort事件（保存引用以便后续移除，防止内存泄漏）
+            contextAbortHandler = () => { cancelOperation(); };
+            context.signal.addEventListener("abort", contextAbortHandler);
         }
         // 超时Promise
         const timeoutPromise = new Promise((_, reject) => {
@@ -2348,13 +2529,45 @@ class Libp2pGrpcClient {
         });
         // 主操作Promise
         const operationPromise = (async () => {
-            let messageBuffer = new Uint8Array(0); // 用于累积跨帧的消息数据
+            /**
+             * 统一错误报告：确保 onErrorCallback 只被调用一次，
+             * 并同时中止操作，防止后续再触发 onEndCallback。
+             * 适用于 onGoaway / onHeaders / processStream.catch / onData 等各个错误路径。
+             */
+            let errorCallbackFired = false;
+            const reportError = (err) => {
+                if (errorCallbackFired)
+                    return;
+                errorCallbackFired = true;
+                internalController.abort();
+                if (onErrorCallback)
+                    onErrorCallback(err);
+            };
+            /** 分段列表缓冲，避免每次 payload 到达时 O(n) 全量拷贝 */
+            let msgChunks = [];
+            let msgTotalLen = 0;
             let expectedMessageLength = -1; // 当前消息的期望长度
+            /** 将分段列表合并为单一 Uint8Array（仅在需要时调用） */
+            const flattenMsgBuffer = () => {
+                if (msgChunks.length === 0)
+                    return new Uint8Array(0);
+                if (msgChunks.length === 1)
+                    return msgChunks[0];
+                const out = new Uint8Array(msgTotalLen);
+                let off = 0;
+                for (const c of msgChunks) {
+                    out.set(c, off);
+                    off += c.length;
+                }
+                return out;
+            };
             const hpack = new HPACK();
             let connection = null;
             let connectionKey = null;
             let state = null;
             let streamSlotAcquired = false;
+            // 提升 writer 作用域到 finally 可访问，确保 unary/server-streaming 模式下也能清理资源
+            let writer = null;
             try {
                 // 检查是否已经中止
                 if (internalController.signal.aborted) {
@@ -2392,7 +2605,7 @@ class Libp2pGrpcClient {
                 });
                 const streamManager = this.getStreamManagerFor(connection);
                 const streamId = await streamManager.getNextAppLevelStreamId();
-                const writer = new StreamWriter(stream, {
+                writer = new StreamWriter(stream, {
                     bufferSize: 16 * 1024 * 1024,
                 });
                 try {
@@ -2427,10 +2640,8 @@ class Libp2pGrpcClient {
                     if (state) {
                         this.rejectStreamWaiters(state, new Error("Connection received GOAWAY"));
                     }
-                    if (onErrorCallback) {
-                        onErrorCallback(new Error(`GOAWAY received: code=${info.errorCode}`));
-                    }
-                    internalController.abort();
+                    // reportError 统一完成：标记已报错 + abort + 触发回调（幂等，不会重复触发）
+                    reportError(new Error(`GOAWAY received: code=${info.errorCode}`));
                     try {
                         connection?.close();
                     }
@@ -2468,52 +2679,43 @@ class Libp2pGrpcClient {
                 };
                 // 在各个回调中检查是否已中止
                 parser.onData = async (payload) => {
-                    // 检查是否已中止
-                    if (internalController.signal.aborted) {
+                    if (internalController.signal.aborted)
                         return;
-                    }
                     try {
-                        // 将新数据添加到消息缓冲区
-                        const newBuffer = new Uint8Array(messageBuffer.length + payload.length);
-                        newBuffer.set(messageBuffer);
-                        newBuffer.set(payload, messageBuffer.length);
-                        messageBuffer = newBuffer;
+                        // 追加到分段列表，O(1)，不拷贝历史数据
+                        msgChunks.push(payload);
+                        msgTotalLen += payload.length;
                         // 处理缓冲区中的完整消息
-                        while (messageBuffer.length > 0) {
-                            // 如果已经中止，停止处理
-                            if (internalController.signal.aborted) {
+                        while (msgTotalLen > 0) {
+                            if (internalController.signal.aborted)
                                 return;
+                            // 读取 gRPC 消息头（5字节）
+                            if (expectedMessageLength === -1 && msgTotalLen >= 5) {
+                                const flat = flattenMsgBuffer();
+                                msgChunks = [flat];
+                                const lengthBytes = flat.slice(1, 5);
+                                expectedMessageLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false);
                             }
-                            // 如果还没有读取消息长度，且缓冲区有足够数据
-                            if (expectedMessageLength === -1 && messageBuffer.length >= 5) {
-                                // 读取 gRPC 消息头：1字节压缩标志 + 4字节长度
-                                const lengthBytes = messageBuffer.slice(1, 5);
-                                expectedMessageLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false); // big-endian
-                            }
-                            // 如果知道期望长度且有足够数据
-                            if (expectedMessageLength !== -1 &&
-                                messageBuffer.length >= expectedMessageLength + 5) {
-                                // 提取完整消息（跳过5字节头部）
-                                const completeMessage = messageBuffer.slice(5, expectedMessageLength + 5);
-                                // 调用回调处理这个完整消息
+                            // 有完整消息
+                            if (expectedMessageLength !== -1 && msgTotalLen >= expectedMessageLength + 5) {
+                                const flat = flattenMsgBuffer();
+                                msgChunks = [flat];
+                                const completeMessage = flat.slice(5, expectedMessageLength + 5);
                                 onDataCallback(completeMessage);
-                                // 移除已处理的消息，保留剩余数据
-                                messageBuffer = messageBuffer.slice(expectedMessageLength + 5);
+                                // 移除已处理消息，保留剩余
+                                const remaining = flat.slice(expectedMessageLength + 5);
+                                msgChunks = remaining.length > 0 ? [remaining] : [];
+                                msgTotalLen = remaining.length;
                                 expectedMessageLength = -1;
                             }
                             else {
-                                // 没有足够数据构成完整消息，等待更多数据
                                 break;
                             }
                         }
                     }
                     catch (error) {
-                        if (onErrorCallback) {
-                            onErrorCallback(error);
-                        }
-                        else {
-                            throw error;
-                        }
+                        // reportError 统一报错并中止，防止 onEndCallback 在数据处理异常后仍被调用
+                        reportError(error);
                     }
                 };
                 parser.onSettings = () => {
@@ -2533,20 +2735,16 @@ class Libp2pGrpcClient {
                     }
                     else if (plainHeaders.get("grpc-status") !== undefined) {
                         const errMsg = plainHeaders.get("grpc-message") || "gRPC call failed";
-                        const err = new Error(errMsg);
-                        if (onErrorCallback) {
-                            onErrorCallback(err);
-                        }
-                        else {
-                            throw err;
-                        }
+                        // reportError 统一完成：标记已报错 + abort + 触发回调（幂等，不会重复触发）
+                        reportError(new Error(errMsg));
                     }
                 };
                 // 启动后台流处理
                 parser.processStream(stream).catch((error) => {
-                    console.error('Error in processStream:', error);
-                    if (onErrorCallback) {
-                        onErrorCallback(error);
+                    // abort() 触发的清理错误属于预期行为，不打印错误日志，不重复触发回调
+                    if (!internalController.signal.aborted) {
+                        console.error('Error in processStream:', error);
+                        reportError(error);
                     }
                 });
                 // 检查是否已中止
@@ -2568,10 +2766,12 @@ class Libp2pGrpcClient {
                     throw new Error("Operation aborted");
                 }
                 // 等待对端 SETTINGS 或 ACK，择一即可，避免偶发握手竞态
+                // 注意：未胜出的 promise 内部有超时定时器，它们最终会 reject。
+                // 必须绑定 .catch(…) 消除错误，否则在 Node.js 新版本中会导致 UnhandledPromiseRejection 崩溃。
                 {
                     await Promise.race([
-                        parser.waitForPeerSettings(1000),
-                        parser.waitForSettingsAck(),
+                        parser.waitForPeerSettings(1000).catch(() => { }),
+                        parser.waitForSettingsAck().catch(() => { }),
                         new Promise((res) => setTimeout(res, 300)),
                     ]);
                     // 即使未等到，也继续；多数实现会随后发送
@@ -2580,12 +2780,8 @@ class Libp2pGrpcClient {
                 if (internalController.signal.aborted) {
                     throw new Error("Operation aborted");
                 }
-                // 检查是否已中止
-                if (internalController.signal.aborted) {
-                    throw new Error("Operation aborted");
-                }
                 // Create header frame
-                const headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token);
+                const headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token, this.getAuthority());
                 if (mode === "unary" || mode === "server-streaming") {
                     await writer.write(headerFrame);
                     const dfs = Http2Frame.createDataFrames(streamId, requestData, true);
@@ -2610,7 +2806,18 @@ class Libp2pGrpcClient {
                     const batchSize = options?.batchSize || 10;
                     // 动态批处理器
                     const processingQueue = [];
+                    /** 事件驱动：批处理完成后唤醒 waitForQueue 等待者 */
+                    const batchDoneWaiters = [];
                     let isProcessing = false;
+                    const _notifyBatchDone = () => {
+                        const ws = batchDoneWaiters.splice(0);
+                        for (const fn of ws) {
+                            try {
+                                fn();
+                            }
+                            catch { /* ignore */ }
+                        }
+                    };
                     const processNextBatch = async () => {
                         if (isProcessing || processingQueue.length === 0)
                             return;
@@ -2654,10 +2861,13 @@ class Libp2pGrpcClient {
                         finally {
                             isProcessing = false;
                             // 如果队列中还有数据，继续处理
-                            if (processingQueue.length > 0 &&
-                                !internalController.signal.aborted) {
-                                // 使用 setTimeout 避免阻塞，让新数据有机会加入队列
-                                setTimeout(() => processNextBatch(), 0);
+                            if (processingQueue.length > 0 && !internalController.signal.aborted) {
+                                // 直接递归调用（已是 async，自动让出事件循环）
+                                processNextBatch().catch((err) => { console.error("Error in processNextBatch:", err); });
+                            }
+                            else {
+                                // 队列清空，唤醒等待者
+                                _notifyBatchDone();
                             }
                         }
                     };
@@ -2707,34 +2917,30 @@ class Libp2pGrpcClient {
                         });
                         throw error;
                     }
-                    // 等待所有剩余的数据处理完成，添加超时保护
-                    const queueWaitStart = Date.now();
-                    const maxQueueWaitMs = timeout; // 使用主超时时间
-                    while (processingQueue.length > 0 || isProcessing) {
-                        if (internalController.signal.aborted) {
-                            throw new Error("Operation aborted");
-                        }
-                        // 防止无限等待
-                        if (Date.now() - queueWaitStart > maxQueueWaitMs) {
-                            // 清理剩余队列
-                            const remainingQueue = processingQueue.splice(0);
-                            remainingQueue.forEach((item) => {
-                                try {
-                                    item.reject(new Error("Queue wait timeout"));
-                                }
-                                catch (err) {
-                                    console.warn("Error rejecting timeout promise:", err);
-                                }
-                            });
-                            throw new Error("Queue processing timeout");
-                        }
-                        await new Promise((resolve) => setTimeout(resolve, 10));
-                    }
+                    // 等待所有剩余的数据处理完成（事件驱动，无 10ms 轮询）
+                    await new Promise((resolve, reject) => {
+                        const check = () => {
+                            if (internalController.signal.aborted) {
+                                reject(new Error("Operation aborted"));
+                                return;
+                            }
+                            if (processingQueue.length === 0 && !isProcessing) {
+                                resolve();
+                                return;
+                            }
+                            // processNextBatch 结束时会通知这里
+                            batchDoneWaiters.push(check);
+                        };
+                        check();
+                    });
                     // 检查是否已中止
                     if (internalController.signal.aborted) {
                         throw new Error("Operation aborted");
                     }
-                    const finalFrame = Http2Frame.createDataFrame(streamId, new Uint8Array(), true);
+                    // 发送纯 HTTP/2 END_STREAM 信号帧（0 字节 payload），而非带 gRPC 消息头的空消息。
+                    // createDataFrame 会额外附加 5 字节 gRPC 消息头 [0,0,0,0,0]，服务端会将其解析
+                    // 为一个长度=0 的额外 gRPC 消息，而不仅仅是流结束信号，可能导致协议混淆。
+                    const finalFrame = Http2Frame.createFrame(0x0, 0x01, streamId, new Uint8Array(0));
                     await writeFrame(finalFrame);
                     // 在结束前尽量冲刷内部队列，避免服务器看到部分数据 + context canceled
                     try {
@@ -2747,9 +2953,24 @@ class Libp2pGrpcClient {
                 if (internalController.signal.aborted) {
                     throw new Error("Operation aborted");
                 }
-                await parser.waitForEndOfStream(0);
-                if (onEndCallback) {
-                    onEndCallback();
+                // 仅在未中止时等待并回调：
+                // 1. 若已中止（如 onHeaders gRPC 错误），跳过 waitForEndOfStream(0) 避免永久阻塞
+                //    （waitForEndOfStream(0) 无超时，需等到 processStream 自然结束，
+                //     而 processStream 结束依赖 stream.close()，但 stream.close() 在 finally 中——形成死锁）
+                // 2. 避免在 onErrorCallback 之后再调用 onEndCallback
+                if (!internalController.signal.aborted) {
+                    await parser.waitForEndOfStream(0);
+                    // Yield one microtask tick so that processStream.catch (which calls
+                    // reportError + internalController.abort()) has a chance to run before
+                    // we check abort status. Without this yield, if the stream died
+                    // unexpectedly (network error), onEndCallback and onErrorCallback
+                    // could both fire because _notifyEndOfStream() is called in
+                    // processStream's catch block before the re-throw schedules the
+                    // .catch handler as a microtask.
+                    await Promise.resolve();
+                    if (!internalController.signal.aborted && onEndCallback) {
+                        onEndCallback();
+                    }
                 }
             }
             catch (err) {
@@ -2757,14 +2978,16 @@ class Libp2pGrpcClient {
                 if (internalController.signal.aborted &&
                     err instanceof Error &&
                     err.message === "Operation aborted") {
-                    if (onErrorCallback) {
+                    // onHeaders / onGoaway / processStream 错误已通过 reportError 处理，
+                    // 此处仅在回调尚未触发时才报告（外部取消/超时场景）
+                    if (!errorCallbackFired && onErrorCallback) {
                         onErrorCallback(new Error("Operation cancelled by user"));
                     }
                 }
-                else if (onErrorCallback) {
+                else if (!errorCallbackFired && onErrorCallback) {
                     onErrorCallback(err);
                 }
-                else {
+                else if (!errorCallbackFired) {
                     if (err instanceof Error) {
                         console.error("asyncCall error:", err.message);
                     }
@@ -2775,12 +2998,21 @@ class Libp2pGrpcClient {
             }
             finally {
                 clearTimeout(timeoutHandle);
+                // 移除外部 abort 监听器，防止 AbortController 复用时触发迟到的 cancelOperation()
+                if (contextAbortHandler && context?.signal) {
+                    context.signal.removeEventListener("abort", contextAbortHandler);
+                }
+                // 必须先 abort writer（立即强制停止 pushable + stream），再 close stream。
+                // 若顺序颠倒：stream.close() 等待服务端半关闭确认，网络异常时永久挂住，
+                // writer.abort() 永远不执行 → watchdog / pushable 泄漏。
+                // abort() 内部幂等，重复调用安全。
+                writer?.abort('Call cleanup');
                 if (stream) {
                     try {
                         await stream.close();
                     }
-                    catch (err) {
-                        console.error("Error closing stream:", err);
+                    catch {
+                        // 流已被 abort，close() 会立即抛出，忽略即可。
                     }
                 }
                 // 如果本次强制使用了新连接，结束时尽量关闭它，避免连接泄漏