grpc-libp2p-client 0.0.38 → 0.0.40

package/dist/grpc.js

@@ -366,7 +366,6 @@
                 this.dynamicTable.unshift([name, value]);
                 this.dynamicTableSize += size;
             }
-            this.dynamicTable.push([name, value]);
         };
         // 获取索引的头部
         HPACK.prototype.getIndexedHeader = function (index) {
@@ -483,22 +482,29 @@
         // Huffman编码实现  
         HPACK.prototype.huffmanEncode = function (bytes) {
             var result = [];
+            // 使用高精度浮点数累积位，避免 JS 32-bit 有符号整数在位数 >31 时溢出。
+            // Huffman 码最长 30 bits，加上未输出的最多 7 bits = 37 bits，超过 32-bit 安全范围。
+            // Number 可精确表示 2^53 以内的整数，足够累积多个码字。
             var current = 0;
             var bits = 0;
             for (var i = 0; i < bytes.length; i++) {
                 var b = bytes[i];
                 var code = this.huffmanTable.codes[b];
                 var length_3 = this.huffmanTable.lengths[b];
+                // 用乘法左移替代 <<，避免 32-bit 截断
+                current = current * (1 << length_3) + code;
                 bits += length_3;
-                current = (current << length_3) | 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);
+                var pad = 8 - bits;
+                current = current * (1 << pad) + ((1 << pad) - 1);
                 result.push(current & 0xFF);
             }
             return new Uint8Array(result);
@@ -521,17 +527,25 @@
                         headers.set(name_3, 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)
+                    var _c = this.decodeInteger(buffer, index, 5), newSize = _c[0], newIndex = _c[1];
+                    this.maxDynamicTableSize = newSize;
+                    // evict entries that exceed the new limit
+                    while (this.dynamicTableSize > this.maxDynamicTableSize && this.dynamicTable.length > 0) {
+                        var 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  
-                    var _c = this.decodeLiteralHeaderWithoutIndexing(buffer, index), name_4 = _c[0], value = _c[1], newIndex = _c[2];
+                    var _d = this.decodeLiteralHeaderWithoutIndexing(buffer, index), name_4 = _d[0], value = _d[1], newIndex = _d[2];
                     if (name_4 && value)
                         headers.set(name_4, value);
                     index = newIndex;
                 }
                 else { // 0000xxxx - Literal Header Field without Indexing  
-                    var _d = this.decodeLiteralHeaderWithoutIndexing(buffer, index), name_5 = _d[0], value = _d[1], newIndex = _d[2];
+                    var _e = this.decodeLiteralHeaderWithoutIndexing(buffer, index), name_5 = _e[0], value = _e[1], newIndex = _e[2];
                     if (name_5 && value)
                         headers.set(name_5, value);
                     index = newIndex;
@@ -594,18 +608,18 @@
             if (staticIndex <= 0) {
                 return ['', '', newIndex];
             }
-            var headerField = this.staticTable[staticIndex];
+            var headerField = this.getIndexedHeader(staticIndex);
             if (!headerField) {
                 return ['', '', newIndex];
             }
             return [headerField[0], headerField[1], newIndex];
         };
         HPACK.prototype.decodeLiteralHeaderWithIndexing = function (buffer, index) {
-            var _a = this.decodeInteger(buffer, index, 6), staticIndex = _a[0], nameIndex = _a[1];
-            index = nameIndex;
+            var _a = this.decodeInteger(buffer, index, 6), nameIndex = _a[0], nextIndex = _a[1];
+            index = nextIndex;
             var name;
-            if (staticIndex > 0) {
-                var headerField = this.staticTable[staticIndex];
+            if (nameIndex > 0) {
+                var headerField = this.getIndexedHeader(nameIndex);
                 name = headerField ? headerField[0] : '';
             }
             else {
@@ -614,10 +628,26 @@
                 index = newIndex;
             }
             var _c = this.decodeLiteralString(buffer, index), value = _c[0], finalIndex = _c[1];
+            // RFC 7541 §6.2.1: Literal Header Field with Incremental Indexing must add to dynamic table
+            this.addToDynamicTable(name, value);
             return [name, value, finalIndex];
         };
         HPACK.prototype.decodeLiteralHeaderWithoutIndexing = function (buffer, index) {
-            return this.decodeLiteralHeaderWithIndexing(buffer, index);
+            // RFC 7541 §6.2.2 / §6.2.3: 4-bit prefix, do NOT add to dynamic table
+            var _a = this.decodeInteger(buffer, index, 4), nameIndex = _a[0], nextIndex = _a[1];
+            index = nextIndex;
+            var name;
+            if (nameIndex > 0) {
+                var headerField = this.getIndexedHeader(nameIndex);
+                name = headerField ? headerField[0] : '';
+            }
+            else {
+                var _b = this.decodeLiteralString(buffer, index), decodedName = _b[0], newIndex = _b[1];
+                name = decodedName;
+                index = newIndex;
+            }
+            var _c = this.decodeLiteralString(buffer, index), value = _c[0], finalIndex = _c[1];
+            return [name, value, finalIndex];
         };
         // 直接转换为字符串的方法  
         HPACK.prototype.huffmanDecodeToString = function (bytes) {
@@ -711,9 +741,11 @@
     };
     var defaultSettings = (_a = {},
         _a[SETTINGS_PARAMETERS.HEADER_TABLE_SIZE] = 4096,
-        _a[SETTINGS_PARAMETERS.ENABLE_PUSH] = 1,
+        // gRPC 客户端不使用 Server Push，禁用以避免无效的 PUSH_PROMISE 处理
+        _a[SETTINGS_PARAMETERS.ENABLE_PUSH] = 0,
         _a[SETTINGS_PARAMETERS.MAX_CONCURRENT_STREAMS] = 100,
-        _a[SETTINGS_PARAMETERS.INITIAL_WINDOW_SIZE] = 16 << 10,
+        // 匹配 parser 的实际接收缓冲区大小（4MB），避免服务端在单流上过早被限速
+        _a[SETTINGS_PARAMETERS.INITIAL_WINDOW_SIZE] = 4 << 20,
         _a[SETTINGS_PARAMETERS.MAX_FRAME_SIZE] = 16 << 10,
         _a[SETTINGS_PARAMETERS.MAX_HEADER_LIST_SIZE] = 8192,
         _a);
@@ -779,8 +811,8 @@
             // Message-Data
             grpcMessage.set(data, 5);
             // 然后将完整的 gRPC 消息分割成多个 HTTP/2 DATA 帧
-            // HTTP/2 帧头为 9 字节
-            var maxDataPerFrame = maxFrameSize - 9;
+            // maxFrameSize 是 payload 上限（RFC 7540 §6.5.2 MAX_FRAME_SIZE），不含 9 字节帧头
+            var maxDataPerFrame = maxFrameSize;
             for (var offset = 0; offset < grpcMessage.length; offset += maxDataPerFrame) {
                 var remaining = grpcMessage.length - offset;
                 var chunkSize = Math.min(maxDataPerFrame, remaining);
@@ -813,14 +845,15 @@
             var flags = endStream ? 0x01 : 0x0; // END_STREAM flag  
             return Http2Frame.createFrame(0x0, flags, streamId, framedData);
         };
-        Http2Frame.createHeadersFrame = function (streamId, path, endHeaders, token) {
+        Http2Frame.createHeadersFrame = function (streamId, path, endHeaders, token, authority) {
             if (endHeaders === void 0) { endHeaders = true; }
+            if (authority === void 0) { authority = 'localhost'; }
             // gRPC-Web 需要的标准 headers  
             var 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',
@@ -954,7 +987,11 @@
     var HTTP2Parser = /** @class */ (function () {
         function HTTP2Parser(writer, options) {
             var _a;
-            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）
@@ -968,15 +1005,51 @@
             this.sendStreamWindows = new Map();
             this.peerInitialStreamWindow = 65535;
             this.sendWindowWaiters = [];
+            this.settingsAckWaiters = [];
+            this.peerSettingsWaiters = [];
+            this.endOfStreamWaiters = [];
             // 结束标志
             this.endFlag = false;
             this.writer = writer;
             this.compatibilityMode = (_a = options === null || options === void 0 ? void 0 : options.compatibilityMode) !== null && _a !== void 0 ? _a : false;
         }
+        Object.defineProperty(HTTP2Parser.prototype, "buffer", {
+            /** 兼容旧代码读取 buffer —— 仅在必须全量访问时调用 _flattenBuffer() */
+            get: function () { return this._flattenBuffer(); },
+            set: function (v) { this.bufferChunks = v.length ? [v] : []; this.bufferTotalLength = v.length; },
+            enumerable: false,
+            configurable: true
+        });
+        /** 将所有分段合并为一个连续 Uint8Array（仅在必要时调用）*/
+        HTTP2Parser.prototype._flattenBuffer = function () {
+            if (this.bufferChunks.length === 0)
+                return new Uint8Array(0);
+            if (this.bufferChunks.length === 1)
+                return this.bufferChunks[0];
+            var out = new Uint8Array(this.bufferTotalLength);
+            var off = 0;
+            for (var _i = 0, _a = this.bufferChunks; _i < _a.length; _i++) {
+                var c = _a[_i];
+                out.set(c, off);
+                off += c.length;
+            }
+            return out;
+        };
+        /** 唤醒所有发送窗口等待者 */
+        HTTP2Parser.prototype._wakeWindowWaiters = function () {
+            var ws = this.sendWindowWaiters.splice(0);
+            for (var _i = 0, ws_1 = ws; _i < ws_1.length; _i++) {
+                var w = ws_1[_i];
+                try {
+                    w.resolve();
+                }
+                catch ( /* ignore */_a) { /* ignore */ }
+            }
+        };
         // 持续处理流数据
         HTTP2Parser.prototype.processStream = function (stream) {
             return __awaiter(this, void 0, void 0, function () {
-                var chunk, e_1_1, error_1;
+                var chunk, e_1_1, error_1, errMsg, isAbortCleanup;
                 var _a, stream_1, stream_1_1;
                 var _b, e_1, _c, _d;
                 var _e;
@@ -1020,7 +1093,6 @@
                         case 12:
                             // Stream 结束后的清理工作
                             if (!this.compatibilityMode && !this.endFlag) {
-                                this.endFlag = true;
                                 try {
                                     (_e = this.onEnd) === null || _e === void 0 ? void 0 : _e.call(this);
                                 }
@@ -1028,55 +1100,87 @@
                                     console.error("Error during onEnd callback:", err);
                                 }
                             }
+                            // 无论何种模式，stream 结束时都通知 waitForEndOfStream 等待者，
+                            // 防止 compatibilityMode=true（server-streaming）时 waitForEndOfStream(0) 永久挂死
+                            if (!this.endFlag) {
+                                this._notifyEndOfStream();
+                            }
                             return [3 /*break*/, 14];
                         case 13:
                             error_1 = _f.sent();
-                            console.error("Error processing stream:", error_1);
+                            errMsg = error_1 instanceof Error ? error_1.message : String(error_1);
+                            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_1);
+                            }
+                            // 确保 waitForEndOfStream 等待者得到通知，防止 operationPromise 后台挂死
+                            if (!this.endFlag) {
+                                this._notifyEndOfStream();
+                            }
                             throw error_1;
                         case 14: return [2 /*return*/];
                     }
                 });
             });
         };
-        // 处理单个数据块
+        // 处理单个数据块 — 分段列表追加，避免每次 O(n) 全量拷贝
         HTTP2Parser.prototype._processChunk = function (chunk) {
             // chunk 是 Uint8ArrayList 或 Uint8Array
             var newData = 'subarray' in chunk && typeof chunk.subarray === 'function'
                 ? chunk.subarray()
                 : chunk;
-            // 原作者之前的 O(N) 内存拷贝优化被保留，去掉了存在 onEnd 竞态的 setTimeout
-            var 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;
+            // 合并一次
+            var flat = this._flattenBuffer();
+            this.bufferChunks = [flat];
+            // bufferTotalLength 保持不变
             // 持续处理所有完整的帧
             var 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帧
                     var settingFrame = Http2Frame.createSettingsFrame();
                     this.writer.write(settingFrame);
                     continue;
                 }
-                var frameHeader = this._parseFrameHeader(this.buffer.subarray(readOffset));
+                var frameHeader = this._parseFrameHeader(flat.subarray(readOffset));
                 var totalFrameLength = 9 + frameHeader.length;
                 // 检查是否有完整的帧
-                if (this.buffer.length - readOffset < totalFrameLength) {
+                if (flat.length - readOffset < totalFrameLength) {
                     break;
                 }
-                // 获取完整帧数据
-                var frameData = this.buffer.subarray(readOffset, readOffset + totalFrameLength);
+                // 获取完整帧数据（subarray 视图，零拷贝）
+                var frameData = flat.subarray(readOffset, readOffset + totalFrameLength);
                 // 处理不同类型的帧
                 this._handleFrame(frameHeader, frameData).catch(function (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 {
+                    var remaining = flat.slice(readOffset);
+                    this.bufferChunks = [remaining];
+                    this.bufferTotalLength = remaining.length;
+                }
             }
         };
         HTTP2Parser.prototype.isHttp2Preface = function (buffer) {
@@ -1088,11 +1192,7 @@
             }
             return true;
         };
-        // 移除之前的 for await 循环代码
-        HTTP2Parser.prototype._oldProcessStream_removed = function () {
-            // 这个方法已被上面的事件驱动实现替代
-        };
-        // 等待SETTINGS ACK
+        // 等待SETTINGS ACK — 事件驱动，无轮询
         HTTP2Parser.prototype.waitForSettingsAck = function () {
             var _this = this;
             return new Promise(function (resolve, reject) {
@@ -1100,20 +1200,32 @@
                     resolve();
                     return;
                 }
-                var interval = setInterval(function () {
-                    if (_this.settingsAckReceived) {
-                        clearInterval(interval);
-                        clearTimeout(timeout);
-                        resolve();
-                    }
-                }, 100);
+                var waiter = { resolve: resolve, reject: reject };
+                _this.settingsAckWaiters.push(waiter);
                 var timeout = setTimeout(function () {
-                    clearInterval(interval);
+                    var idx = _this.settingsAckWaiters.indexOf(waiter);
+                    if (idx >= 0)
+                        _this.settingsAckWaiters.splice(idx, 1);
                     reject(new Error("Settings ACK timeout"));
                 }, 30000);
+                // 覆盖 resolve 以便超时前自动清理定时器
+                waiter.resolve = function () { clearTimeout(timeout); resolve(); };
+                waiter.reject = function (e) { clearTimeout(timeout); reject(e); };
             });
         };
-        // 等待接收来自对端的 SETTINGS（非 ACK）
+        /** 内部调用：SETTINGS ACK 收到时唤醒所有等待者 */
+        HTTP2Parser.prototype._notifySettingsAck = function () {
+            this.settingsAckReceived = true;
+            var ws = this.settingsAckWaiters.splice(0);
+            for (var _i = 0, ws_2 = ws; _i < ws_2.length; _i++) {
+                var w = ws_2[_i];
+                try {
+                    w.resolve();
+                }
+                catch ( /* ignore */_a) { /* ignore */ }
+            }
+        };
+        // 等待接收来自对端的 SETTINGS（非 ACK）— 事件驱动，无轮询
         HTTP2Parser.prototype.waitForPeerSettings = function (timeoutMs) {
             var _this = this;
             if (timeoutMs === void 0) { timeoutMs = 30000; }
@@ -1122,19 +1234,30 @@
                     resolve();
                     return;
                 }
-                var interval = setInterval(function () {
-                    if (_this.peerSettingsReceived) {
-                        clearInterval(interval);
-                        clearTimeout(timeout);
-                        resolve();
-                    }
-                }, 100);
+                var waiter = { resolve: resolve, reject: reject };
+                _this.peerSettingsWaiters.push(waiter);
                 var timeout = setTimeout(function () {
-                    clearInterval(interval);
+                    var idx = _this.peerSettingsWaiters.indexOf(waiter);
+                    if (idx >= 0)
+                        _this.peerSettingsWaiters.splice(idx, 1);
                     reject(new Error("Peer SETTINGS timeout"));
                 }, timeoutMs);
+                waiter.resolve = function () { clearTimeout(timeout); resolve(); };
+                waiter.reject = function (e) { clearTimeout(timeout); reject(e); };
             });
         };
+        /** 内部调用：收到对端 SETTINGS（非 ACK）时唤醒等待者 */
+        HTTP2Parser.prototype._notifyPeerSettings = function () {
+            this.peerSettingsReceived = true;
+            var ws = this.peerSettingsWaiters.splice(0);
+            for (var _i = 0, ws_3 = ws; _i < ws_3.length; _i++) {
+                var w = ws_3[_i];
+                try {
+                    w.resolve();
+                }
+                catch ( /* ignore */_a) { /* ignore */ }
+            }
+        };
         // 注册我们要发送数据的出站流（用于初始化该流的对端窗口）
         HTTP2Parser.prototype.registerOutboundStream = function (streamId) {
             if (!this.sendStreamWindows.has(streamId)) {
@@ -1164,75 +1287,67 @@
             this.sendConnWindow = Math.min(0x7fffffff, this.sendConnWindow + bytes);
             var cur = (_a = this.sendStreamWindows.get(streamId)) !== null && _a !== void 0 ? _a : 0;
             this.sendStreamWindows.set(streamId, Math.min(0x7fffffff, cur + bytes));
+            // 窗口增大，唤醒等待者
+            this._wakeWindowWaiters();
         };
-        // 等待可用发送窗口（两个窗口都需要 >0）
-        HTTP2Parser.prototype.waitForSendWindow = function (streamId_1) {
-            return __awaiter(this, arguments, void 0, function (streamId, minBytes, timeoutMs) {
-                var start;
-                var _this = this;
-                if (minBytes === void 0) { minBytes = 1; }
-                if (timeoutMs === void 0) { timeoutMs = 30000; }
-                return __generator(this, function (_a) {
-                    start = Date.now();
-                    return [2 /*return*/, new Promise(function (resolve, reject) {
-                            var interval = null;
-                            var settled = false;
-                            var check = function () {
-                                var _a = _this.getSendWindows(streamId), conn = _a.conn, stream = _a.stream;
-                                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;
-                                }
-                                return false;
-                            };
-                            if (check())
-                                return;
-                            var tick = function () {
-                                if (!check()) ;
-                            };
-                            var wake = function () { tick(); };
-                            // 简单的等待模型：依赖 WINDOW_UPDATE 到达时调用 wake
-                            _this.sendWindowWaiters.push(wake);
-                            // 同时做一个轻微的轮询，防止错过唤醒
-                            interval = setInterval(function () {
-                                if (check() && interval) {
-                                    clearInterval(interval);
-                                    interval = null;
-                                }
-                            }, 50);
-                        })];
-                });
+        // 等待可用发送窗口 — 事件驱动，WINDOW_UPDATE/SETTINGS 收到时直接唤醒
+        HTTP2Parser.prototype.waitForSendWindow = function (streamId, minBytes, timeoutMs) {
+            var _this = this;
+            if (minBytes === void 0) { minBytes = 1; }
+            if (timeoutMs === void 0) { timeoutMs = 30000; }
+            var _a = this.getSendWindows(streamId), conn = _a.conn, stream = _a.stream;
+            if (conn >= minBytes && stream >= minBytes)
+                return Promise.resolve();
+            return new Promise(function (resolve, reject) {
+                var settled = false;
+                var timeout = timeoutMs > 0
+                    ? setTimeout(function () {
+                        if (settled)
+                            return;
+                        settled = true;
+                        var idx = _this.sendWindowWaiters.findIndex(function (w) { return w.resolve === resolveWrap; });
+                        if (idx >= 0)
+                            _this.sendWindowWaiters.splice(idx, 1);
+                        reject(new Error('Send window wait timeout'));
+                    }, timeoutMs)
+                    : undefined;
+                var resolveWrap = function () {
+                    if (settled)
+                        return;
+                    var _a = _this.getSendWindows(streamId), c2 = _a.conn, s2 = _a.stream;
+                    if (c2 >= minBytes && s2 >= minBytes) {
+                        settled = true;
+                        if (timeout)
+                            clearTimeout(timeout);
+                        resolve();
+                    }
+                    else {
+                        // 窗口仍不够，重新入队等待下一次更新
+                        _this.sendWindowWaiters.push({ resolve: resolveWrap, reject: rejectWrap });
+                    }
+                };
+                var rejectWrap = function (e) {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (timeout)
+                        clearTimeout(timeout);
+                    reject(e);
+                };
+                _this.sendWindowWaiters.push({ resolve: resolveWrap, reject: rejectWrap });
             });
         };
         // 处理单个帧
         HTTP2Parser.prototype._handleFrame = function (frameHeader, frameData) {
             return __awaiter(this, void 0, void 0, function () {
-                var settingsPayload, settings, initialWindowDelta_1, maxConcurrentStreams, i, id, value, payload, waiters, streamWindowUpdate, connWindowUpdate, inc, cur, waiters, info, body, view, lastStreamId, errorCode;
+                var settingsPayload, settings, initialWindowDelta_1, maxConcurrentStreams, i, id, value, payload, dataLength, streamWindowUpdate, connWindowUpdate, result, cur, info, body, view, lastStreamId, errorCode;
                 var _this = this;
-                var _a, _b, _c, _d, _e;
-                return __generator(this, function (_f) {
+                var _a, _b, _c, _d, _e, _f, _g;
+                return __generator(this, function (_h) {
                     switch (frameHeader.type) {
                         case FRAME_TYPES.SETTINGS:
                             if ((frameHeader.flags & FRAME_FLAGS.ACK) === FRAME_FLAGS.ACK) {
-                                this.settingsAckReceived = true;
+                                this._notifySettingsAck();
                             }
                             else {
                                 settingsPayload = frameData.slice(9);
@@ -1241,10 +1356,10 @@
                                 maxConcurrentStreams = void 0;
                                 for (i = 0; i < settingsPayload.length; i += 6) {
                                     id = (settingsPayload[i] << 8) | settingsPayload[i + 1];
-                                    value = (settingsPayload[i + 2] << 24) |
+                                    value = ((settingsPayload[i + 2] << 24) |
                                         (settingsPayload[i + 3] << 16) |
                                         (settingsPayload[i + 4] << 8) |
-                                        settingsPayload[i + 5];
+                                        settingsPayload[i + 5]) >>> 0;
                                     settings[id] = value;
                                     if (id === 4) {
                                         // SETTINGS_INITIAL_WINDOW_SIZE
@@ -1283,45 +1398,41 @@
                                 if (this.onSettings) {
                                     this.onSettings(frameHeader);
                                 }
-                                // 标记已收到对端 SETTINGS
-                                this.peerSettingsReceived = true;
-                                waiters = this.sendWindowWaiters.splice(0);
-                                waiters.forEach(function (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) {
-                                    streamWindowUpdate = Http2Frame.createWindowUpdateFrame(frameHeader.streamId, (_a = frameHeader.length) !== null && _a !== void 0 ? _a : 0);
-                                    this.writer.write(streamWindowUpdate);
+                            dataLength = (_a = frameHeader.length) !== null && _a !== void 0 ? _a : 0;
+                            if (dataLength > 0) {
+                                try {
+                                    // 更新流级别的窗口
+                                    if (frameHeader.streamId !== 0) {
+                                        streamWindowUpdate = Http2Frame.createWindowUpdateFrame(frameHeader.streamId, dataLength);
+                                        this.writer.write(streamWindowUpdate);
+                                    }
+                                    connWindowUpdate = Http2Frame.createWindowUpdateFrame(0, dataLength);
+                                    this.writer.write(connWindowUpdate);
+                                }
+                                catch (err) {
+                                    console.error("[HTTP2] Error sending window update:", err);
                                 }
-                                connWindowUpdate = Http2Frame.createWindowUpdateFrame(0, (_b = frameHeader.length) !== null && _b !== void 0 ? _b : 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();
-                                }
+                                (_b = this.onEnd) === null || _b === void 0 ? void 0 : _b.call(this);
+                                this._notifyEndOfStream();
                                 return [2 /*return*/];
                             }
                             break;
+                        }
                         case FRAME_TYPES.HEADERS:
                             // 处理头部帧
                             if (this.onHeaders) {
@@ -1330,35 +1441,26 @@
                             //判断是否是最后一个帧
                             if ((frameHeader.flags & FRAME_FLAGS.END_STREAM) ===
                                 FRAME_FLAGS.END_STREAM) {
-                                this.endFlag = true;
-                                if (this.onEnd) {
-                                    this.onEnd();
-                                }
+                                (_c = this.onEnd) === null || _c === void 0 ? void 0 : _c.call(this);
+                                this._notifyEndOfStream();
                                 return [2 /*return*/];
                             }
                             break;
                         case FRAME_TYPES.WINDOW_UPDATE:
-                            // 处理窗口更新帧
-                            this.handleWindowUpdateFrame(frameHeader, frameData);
-                            // 更新发送窗口（对端接收窗口）
+                            // 处理窗口更新帧（同时更新接收侧诊断计数器和发送侧流控窗口，只解析一次）
                             try {
-                                inc = this.parseWindowUpdateFrame(frameData, frameHeader).windowSizeIncrement;
+                                result = this.handleWindowUpdateFrame(frameHeader, frameData);
+                                // 更新发送方向窗口（对端的接收窗口）
                                 if (frameHeader.streamId === 0) {
-                                    this.sendConnWindow += inc;
+                                    this.sendConnWindow += result.windowSizeIncrement;
                                 }
                                 else {
-                                    cur = (_c = this.sendStreamWindows.get(frameHeader.streamId)) !== null && _c !== void 0 ? _c : this.peerInitialStreamWindow;
-                                    this.sendStreamWindows.set(frameHeader.streamId, cur + inc);
-                                }
-                                waiters = this.sendWindowWaiters.splice(0);
-                                waiters.forEach(function (fn) { try {
-                                    fn();
+                                    cur = (_d = this.sendStreamWindows.get(frameHeader.streamId)) !== null && _d !== void 0 ? _d : this.peerInitialStreamWindow;
+                                    this.sendStreamWindows.set(frameHeader.streamId, cur + result.windowSizeIncrement);
                                 }
-                                catch (e) {
-                                    console.debug('waiter error', e);
-                                } });
+                                this._wakeWindowWaiters();
                             }
-                            catch ( /* ignore WINDOW_UPDATE parse errors */_g) { /* ignore WINDOW_UPDATE parse errors */ }
+                            catch ( /* ignore WINDOW_UPDATE parse errors (e.g. increment=0 is RFC PROTOCOL_ERROR) */_j) { /* ignore WINDOW_UPDATE parse errors (e.g. increment=0 is RFC PROTOCOL_ERROR) */ }
                             break;
                         case FRAME_TYPES.PING:
                             // 处理PING帧
@@ -1380,20 +1482,20 @@
                                     info = {};
                                 }
                             }
-                            catch ( /* ignore GOAWAY parse errors */_h) { /* ignore GOAWAY parse errors */ }
+                            catch ( /* ignore GOAWAY parse errors */_k) { /* ignore GOAWAY parse errors */ }
                             try {
-                                (_d = this.onGoaway) === null || _d === void 0 ? void 0 : _d.call(this, info !== null && info !== void 0 ? info : {});
+                                (_e = this.onGoaway) === null || _e === void 0 ? void 0 : _e.call(this, info !== null && info !== void 0 ? info : {});
                             }
                             catch (err) {
                                 console.error('Error during GOAWAY callback:', err);
                             }
-                            this.endFlag = true;
                             try {
-                                (_e = this.onEnd) === null || _e === void 0 ? void 0 : _e.call(this);
+                                (_f = this.onEnd) === null || _f === void 0 ? void 0 : _f.call(this);
                             }
                             catch (err) {
                                 console.error('Error during GOAWAY onEnd callback:', err);
                             }
+                            this._notifyEndOfStream();
                             break;
                         }
                         // case FRAME_TYPES.PUSH_PROMISE:
@@ -1401,10 +1503,8 @@
                         //     this.handlePushPromiseFrame(frameHeader, frameData);
                         //     break;
                         case FRAME_TYPES.RST_STREAM:
-                            this.endFlag = true;
-                            if (this.onEnd) {
-                                this.onEnd();
-                            }
+                            (_g = this.onEnd) === null || _g === void 0 ? void 0 : _g.call(this);
+                            this._notifyEndOfStream();
                             break;
                         default:
                             console.debug("Unknown frame type:", frameHeader.type);
@@ -1417,7 +1517,8 @@
             var length = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
             var type = buffer[3];
             var flags = buffer[4];
-            var 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
+            var streamId = ((buffer[5] << 24) | (buffer[6] << 16) | (buffer[7] << 8) | buffer[8]) & 0x7fffffff;
             return {
                 length: length,
                 type: type,
@@ -1446,53 +1547,42 @@
                 throw error;
             }
         };
-        //等待流结束
+        // 等待流结束 — 事件驱动，onEnd 触发时直接唤醒，无 setInterval 轮询
         HTTP2Parser.prototype.waitForEndOfStream = function (waitTime) {
             var _this = this;
             return new Promise(function (resolve, reject) {
-                // If the stream has already ended, resolve immediately
                 if (_this.endFlag) {
                     resolve();
                     return;
                 }
-                // 如果是0 ,则不设置超时
-                var timeout = null;
-                if (waitTime > 0) {
-                    timeout = setTimeout(function () {
-                        clearInterval(interval);
+                var waiter = { resolve: resolve, reject: reject };
+                _this.endOfStreamWaiters.push(waiter);
+                var timeout = waitTime > 0
+                    ? setTimeout(function () {
+                        var 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
-                var checkInterval = 100; // Check every 100 milliseconds
-                // Set an interval to check the endFlag regularly
-                var interval = setInterval(function () {
-                    if (_this.endFlag) {
-                        if (timeout !== null) {
-                            clearTimeout(timeout);
-                        }
-                        clearInterval(interval);
-                        resolve();
-                    }
-                }, checkInterval);
-                // If the onEnd is triggered externally, it should now be marked manually
-                var originalOnEnd = _this.onEnd;
-                _this.onEnd = function () {
-                    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 = function () { if (timeout)
+                    clearTimeout(timeout); resolve(); };
+                waiter.reject = function (e) { if (timeout)
+                    clearTimeout(timeout); reject(e); };
             });
         };
+        /** 内部调用：流结束时唤醒所有 waitForEndOfStream 等待者 */
+        HTTP2Parser.prototype._notifyEndOfStream = function () {
+            this.endFlag = true;
+            var ws = this.endOfStreamWaiters.splice(0);
+            for (var _i = 0, ws_4 = ws; _i < ws_4.length; _i++) {
+                var w = ws_4[_i];
+                try {
+                    w.resolve();
+                }
+                catch ( /* ignore */_a) { /* ignore */ }
+            }
+        };
         // 解析 WINDOW_UPDATE 帧
         HTTP2Parser.prototype.parseWindowUpdateFrame = function (frameBuffer, frameHeader) {
             // WINDOW_UPDATE帧的payload固定为4字节
@@ -1886,6 +1976,8 @@
             this.lastBytesDrainedSeen = 0;
             this.lastBpWarnAt = 0;
             this.isHandlingError = false; // 防止重复错误处理
+            /** drain 事件驱动等待者，替代 flush() 中的 setInterval 轮询 */
+            this.drainWaiters = [];
             // 事件系统  
             this.listeners = new Map();
             // 验证 stream 参数
@@ -2016,10 +2108,12 @@
                             _l.trys.push([4, 7, , 8]);
                             canContinue = this.stream.send(chunk);
                             if (!!canContinue) return [3 /*break*/, 6];
-                            // 等待 drain 事件
-                            return [4 /*yield*/, this.stream.onDrain()];
+                            // 传入 abort signal，当流被 abort 时 onDrain() 会立即 reject，
+                            // 避免在 abort 路径下永久挂住
+                            return [4 /*yield*/, this.stream.onDrain({ signal: this.abortController.signal })];
                         case 5:
-                            // 等待 drain 事件
+                            // 传入 abort signal，当流被 abort 时 onDrain() 会立即 reject，
+                            // 避免在 abort 路径下永久挂住
                             _l.sent();
                             _l.label = 6;
                         case 6: return [3 /*break*/, 8];
@@ -2054,7 +2148,11 @@
                             if (e_1) throw e_1.error;
                             return [7 /*endfinally*/];
                         case 15: return [7 /*endfinally*/];
-                        case 16: return [2 /*return*/];
+                        case 16:
+                            // pipeline 正常结束（stream 关闭或 pushable 耗尽）—— 确保资源清理
+                            // 若已通过 abort() 触发则 cleanup() 内部幂等处理
+                            this.cleanup();
+                            return [2 /*return*/];
                     }
                 });
             });
@@ -2064,7 +2162,7 @@
             var self = this;
             return function (source) {
                 return __asyncGenerator(this, arguments, function () {
-                    var _a, source_1, source_1_1, chunk, now, e_2_1;
+                    var _a, source_1, source_1_1, chunk, now, ws, _i, ws_1, fn, e_2_1;
                     var _b, e_2, _c, _d;
                     return __generator(this, function (_e) {
                         switch (_e.label) {
@@ -2101,6 +2199,17 @@
                                         self.lastDrainEventAt = now;
                                         self.dispatchEvent(new CustomEvent('drain', { detail: { drained: self.bytesDrained, queueSize: self.queueSize } }));
                                     }
+                                    // 唤醒所有在等 flush() 或背压解除 的 drainWaiters（队列降低时就可唤醒）
+                                    if (self.drainWaiters.length > 0) {
+                                        ws = self.drainWaiters.splice(0);
+                                        for (_i = 0, ws_1 = ws; _i < ws_1.length; _i++) {
+                                            fn = ws_1[_i];
+                                            try {
+                                                fn();
+                                            }
+                                            catch ( /* ignore */_f) { /* ignore */ }
+                                        }
+                                    }
                                     // 记录本次已消耗字节，用于看门狗判断是否前进
                                     self.lastBytesDrainedSeen = self.bytesDrained;
                                 }
@@ -2136,13 +2245,14 @@
             };
         };
         // 简单的卡顿看门狗：当队列长期高位且 bytesDrained 无进展时发出 stalled 事件
+        // 使用递归 setTimeout 而非 setInterval，避免标签页后台恢复时回调堆积导致 Violation
         StreamWriter.prototype.startWatchdog = function (intervalMs, stallMs) {
             var _this = this;
             if (intervalMs === void 0) { intervalMs = 500; }
             if (stallMs === void 0) { stallMs = 1500; }
             if (this.watchdogTimer)
                 return;
-            this.watchdogTimer = setInterval(function () {
+            var tick = function () {
                 if (_this.abortController.signal.aborted)
                     return;
                 var baseThreshold = _this.options.bufferSize * 0.7;
@@ -2153,7 +2263,13 @@
                         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 立即返回，避免同步事件处理器阻塞主线程
+                            var detail_1 = { queueSize: q, drained: _this.bytesDrained, sinceMs: now - _this.stallStartAt };
+                            setTimeout(function () {
+                                if (!_this.abortController.signal.aborted) {
+                                    _this.dispatchEvent(new CustomEvent('stalled', { detail: detail_1 }));
+                                }
+                            }, 0);
                             // 避免持续触发，推进起点
                             _this.stallStartAt = now;
                         }
@@ -2168,7 +2284,10 @@
                     // 队列回落，重置
                     _this.stallStartAt = 0;
                 }
-            }, intervalMs);
+                // 本次 tick 完成后再安排下一次，不会因主线程繁忙而堆积
+                _this.watchdogTimer = setTimeout(tick, intervalMs);
+            };
+            this.watchdogTimer = setTimeout(tick, intervalMs);
         };
         StreamWriter.prototype.write = function (data) {
             return __awaiter(this, void 0, void 0, function () {
@@ -2227,17 +2346,17 @@
         };
         StreamWriter.prototype.writeChunks = function (buffer) {
             return __awaiter(this, void 0, void 0, function () {
-                var offset, end, chunk;
+                var src, offset, end, chunk;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
+                            src = new Uint8Array(buffer);
                             offset = 0;
                             _a.label = 1;
                         case 1:
-                            if (!(offset < buffer.byteLength)) return [3 /*break*/, 4];
-                            end = Math.min(offset + this.options.chunkSize, buffer.byteLength);
-                            chunk = new Uint8Array(end - offset);
-                            chunk.set(new Uint8Array(buffer.slice(offset, end)));
+                            if (!(offset < src.byteLength)) return [3 /*break*/, 4];
+                            end = Math.min(offset + this.options.chunkSize, src.byteLength);
+                            chunk = src.subarray(offset, end);
                             return [4 /*yield*/, this.retryableWrite(chunk)];
                         case 2:
                             _a.sent();
@@ -2254,7 +2373,6 @@
         StreamWriter.prototype.retryableWrite = function (chunk_1) {
             return __awaiter(this, arguments, void 0, function (chunk, attempt) {
                 var currentSize, threshold, err_3, delay_1;
-                var _this = this;
                 if (attempt === void 0) { attempt = 0; }
                 return __generator(this, function (_a) {
                     switch (_a.label) {
@@ -2265,7 +2383,7 @@
                             }
                             _a.label = 1;
                         case 1:
-                            _a.trys.push([1, 5, , 8]);
+                            _a.trys.push([1, 4, , 7]);
                             currentSize = this.queueSize;
                             threshold = this.options.bufferSize * 0.7;
                             if (!(currentSize > threshold)) return [3 /*break*/, 3];
@@ -2278,94 +2396,92 @@
                             if (this.abortController.signal.aborted) {
                                 throw new Error('Stream aborted during backpressure monitoring');
                             }
-                            return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                    try {
-                                        _this.p.push(chunk);
-                                    }
-                                    catch (err) {
-                                        reject(err);
-                                    }
-                                    resolve();
-                                })];
+                            // push 是同步操作，直接调用即可
+                            this.p.push(chunk);
+                            return [3 /*break*/, 7];
                         case 4:
-                            _a.sent();
-                            return [3 /*break*/, 8];
-                        case 5:
                             err_3 = _a.sent();
-                            if (!(attempt < this.options.retries)) return [3 /*break*/, 7];
+                            if (!(!this.abortController.signal.aborted && attempt < this.options.retries)) return [3 /*break*/, 6];
                             delay_1 = this.calculateRetryDelay(attempt);
                             return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, delay_1); })];
-                        case 6:
+                        case 5:
                             _a.sent();
                             return [2 /*return*/, this.retryableWrite(chunk, attempt + 1)];
-                        case 7: throw err_3;
-                        case 8: return [2 /*return*/];
+                        case 6: throw err_3;
+                        case 7: return [2 /*return*/];
                     }
                 });
             });
         };
         StreamWriter.prototype.monitorBackpressure = function () {
             return __awaiter(this, void 0, void 0, function () {
-                var currentSize, baseThreshold, criticalThreshold, pressure, waitTime, retryCount, maxRetries, now;
+                var baseThreshold, criticalThreshold, maxRounds, _loop_1, this_1, i, state_1, now;
+                var _this = this;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            currentSize = this.queueSize;
-                            baseThreshold = this.options.bufferSize * 0.7 // 降低基础阈值，更早检测
-                            ;
-                            criticalThreshold = this.options.bufferSize * 0.9 // 临界阈值
-                            ;
-                            // 快速路径：无背压时直接返回
-                            if (currentSize < baseThreshold) {
+                            baseThreshold = this.options.bufferSize * 0.7;
+                            criticalThreshold = this.options.bufferSize * 0.9;
+                            // 快速路径
+                            if (this.queueSize < baseThreshold) {
                                 if (this.isBackpressure) {
                                     this.isBackpressure = false;
-                                    this.dispatchBackpressureEvent({
-                                        currentSize: currentSize,
-                                        averageSize: this.getAverageQueueSize(),
-                                        threshold: baseThreshold,
-                                        waitingTime: 0
-                                    });
+                                    this.dispatchBackpressureEvent({ currentSize: this.queueSize, averageSize: this.getAverageQueueSize(), threshold: baseThreshold, waitingTime: 0 });
                                 }
                                 return [2 /*return*/];
                             }
-                            // 进入背压状态
                             if (!this.isBackpressure) {
                                 this.isBackpressure = true;
-                                this.dispatchBackpressureEvent({
-                                    currentSize: currentSize,
-                                    averageSize: this.getAverageQueueSize(),
-                                    threshold: baseThreshold,
-                                    waitingTime: 0
-                                });
+                                this.dispatchBackpressureEvent({ currentSize: this.queueSize, averageSize: this.getAverageQueueSize(), threshold: baseThreshold, waitingTime: 0 });
                             }
-                            pressure = currentSize / this.options.bufferSize;
-                            if (currentSize >= criticalThreshold) {
-                                // 临界状态：长时间等待
-                                waitTime = 50 + Math.min(200, pressure * 100);
-                            }
-                            else {
-                                // 轻度背压：短时间等待
-                                waitTime = Math.min(20, pressure * 30);
-                            }
-                            retryCount = 0;
-                            maxRetries = 3;
+                            maxRounds = 3;
+                            _loop_1 = function (i) {
+                                var isCritical, waitMs;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            if (this_1.abortController.signal.aborted)
+                                                return [2 /*return*/, "break"];
+                                            if (this_1.queueSize < baseThreshold)
+                                                return [2 /*return*/, "break"];
+                                            isCritical = this_1.queueSize >= criticalThreshold;
+                                            waitMs = isCritical ? 100 : 30;
+                                            return [4 /*yield*/, new Promise(function (resolve) {
+                                                    var done = false;
+                                                    var timer = setTimeout(function () { if (!done) {
+                                                        done = true;
+                                                        resolve();
+                                                    } }, waitMs);
+                                                    _this.drainWaiters.push(function () { if (!done) {
+                                                        done = true;
+                                                        clearTimeout(timer);
+                                                        resolve();
+                                                    } });
+                                                })];
+                                        case 1:
+                                            _b.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            };
+                            this_1 = this;
+                            i = 0;
                             _a.label = 1;
                         case 1:
-                            if (!(this.queueSize >= baseThreshold && retryCount < maxRetries)) return [3 /*break*/, 3];
-                            if (this.abortController.signal.aborted)
-                                return [3 /*break*/, 3];
-                            return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, waitTime); })];
+                            if (!(i < maxRounds)) return [3 /*break*/, 4];
+                            return [5 /*yield**/, _loop_1(i)];
                         case 2:
-                            _a.sent();
-                            retryCount++;
-                            // 动态调整等待时间
-                            waitTime = Math.min(waitTime * 1.5, 100);
-                            return [3 /*break*/, 1];
+                            state_1 = _a.sent();
+                            if (state_1 === "break")
+                                return [3 /*break*/, 4];
+                            _a.label = 3;
                         case 3:
-                            // 如果仍然背压但达到最大重试次数，记录警告但继续执行
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 4:
                             if (this.queueSize >= baseThreshold) {
                                 now = Date.now();
-                                if (now - this.lastBpWarnAt > 1000) { // 节流警告
+                                if (now - this.lastBpWarnAt > 1000) {
                                     this.lastBpWarnAt = now;
                                     console.warn("Stream writer: High backpressure detected (".concat(this.queueSize, " bytes), continuing anyway"));
                                 }
@@ -2493,19 +2609,31 @@
             if (!this.abortController.signal.aborted) {
                 this.abortController.abort();
             }
-            // 立即拒绝所有待处理的写入任务，避免它们继续执行
+            // 执行所有待处理的写入任务：它们会检查 signal.aborted 并立即 resolve，
+            // 不执行的话调用方的 Promise 会永远挂住
             var pendingTasks = this.writeQueue.splice(0);
-            pendingTasks.forEach(function () {
-                // 这些任务的 Promise 会在执行时因为检查到 aborted 而被拒绝
-            });
+            for (var _i = 0, pendingTasks_1 = pendingTasks; _i < pendingTasks_1.length; _i++) {
+                var task = pendingTasks_1[_i];
+                task().catch(function () { });
+            }
+            // 唤醒所有 drainWaiters（flush / monitorBackpressure 中的等待者），
+            // 让它们检查 signal.aborted 并立即 resolve，不必等到各自的超时
+            var ws = this.drainWaiters.splice(0);
+            for (var _a = 0, ws_2 = ws; _a < ws_2.length; _a++) {
+                var fn = ws_2[_a];
+                try {
+                    fn();
+                }
+                catch ( /* ignore */_b) { /* ignore */ }
+            }
             try {
                 this.p.end();
             }
-            catch (_a) {
+            catch (_c) {
                 // Ignore errors when ending pushable
             }
             if (this.watchdogTimer) {
-                clearInterval(this.watchdogTimer);
+                clearTimeout(this.watchdogTimer);
                 this.watchdogTimer = undefined;
             }
         };
@@ -2513,30 +2641,49 @@
         // 默认超时 10s，避免无限等待
         StreamWriter.prototype.flush = function () {
             return __awaiter(this, arguments, void 0, function (timeoutMs) {
-                var start;
+                var _this = this;
                 if (timeoutMs === void 0) { timeoutMs = 10000; }
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            start = Date.now();
                             // 快速路径
                             if (this.queueSize <= 0 && !this.isProcessingQueue && this.writeQueue.length === 0)
                                 return [2 /*return*/];
-                            _a.label = 1;
-                        case 1:
                             if (this.abortController.signal.aborted)
                                 return [2 /*return*/];
-                            if (this.queueSize <= 0 && !this.isProcessingQueue && this.writeQueue.length === 0)
-                                return [2 /*return*/];
-                            if (Date.now() - start > timeoutMs) {
-                                console.warn("Stream writer: flush timeout with ".concat(this.queueSize, " bytes still queued"));
-                                return [2 /*return*/];
-                            }
-                            return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 10); })];
-                        case 2:
+                            return [4 /*yield*/, new Promise(function (resolve) {
+                                    // 已经清空
+                                    if (_this.queueSize <= 0 && !_this.isProcessingQueue && _this.writeQueue.length === 0) {
+                                        resolve();
+                                        return;
+                                    }
+                                    var done = false;
+                                    var timer = setTimeout(function () {
+                                        if (!done) {
+                                            done = true;
+                                            console.warn("Stream writer: flush timeout with ".concat(_this.queueSize, " bytes still queued"));
+                                            resolve();
+                                        }
+                                    }, timeoutMs);
+                                    // 由 createTransform 在每个 chunk 被下游消耗后唤醒
+                                    var check = function () {
+                                        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);
+                                })];
+                        case 1:
                             _a.sent();
-                            return [3 /*break*/, 1];
-                        case 3: return [2 /*return*/];
+                            return [2 /*return*/];
                     }
                 });
             });
@@ -2845,45 +2992,65 @@
         Libp2pGrpcClient.prototype.setToken = function (token) {
             this.token = token;
         };
+        /** 从 peerAddr 提取 HTTP/2 :authority 字段（host:port 格式） */
+        Libp2pGrpcClient.prototype.getAuthority = function () {
+            try {
+                var addr = this.peerAddr.toString();
+                var ip4 = addr.match(/\/ip4\/(\d[\d.]+)\/tcp\/(\d+)/);
+                if (ip4)
+                    return "".concat(ip4[1], ":").concat(ip4[2]);
+                var ip6 = addr.match(/\/ip6\/([^/]+)\/tcp\/(\d+)/);
+                if (ip6)
+                    return "[".concat(ip6[1], "]:").concat(ip6[2]);
+                var dns = addr.match(/\/dns(?:4|6)?\/([.\w-]+)\/tcp\/(\d+)/);
+                if (dns)
+                    return "".concat(dns[1], ":").concat(dns[2]);
+            }
+            catch ( /* ignore */_a) { /* ignore */ }
+            return 'localhost';
+        };
         Libp2pGrpcClient.prototype.unaryCall = function (method_1, requestData_1) {
             return __awaiter(this, arguments, void 0, function (method, requestData, timeout) {
-                var stream, responseData, responseBuffer, responseDataExpectedLength, hpack, exitFlag, errMsg, isResponseComplete, connection, state, streamSlotAcquired, connectionKey_1, err_2, streamManager, streamId_1, writer_1, parser, preface, settingFrme, headerFrame, dataFrames, frameSendTimeout, _i, dataFrames_1, df, err_3;
+                var stream, responseData, responseBuffer, responseDataExpectedLength, headerPartialBuffer, hpack, exitFlag, errMsg, isResponseComplete, notifyResponseComplete, connection, state, streamSlotAcquired, writerRef, connectionKey_1, err_2, streamManager, streamId_1, writer_1, parser, preface, settingFrme, headerFrame, dataFrames, frameSendTimeout, _i, dataFrames_1, df, err_3;
                 var _this = this;
                 if (timeout === void 0) { timeout = 30000; }
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0:
                             stream = null;
                             responseData = null;
                             responseBuffer = [];
                             responseDataExpectedLength = -1;
+                            headerPartialBuffer = [];
                             hpack = new HPACK();
                             exitFlag = false;
                             errMsg = "";
                             isResponseComplete = false;
+                            notifyResponseComplete = null;
                             connection = null;
                             state = null;
                             streamSlotAcquired = false;
-                            _b.label = 1;
+                            writerRef = null;
+                            _c.label = 1;
                         case 1:
-                            _b.trys.push([1, 23, 24, 27]);
+                            _c.trys.push([1, 23, 24, 29]);
                             return [4 /*yield*/, this.acquireConnection(false)];
                         case 2:
                             // const stream = await this.node.dialProtocol(this.peerAddr, this.protocol)
-                            connection = _b.sent();
+                            connection = _c.sent();
                             connectionKey_1 = this.peerAddr.toString();
                             state = this.getConnectionState(connection);
-                            _b.label = 3;
+                            _c.label = 3;
                         case 3:
-                            _b.trys.push([3, 5, , 6]);
+                            _c.trys.push([3, 5, , 6]);
                             return [4 /*yield*/, this.waitForStreamSlot(state, undefined, timeout)];
                         case 4:
-                            _b.sent();
+                            _c.sent();
                             state.activeStreams += 1;
                             streamSlotAcquired = true;
                             return [3 /*break*/, 6];
                         case 5:
-                            err_2 = _b.sent();
+                            err_2 = _c.sent();
                             console.warn("[unaryCall] waiting for stream slot failed:", err_2);
                             throw err_2;
                         case 6: return [4 /*yield*/, connection.newStream(this.protocol, {
@@ -2891,14 +3058,15 @@
                                 negotiateFully: false,
                             })];
                         case 7:
-                            stream = _b.sent();
+                            stream = _c.sent();
                             streamManager = this.getStreamManagerFor(connection);
                             return [4 /*yield*/, streamManager.getNextAppLevelStreamId()];
                         case 8:
-                            streamId_1 = _b.sent();
+                            streamId_1 = _c.sent();
                             writer_1 = new StreamWriter(stream, {
                                 bufferSize: 16 * 1024 * 1024,
                             });
+                            writerRef = writer_1;
                             try {
                                 writer_1.addEventListener("backpressure", function (e) {
                                     var d = e.detail || {};
@@ -2920,7 +3088,7 @@
                                     catch ( /* ignore ping write errors */_b) { /* ignore ping write errors */ }
                                 });
                             }
-                            catch ( /* ignore addEventListener errors */_c) { /* ignore addEventListener errors */ }
+                            catch ( /* ignore addEventListener errors */_d) { /* ignore addEventListener errors */ }
                             parser = new HTTP2Parser(writer_1);
                             parser.onGoaway = function (info) {
                                 console.warn("[unaryCall] GOAWAY received from server", info);
@@ -2930,6 +3098,7 @@
                                 }
                                 exitFlag = true;
                                 errMsg = "GOAWAY received: code=".concat(info.errorCode);
+                                notifyResponseComplete === null || notifyResponseComplete === void 0 ? void 0 : notifyResponseComplete(); // 唤醒等待中的 Promise
                                 try {
                                     connection === null || connection === void 0 ? void 0 : connection.close();
                                 }
@@ -2948,86 +3117,99 @@
                             parser.registerOutboundStream(streamId_1);
                             responseDataExpectedLength = -1; // 重置期望长度
                             responseBuffer = []; // 重置缓冲区
+                            headerPartialBuffer = []; // 重置跨帧头部缓冲
                             parser.onData = function (payload, frameHeader) {
                                 //接收数据
                                 if (responseDataExpectedLength === -1) {
                                     //grpc消息头部未读取
+                                    // 如果有跨帧积累的部分头字节，先与本帧 payload 合并
+                                    var effectivePayload = payload;
+                                    if (headerPartialBuffer.length > 0) {
+                                        headerPartialBuffer.push(payload);
+                                        var totalLen = headerPartialBuffer.reduce(function (s, c) { return s + c.length; }, 0);
+                                        effectivePayload = new Uint8Array(totalLen);
+                                        var off = 0;
+                                        for (var _i = 0, headerPartialBuffer_1 = headerPartialBuffer; _i < headerPartialBuffer_1.length; _i++) {
+                                            var c = headerPartialBuffer_1[_i];
+                                            effectivePayload.set(c, off);
+                                            off += c.length;
+                                        }
+                                        headerPartialBuffer = [];
+                                    }
                                     //提取gRPC消息头部
-                                    if (payload.length < 5) {
+                                    if (effectivePayload.length < 5) {
+                                        // 头部字节不足 5，先缓存，等待后续帧补全
+                                        headerPartialBuffer.push(effectivePayload);
                                         return;
                                     }
-                                    var 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) {
+                                    var 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 消息，缓存数据
-                                        var grpcData = payload.subarray(5);
+                                        var grpcData = effectivePayload.subarray(5);
                                         responseBuffer.push(grpcData);
                                         responseDataExpectedLength -= grpcData.length; // 更新期望长度
                                         return;
                                     }
                                     else {
-                                        // 如果当前 payload 足以包含完整的 gRPC 消息，重置缓冲区
-                                        var grpcData = payload.subarray(5); // 提取完整的 gRPC 消息
+                                        // payload 已包含完整的 gRPC 消息体，精确截取（避免尾部多余字节污染）
+                                        var msgLen = responseDataExpectedLength;
+                                        var grpcData = effectivePayload.slice(5, 5 + msgLen);
                                         responseBuffer.push(grpcData);
                                         responseData = grpcData;
                                         isResponseComplete = true;
-                                        responseDataExpectedLength = -1; // 重置期望长度
+                                        responseDataExpectedLength = -1;
+                                        notifyResponseComplete === null || notifyResponseComplete === void 0 ? void 0 : notifyResponseComplete();
                                     }
                                 }
                                 else if (responseDataExpectedLength > 0) {
                                     //grpc消息头部已读取
-                                    responseBuffer.push(payload); // 将数据添加到缓冲区
-                                    responseDataExpectedLength -= payload.length; // 更新期望长度
+                                    responseDataExpectedLength -= payload.length;
                                     if (responseDataExpectedLength <= 0) {
-                                        // 如果缓冲区中的数据已经完全处理，重置缓冲区
+                                        // 超收时截掉多余字节
+                                        var exactPayload = responseDataExpectedLength < 0
+                                            ? payload.slice(0, payload.length + responseDataExpectedLength)
+                                            : payload;
+                                        responseBuffer.push(exactPayload);
                                         responseData = new Uint8Array(responseBuffer.reduce(function (sum, chunk) { return sum + chunk.length; }, 0));
                                         var offset = 0;
-                                        for (var _i = 0, responseBuffer_1 = responseBuffer; _i < responseBuffer_1.length; _i++) {
-                                            var chunk = responseBuffer_1[_i];
+                                        for (var _a = 0, responseBuffer_1 = responseBuffer; _a < responseBuffer_1.length; _a++) {
+                                            var chunk = responseBuffer_1[_a];
                                             responseData.set(chunk, offset);
                                             offset += chunk.length;
                                         }
                                         responseDataExpectedLength = -1;
-                                        isResponseComplete = true; // 设置响应完成标志
+                                        isResponseComplete = true;
+                                        notifyResponseComplete === null || notifyResponseComplete === void 0 ? void 0 : notifyResponseComplete();
                                     }
-                                }
-                                // 检查是否是流的最后一个帧（END_STREAM 标志）
-                                if (frameHeader && frameHeader.flags & 0x1 && !isResponseComplete) {
-                                    // END_STREAM flag
-                                    // 合并所有缓冲的数据
-                                    var totalLength = responseBuffer.reduce(function (sum, chunk) { return sum + chunk.length; }, 0);
-                                    responseData = new Uint8Array(totalLength);
-                                    var offset = 0;
-                                    for (var _a = 0, responseBuffer_2 = responseBuffer; _a < responseBuffer_2.length; _a++) {
-                                        var chunk = responseBuffer_2[_a];
-                                        responseData.set(chunk, offset);
-                                        offset += chunk.length;
+                                    else {
+                                        responseBuffer.push(payload); // 还不完整，继续累积
                                     }
-                                    isResponseComplete = true;
                                 }
-                            };
-                            parser.onEnd = function () {
-                                //接收结束
-                                if (!isResponseComplete) {
-                                    isResponseComplete = true; // 设置响应完成标志
-                                    if (responseBuffer.length === 0) {
-                                        responseData = new Uint8Array(); // 如果没有数据，返回空数组
-                                    }
-                                    else {
-                                        // 合并所有缓冲的数据
-                                        var totalLength = responseBuffer.reduce(function (sum, chunk) { return sum + chunk.length; }, 0);
+                                // END_STREAM 兜底：数据路径已处理大多数情况；此分支仅在边缘情况下触发
+                                if (frameHeader && frameHeader.flags & 0x1 && !isResponseComplete) {
+                                    if (responseBuffer.length > 0) {
+                                        var totalLength = responseBuffer.reduce(function (sum, c) { return sum + c.length; }, 0);
                                         responseData = new Uint8Array(totalLength);
                                         var offset = 0;
-                                        for (var _i = 0, responseBuffer_3 = responseBuffer; _i < responseBuffer_3.length; _i++) {
-                                            var chunk = responseBuffer_3[_i];
+                                        for (var _b = 0, responseBuffer_2 = responseBuffer; _b < responseBuffer_2.length; _b++) {
+                                            var chunk = responseBuffer_2[_b];
                                             responseData.set(chunk, offset);
                                             offset += chunk.length;
                                         }
-                                        isResponseComplete = true;
                                     }
+                                    else {
+                                        responseData = new Uint8Array(0);
+                                    }
+                                    isResponseComplete = true;
+                                    notifyResponseComplete === null || notifyResponseComplete === void 0 ? void 0 : notifyResponseComplete();
+                                }
+                            };
+                            parser.onEnd = function () {
+                                // 流结束时若响应未标记完成（空响应 / 纯 trailers），强制标记并唤醒等待者
+                                if (!isResponseComplete) {
+                                    isResponseComplete = true;
+                                    notifyResponseComplete === null || notifyResponseComplete === void 0 ? void 0 : notifyResponseComplete();
                                 }
                             };
                             parser.onSettings = function () {
@@ -3041,6 +3223,7 @@
                                 else if (plainHeaders.get("grpc-status") !== undefined) {
                                     exitFlag = true;
                                     errMsg = plainHeaders.get("grpc-message") || "gRPC call failed";
+                                    notifyResponseComplete === null || notifyResponseComplete === void 0 ? void 0 : notifyResponseComplete(); // 唤醒等待中的 Promise
                                 }
                             };
                             // 启动后台流处理，捕获任何异步错误
@@ -3050,94 +3233,109 @@
                                 if (!errMsg) {
                                     errMsg = error instanceof Error ? error.message : 'Stream processing failed';
                                 }
+                                notifyResponseComplete === null || notifyResponseComplete === void 0 ? void 0 : notifyResponseComplete(); // 流处理异常也需唤醒等待者
                             });
                             preface = Http2Frame.createPreface();
                             return [4 /*yield*/, writer_1.write(preface)];
                         case 9:
-                            _b.sent();
+                            _c.sent();
                             settingFrme = Http2Frame.createSettingsFrame();
                             return [4 /*yield*/, writer_1.write(settingFrme)];
                         case 10:
-                            _b.sent();
+                            _c.sent();
                             // 等待对端 SETTINGS 或 ACK，择一即可，避免偶发握手竞态
+                            // 注意：未胜出的 promise 内部有超时定时器，它们最终会 reject。
+                            // 必须绑定 .catch(…) 消除错误，否则在 Node.js 新版本中会导致 UnhandledPromiseRejection 崩溃。
                             return [4 /*yield*/, Promise.race([
-                                    parser.waitForPeerSettings(1000),
-                                    parser.waitForSettingsAck(),
+                                    parser.waitForPeerSettings(1000).catch(function () { }),
+                                    parser.waitForSettingsAck().catch(function () { }),
                                     new Promise(function (res) { return setTimeout(res, 300); }),
                                 ])];
                         case 11:
                             // 等待对端 SETTINGS 或 ACK，择一即可，避免偶发握手竞态
-                            _b.sent();
-                            headerFrame = Http2Frame.createHeadersFrame(streamId_1, method, true, this.token);
+                            // 注意：未胜出的 promise 内部有超时定时器，它们最终会 reject。
+                            // 必须绑定 .catch(…) 消除错误，否则在 Node.js 新版本中会导致 UnhandledPromiseRejection 崩溃。
+                            _c.sent();
+                            headerFrame = Http2Frame.createHeadersFrame(streamId_1, method, true, this.token, this.getAuthority());
                             return [4 /*yield*/, writer_1.write(headerFrame)];
                         case 12:
-                            _b.sent();
+                            _c.sent();
                             dataFrames = Http2Frame.createDataFrames(streamId_1, requestData, true);
                             frameSendTimeout = timeout > 0 ? timeout : DEFAULT_SEND_WINDOW_TIMEOUT;
                             _i = 0, dataFrames_1 = dataFrames;
-                            _b.label = 13;
+                            _c.label = 13;
                         case 13:
                             if (!(_i < dataFrames_1.length)) return [3 /*break*/, 16];
                             df = dataFrames_1[_i];
                             return [4 /*yield*/, this.sendFrameWithFlowControl(parser, streamId_1, df, writer_1, undefined, frameSendTimeout)];
                         case 14:
-                            _b.sent();
-                            _b.label = 15;
+                            _c.sent();
+                            _c.label = 15;
                         case 15:
                             _i++;
                             return [3 /*break*/, 13];
                         case 16: 
-                        // 等待responseData 不为空,或超时
+                        // 等待 responseData 不为空，或超时（事件驱动，不轮询）
                         return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                if (isResponseComplete || exitFlag) {
+                                    resolve();
+                                    return;
+                                }
                                 var t = setTimeout(function () {
+                                    notifyResponseComplete = null;
                                     reject(new Error("gRPC response timeout"));
                                 }, timeout);
-                                var checkResponse = function () {
-                                    if (isResponseComplete || exitFlag) {
-                                        // 使用新的完成标志
-                                        clearTimeout(t);
-                                        resolve(responseData);
-                                    }
-                                    else {
-                                        setTimeout(checkResponse, 50);
-                                    }
+                                notifyResponseComplete = function () {
+                                    clearTimeout(t);
+                                    notifyResponseComplete = null;
+                                    resolve();
                                 };
-                                checkResponse();
                             })];
                         case 17:
-                            // 等待responseData 不为空,或超时
-                            _b.sent();
-                            _b.label = 18;
+                            // 等待 responseData 不为空，或超时（事件驱动，不轮询）
+                            _c.sent();
+                            _c.label = 18;
                         case 18:
-                            _b.trys.push([18, 20, , 21]);
+                            _c.trys.push([18, 20, , 21]);
                             return [4 /*yield*/, writer_1.flush(timeout)];
                         case 19:
-                            _b.sent();
+                            _c.sent();
                             return [3 /*break*/, 21];
                         case 20:
-                            _b.sent();
+                            _c.sent();
                             return [3 /*break*/, 21];
                         case 21: return [4 /*yield*/, writer_1.end()];
                         case 22:
-                            _b.sent();
-                            return [3 /*break*/, 27];
+                            _c.sent();
+                            return [3 /*break*/, 29];
                         case 23:
-                            err_3 = _b.sent();
+                            err_3 = _c.sent();
                             console.error("unaryCall error:", err_3);
                             throw err_3;
                         case 24:
-                            if (!stream) return [3 /*break*/, 26];
-                            return [4 /*yield*/, stream.close()];
+                            // 必须先 abort writer（立即强制停止 pushable + stream），再 close stream。
+                            // 若顺序颠倒：stream.close() 会等待服务端半关闭确认，网络异常时永久挂住，
+                            // 导致 writer.abort() 永远不执行 → watchdog 定时器 / pushable 泄漏。
+                            // writer.abort() 内部幂等，成功路径下 writer.end() 已调用 cleanup()，安全。
+                            writerRef === null || writerRef === void 0 ? void 0 : writerRef.abort('unaryCall cleanup');
+                            if (!stream) return [3 /*break*/, 28];
+                            _c.label = 25;
                         case 25:
-                            _b.sent();
-                            _b.label = 26;
+                            _c.trys.push([25, 27, , 28]);
+                            return [4 /*yield*/, stream.close()];
                         case 26:
+                            _c.sent();
+                            return [3 /*break*/, 28];
+                        case 27:
+                            _c.sent();
+                            return [3 /*break*/, 28];
+                        case 28:
                             if (streamSlotAcquired && state) {
                                 state.activeStreams = Math.max(0, state.activeStreams - 1);
                                 this.notifyStreamSlotAvailable(state);
                             }
                             return [7 /*endfinally*/];
-                        case 27:
+                        case 29:
                             if (exitFlag) {
                                 throw new Error(errMsg);
                             }
@@ -3166,7 +3364,7 @@
          */
         Libp2pGrpcClient.prototype.Call = function (method_1, requestData_1) {
             return __awaiter(this, arguments, void 0, function (method, requestData, timeout, mode, onDataCallback, dataSourceCallback, onEndCallback, onErrorCallback, context, options) {
-                var internalController, timeoutHandle, stream, profile, useFlowControl, cancelOperation, timeoutPromise, operationPromise, error_1;
+                var internalController, timeoutHandle, stream, contextAbortHandler, profile, useFlowControl, cancelOperation, timeoutPromise, operationPromise, error_1;
                 var _this = this;
                 var _a;
                 if (timeout === void 0) { timeout = 30000; }
@@ -3193,17 +3391,16 @@
                             };
                             // 如果提供了外部信号，监听它
                             if (context === null || context === void 0 ? void 0 : context.signal) {
-                                // 如果外部信号已经触发中止，立即返回
+                                // 如果外部信号已经触发中止，立即返回——避免启动 IIFE 后在 catch 中再次调用 onErrorCallback
                                 if (context.signal.aborted) {
                                     if (onErrorCallback) {
                                         onErrorCallback(new Error("Operation aborted by context"));
                                     }
-                                    cancelOperation();
+                                    return [2 /*return*/, cancelOperation];
                                 }
-                                // 监听外部的abort事件
-                                context.signal.addEventListener("abort", function () {
-                                    cancelOperation();
-                                });
+                                // 监听外部的abort事件（保存引用以便后续移除，防止内存泄漏）
+                                contextAbortHandler = function () { cancelOperation(); };
+                                context.signal.addEventListener("abort", contextAbortHandler);
                             }
                             timeoutPromise = new Promise(function (_, reject) {
                                 timeoutHandle = setTimeout(function () {
@@ -3212,58 +3409,83 @@
                                 }, timeout);
                             });
                             operationPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
-                                var messageBuffer, expectedMessageLength, hpack, connection, connectionKey, state, streamSlotAcquired, err_4, err_5, streamManager, streamId_2, writer_2, parser_1, sendWindowTimeout_1, writeFrame_1, writeDataFrames_1, preface, settingFrame, headerFrame, dfs, dfs0, batchSize_1, processingQueue_1, isProcessing_1, processNextBatch_1, addToQueue_1, _a, _b, _c, chunkOrChunks, chunksToProcess, addPromises, e_1_1, error_2, remainingQueue, queueWaitStart, maxQueueWaitMs, remainingQueue, finalFrame, err_6, err_7, conns, _i, conns_1, c;
+                                var errorCallbackFired, reportError, msgChunks, msgTotalLen, expectedMessageLength, flattenMsgBuffer, hpack, connection, connectionKey, state, streamSlotAcquired, writer, err_4, err_5, streamManager, streamId_2, parser_1, sendWindowTimeout_1, writeFrame_1, writeDataFrames_1, preface, settingFrame, headerFrame, dfs, dfs0, batchSize_1, processingQueue_1, batchDoneWaiters_1, isProcessing_1, _notifyBatchDone_1, processNextBatch_1, addToQueue_1, _a, _b, _c, chunkOrChunks, chunksToProcess, addPromises, e_1_1, error_2, remainingQueue, finalFrame, err_6, conns, _i, conns_1, c;
                                 var _this = this;
-                                var _g, e_1, _h, _j;
-                                var _k, _l, _m;
-                                return __generator(this, function (_o) {
-                                    switch (_o.label) {
+                                var _h, e_1, _j, _k;
+                                var _l, _m, _o;
+                                return __generator(this, function (_p) {
+                                    switch (_p.label) {
                                         case 0:
-                                            messageBuffer = new Uint8Array(0);
+                                            errorCallbackFired = false;
+                                            reportError = function (err) {
+                                                if (errorCallbackFired)
+                                                    return;
+                                                errorCallbackFired = true;
+                                                internalController.abort();
+                                                if (onErrorCallback)
+                                                    onErrorCallback(err);
+                                            };
+                                            msgChunks = [];
+                                            msgTotalLen = 0;
                                             expectedMessageLength = -1;
+                                            flattenMsgBuffer = function () {
+                                                if (msgChunks.length === 0)
+                                                    return new Uint8Array(0);
+                                                if (msgChunks.length === 1)
+                                                    return msgChunks[0];
+                                                var out = new Uint8Array(msgTotalLen);
+                                                var off = 0;
+                                                for (var _i = 0, msgChunks_1 = msgChunks; _i < msgChunks_1.length; _i++) {
+                                                    var c = msgChunks_1[_i];
+                                                    out.set(c, off);
+                                                    off += c.length;
+                                                }
+                                                return out;
+                                            };
                                             hpack = new HPACK();
                                             connection = null;
                                             connectionKey = null;
                                             state = null;
                                             streamSlotAcquired = false;
-                                            _o.label = 1;
+                                            writer = null;
+                                            _p.label = 1;
                                         case 1:
-                                            _o.trys.push([1, 49, 50, 64]);
+                                            _p.trys.push([1, 49, 50, 64]);
                                             // 检查是否已经中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
                                             }
                                             if (!(options === null || options === void 0 ? void 0 : options.freshConnection)) return [3 /*break*/, 5];
-                                            _o.label = 2;
+                                            _p.label = 2;
                                         case 2:
-                                            _o.trys.push([2, 4, , 5]);
+                                            _p.trys.push([2, 4, , 5]);
                                             this.connectionPool.delete(this.peerAddr.toString());
                                             return [4 /*yield*/, this.node.hangUp(this.peerAddr)];
                                         case 3:
-                                            _o.sent();
+                                            _p.sent();
                                             console.warn("[Call] hangUp existing connection before dialing due to freshConnection=true");
                                             return [3 /*break*/, 5];
                                         case 4:
-                                            err_4 = _o.sent();
+                                            err_4 = _p.sent();
                                             console.warn("[Call] hangUp failed or not supported, proceeding to dial", err_4);
                                             return [3 /*break*/, 5];
                                         case 5: return [4 /*yield*/, this.acquireConnection(Boolean(options === null || options === void 0 ? void 0 : options.freshConnection))];
                                         case 6:
-                                            connection = _o.sent();
+                                            connection = _p.sent();
                                             connectionKey = this.peerAddr.toString();
                                             state = this.getConnectionState(connection);
                                             if (!state) return [3 /*break*/, 10];
-                                            _o.label = 7;
+                                            _p.label = 7;
                                         case 7:
-                                            _o.trys.push([7, 9, , 10]);
+                                            _p.trys.push([7, 9, , 10]);
                                             return [4 /*yield*/, this.waitForStreamSlot(state, internalController.signal, timeout)];
                                         case 8:
-                                            _o.sent();
+                                            _p.sent();
                                             state.activeStreams += 1;
                                             streamSlotAcquired = true;
                                             return [3 /*break*/, 10];
                                         case 9:
-                                            err_5 = _o.sent();
+                                            err_5 = _p.sent();
                                             console.warn("[Call] waiting for stream slot failed:", err_5);
                                             throw err_5;
                                         case 10: return [4 /*yield*/, connection.newStream(this.protocol, {
@@ -3272,23 +3494,23 @@
                                                 negotiateFully: false,
                                             })];
                                         case 11:
-                                            stream = _o.sent();
+                                            stream = _p.sent();
                                             streamManager = this.getStreamManagerFor(connection);
                                             return [4 /*yield*/, streamManager.getNextAppLevelStreamId()];
                                         case 12:
-                                            streamId_2 = _o.sent();
-                                            writer_2 = new StreamWriter(stream, {
+                                            streamId_2 = _p.sent();
+                                            writer = new StreamWriter(stream, {
                                                 bufferSize: 16 * 1024 * 1024,
                                             });
                                             try {
-                                                writer_2.addEventListener("backpressure", function (e) {
+                                                writer.addEventListener("backpressure", function (e) {
                                                     var d = e.detail || {};
                                                     console.warn("[stream ".concat(streamId_2, "] backpressure current=").concat(d.currentSize, " avg=").concat(d.averageSize, " threshold=").concat(d.threshold));
                                                 });
-                                                writer_2.addEventListener("drain", function () {
+                                                writer.addEventListener("drain", function () {
                                                     // drain event - no action needed
                                                 });
-                                                writer_2.addEventListener("stalled", function (e) {
+                                                writer.addEventListener("stalled", function (e) {
                                                     var _a;
                                                     var d = e.detail || {};
                                                     console.warn("[stream ".concat(streamId_2, "] stalled queue=").concat(d.queueSize, " drained=").concat(d.drained, " since=").concat(d.sinceMs, "ms \u2014 sending PING"));
@@ -3296,13 +3518,13 @@
                                                         var payload = new Uint8Array(8);
                                                         (_a = crypto.getRandomValues) === null || _a === void 0 ? void 0 : _a.call(crypto, payload);
                                                         var ping = Http2Frame.createFrame(0x6, 0x0, 0, payload);
-                                                        writer_2.write(ping);
+                                                        writer.write(ping);
                                                     }
                                                     catch ( /* ignore ping write errors */_b) { /* ignore ping write errors */ }
                                                 });
                                             }
-                                            catch ( /* ignore addEventListener errors */_p) { /* ignore addEventListener errors */ }
-                                            parser_1 = new HTTP2Parser(writer_2, {
+                                            catch ( /* ignore addEventListener errors */_q) { /* ignore addEventListener errors */ }
+                                            parser_1 = new HTTP2Parser(writer, {
                                                 compatibilityMode: !useFlowControl,
                                             });
                                             parser_1.onGoaway = function (info) {
@@ -3313,10 +3535,8 @@
                                                 if (state) {
                                                     _this.rejectStreamWaiters(state, new Error("Connection received GOAWAY"));
                                                 }
-                                                if (onErrorCallback) {
-                                                    onErrorCallback(new Error("GOAWAY received: code=".concat(info.errorCode)));
-                                                }
-                                                internalController.abort();
+                                                // reportError 统一完成：标记已报错 + abort + 触发回调（幂等，不会重复触发）
+                                                reportError(new Error("GOAWAY received: code=".concat(info.errorCode)));
                                                 try {
                                                     connection === null || connection === void 0 ? void 0 : connection.close();
                                                 }
@@ -3341,7 +3561,7 @@
                                                     switch (_a.label) {
                                                         case 0:
                                                             if (!useFlowControl) return [3 /*break*/, 2];
-                                                            return [4 /*yield*/, this.sendFrameWithFlowControl(parser_1, streamId_2, frame, writer_2, internalController.signal, sendWindowTimeout_1)];
+                                                            return [4 /*yield*/, this.sendFrameWithFlowControl(parser_1, streamId_2, frame, writer, internalController.signal, sendWindowTimeout_1)];
                                                         case 1:
                                                             _a.sent();
                                                             return [3 /*break*/, 4];
@@ -3349,7 +3569,7 @@
                                                             if (internalController.signal.aborted) {
                                                                 throw new Error("Operation aborted");
                                                             }
-                                                            return [4 /*yield*/, writer_2.write(frame)];
+                                                            return [4 /*yield*/, writer.write(frame)];
                                                         case 3:
                                                             _a.sent();
                                                             _a.label = 4;
@@ -3380,51 +3600,44 @@
                                             }); };
                                             // 在各个回调中检查是否已中止
                                             parser_1.onData = function (payload) { return __awaiter(_this, void 0, void 0, function () {
-                                                var newBuffer, lengthBytes, completeMessage;
+                                                var flat, lengthBytes, flat, completeMessage, remaining;
                                                 return __generator(this, function (_a) {
-                                                    // 检查是否已中止
-                                                    if (internalController.signal.aborted) {
+                                                    if (internalController.signal.aborted)
                                                         return [2 /*return*/];
-                                                    }
                                                     try {
-                                                        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 [2 /*return*/];
+                                                            // 读取 gRPC 消息头（5字节）
+                                                            if (expectedMessageLength === -1 && msgTotalLen >= 5) {
+                                                                flat = flattenMsgBuffer();
+                                                                msgChunks = [flat];
+                                                                lengthBytes = flat.slice(1, 5);
+                                                                expectedMessageLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false);
                                                             }
-                                                            // 如果还没有读取消息长度，且缓冲区有足够数据
-                                                            if (expectedMessageLength === -1 && messageBuffer.length >= 5) {
-                                                                lengthBytes = messageBuffer.slice(1, 5);
-                                                                expectedMessageLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false); // big-endian
-                                                            }
-                                                            // 如果知道期望长度且有足够数据
-                                                            if (expectedMessageLength !== -1 &&
-                                                                messageBuffer.length >= expectedMessageLength + 5) {
-                                                                completeMessage = messageBuffer.slice(5, expectedMessageLength + 5);
-                                                                // 调用回调处理这个完整消息
+                                                            // 有完整消息
+                                                            if (expectedMessageLength !== -1 && msgTotalLen >= expectedMessageLength + 5) {
+                                                                flat = flattenMsgBuffer();
+                                                                msgChunks = [flat];
+                                                                completeMessage = flat.slice(5, expectedMessageLength + 5);
                                                                 onDataCallback(completeMessage);
-                                                                // 移除已处理的消息，保留剩余数据
-                                                                messageBuffer = messageBuffer.slice(expectedMessageLength + 5);
+                                                                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);
                                                     }
                                                     return [2 /*return*/];
                                                 });
@@ -3434,7 +3647,7 @@
                                                 if (internalController.signal.aborted)
                                                     return;
                                                 var ackSettingFrame = Http2Frame.createSettingsAckFrame();
-                                                writer_2.write(ackSettingFrame);
+                                                writer.write(ackSettingFrame);
                                             };
                                             parser_1.onHeaders = function (headers) {
                                                 // 检查是否已中止
@@ -3444,20 +3657,16 @@
                                                 if (plainHeaders.get("grpc-status") === "0") ;
                                                 else if (plainHeaders.get("grpc-status") !== undefined) {
                                                     var errMsg = plainHeaders.get("grpc-message") || "gRPC call failed";
-                                                    var err = new Error(errMsg);
-                                                    if (onErrorCallback) {
-                                                        onErrorCallback(err);
-                                                    }
-                                                    else {
-                                                        throw err;
-                                                    }
+                                                    // reportError 统一完成：标记已报错 + abort + 触发回调（幂等，不会重复触发）
+                                                    reportError(new Error(errMsg));
                                                 }
                                             };
                                             // 启动后台流处理
                                             parser_1.processStream(stream).catch(function (error) {
-                                                console.error('Error in processStream:', error);
-                                                if (onErrorCallback) {
-                                                    onErrorCallback(error);
+                                                // abort() 触发的清理错误属于预期行为，不打印错误日志，不重复触发回调
+                                                if (!internalController.signal.aborted) {
+                                                    console.error('Error in processStream:', error);
+                                                    reportError(error);
                                                 }
                                             });
                                             // 检查是否已中止
@@ -3465,56 +3674,52 @@
                                                 throw new Error("Operation aborted");
                                             }
                                             preface = Http2Frame.createPreface();
-                                            return [4 /*yield*/, writer_2.write(preface)];
+                                            return [4 /*yield*/, writer.write(preface)];
                                         case 13:
-                                            _o.sent();
+                                            _p.sent();
                                             // 检查是否已中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
                                             }
                                             settingFrame = Http2Frame.createSettingsFrame();
-                                            return [4 /*yield*/, writer_2.write(settingFrame)];
+                                            return [4 /*yield*/, writer.write(settingFrame)];
                                         case 14:
-                                            _o.sent();
+                                            _p.sent();
                                             // 检查是否已中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
                                             }
                                             return [4 /*yield*/, Promise.race([
-                                                    parser_1.waitForPeerSettings(1000),
-                                                    parser_1.waitForSettingsAck(),
+                                                    parser_1.waitForPeerSettings(1000).catch(function () { }),
+                                                    parser_1.waitForSettingsAck().catch(function () { }),
                                                     new Promise(function (res) { return setTimeout(res, 300); }),
                                                 ])];
                                         case 15:
-                                            _o.sent();
+                                            _p.sent();
                                             // 检查是否已中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
                                             }
-                                            // 检查是否已中止
-                                            if (internalController.signal.aborted) {
-                                                throw new Error("Operation aborted");
-                                            }
-                                            headerFrame = Http2Frame.createHeadersFrame(streamId_2, method, true, this.token);
+                                            headerFrame = Http2Frame.createHeadersFrame(streamId_2, method, true, this.token, this.getAuthority());
                                             if (!(mode === "unary" || mode === "server-streaming")) return [3 /*break*/, 18];
-                                            return [4 /*yield*/, writer_2.write(headerFrame)];
+                                            return [4 /*yield*/, writer.write(headerFrame)];
                                         case 16:
-                                            _o.sent();
+                                            _p.sent();
                                             dfs = Http2Frame.createDataFrames(streamId_2, requestData, true);
                                             return [4 /*yield*/, writeDataFrames_1(dfs)];
                                         case 17:
-                                            _o.sent();
+                                            _p.sent();
                                             // 检查是否已中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
                                             }
-                                            return [3 /*break*/, 47];
+                                            return [3 /*break*/, 45];
                                         case 18:
                                             if (!((mode === "client-streaming" || mode === "bidirectional") &&
-                                                dataSourceCallback)) return [3 /*break*/, 47];
-                                            return [4 /*yield*/, writer_2.write(headerFrame)];
+                                                dataSourceCallback)) return [3 /*break*/, 45];
+                                            return [4 /*yield*/, writer.write(headerFrame)];
                                         case 19:
-                                            _o.sent();
+                                            _p.sent();
                                             // 检查是否已中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
@@ -3523,12 +3728,23 @@
                                             dfs0 = Http2Frame.createDataFrames(streamId_2, requestData, false);
                                             return [4 /*yield*/, writeDataFrames_1(dfs0)];
                                         case 20:
-                                            _o.sent();
-                                            _o.label = 21;
+                                            _p.sent();
+                                            _p.label = 21;
                                         case 21:
                                             batchSize_1 = (options === null || options === void 0 ? void 0 : options.batchSize) || 10;
                                             processingQueue_1 = [];
+                                            batchDoneWaiters_1 = [];
                                             isProcessing_1 = false;
+                                            _notifyBatchDone_1 = function () {
+                                                var ws = batchDoneWaiters_1.splice(0);
+                                                for (var _i = 0, ws_1 = ws; _i < ws_1.length; _i++) {
+                                                    var fn = ws_1[_i];
+                                                    try {
+                                                        fn();
+                                                    }
+                                                    catch ( /* ignore */_a) { /* ignore */ }
+                                                }
+                                            };
                                             processNextBatch_1 = function () { return __awaiter(_this, void 0, void 0, function () {
                                                 var currentBatch, _i, currentBatch_1, item, frames_2, item, frames1, error_3;
                                                 return __generator(this, function (_a) {
@@ -3589,10 +3805,13 @@
                                                         case 10:
                                                             isProcessing_1 = false;
                                                             // 如果队列中还有数据，继续处理
-                                                            if (processingQueue_1.length > 0 &&
-                                                                !internalController.signal.aborted) {
-                                                                // 使用 setTimeout 避免阻塞，让新数据有机会加入队列
-                                                                setTimeout(function () { return processNextBatch_1(); }, 0);
+                                                            if (processingQueue_1.length > 0 && !internalController.signal.aborted) {
+                                                                // 直接递归调用（已是 async，自动让出事件循环）
+                                                                processNextBatch_1().catch(function (err) { console.error("Error in processNextBatch:", err); });
+                                                            }
+                                                            else {
+                                                                // 队列清空，唤醒等待者
+                                                                _notifyBatchDone_1();
                                                             }
                                                             return [7 /*endfinally*/];
                                                         case 11: return [2 /*return*/];
@@ -3615,20 +3834,20 @@
                                                     }
                                                 });
                                             };
-                                            _o.label = 22;
+                                            _p.label = 22;
                                         case 22:
-                                            _o.trys.push([22, 36, , 37]);
-                                            _o.label = 23;
+                                            _p.trys.push([22, 36, , 37]);
+                                            _p.label = 23;
                                         case 23:
-                                            _o.trys.push([23, 29, 30, 35]);
+                                            _p.trys.push([23, 29, 30, 35]);
                                             _a = true, _b = __asyncValues(dataSourceCallback());
-                                            _o.label = 24;
+                                            _p.label = 24;
                                         case 24: return [4 /*yield*/, _b.next()];
                                         case 25:
-                                            if (!(_c = _o.sent(), _g = _c.done, !_g)) return [3 /*break*/, 28];
-                                            _j = _c.value;
+                                            if (!(_c = _p.sent(), _h = _c.done, !_h)) return [3 /*break*/, 28];
+                                            _k = _c.value;
                                             _a = false;
-                                            chunkOrChunks = _j;
+                                            chunkOrChunks = _k;
                                             // 检查是否已中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
@@ -3643,23 +3862,23 @@
                                             return [4 /*yield*/, Promise.all(addPromises)];
                                         case 26:
                                             // 等待当前批次的chunks被添加到队列（不等待处理完成）
-                                            _o.sent();
-                                            _o.label = 27;
+                                            _p.sent();
+                                            _p.label = 27;
                                         case 27:
                                             _a = true;
                                             return [3 /*break*/, 24];
                                         case 28: return [3 /*break*/, 35];
                                         case 29:
-                                            e_1_1 = _o.sent();
+                                            e_1_1 = _p.sent();
                                             e_1 = { error: e_1_1 };
                                             return [3 /*break*/, 35];
                                         case 30:
-                                            _o.trys.push([30, , 33, 34]);
-                                            if (!(!_a && !_g && (_h = _b.return))) return [3 /*break*/, 32];
-                                            return [4 /*yield*/, _h.call(_b)];
+                                            _p.trys.push([30, , 33, 34]);
+                                            if (!(!_a && !_h && (_j = _b.return))) return [3 /*break*/, 32];
+                                            return [4 /*yield*/, _j.call(_b)];
                                         case 31:
-                                            _o.sent();
-                                            _o.label = 32;
+                                            _p.sent();
+                                            _p.label = 32;
                                         case 32: return [3 /*break*/, 34];
                                         case 33:
                                             if (e_1) throw e_1.error;
@@ -3667,7 +3886,7 @@
                                         case 34: return [7 /*endfinally*/];
                                         case 35: return [3 /*break*/, 37];
                                         case 36:
-                                            error_2 = _o.sent();
+                                            error_2 = _p.sent();
                                             remainingQueue = processingQueue_1.splice(0);
                                             remainingQueue.forEach(function (item) {
                                                 try {
@@ -3678,81 +3897,95 @@
                                                 }
                                             });
                                             throw error_2;
-                                        case 37:
-                                            queueWaitStart = Date.now();
-                                            maxQueueWaitMs = timeout;
-                                            _o.label = 38;
-                                        case 38:
-                                            if (!(processingQueue_1.length > 0 || isProcessing_1)) return [3 /*break*/, 40];
-                                            if (internalController.signal.aborted) {
-                                                throw new Error("Operation aborted");
-                                            }
-                                            // 防止无限等待
-                                            if (Date.now() - queueWaitStart > maxQueueWaitMs) {
-                                                remainingQueue = processingQueue_1.splice(0);
-                                                remainingQueue.forEach(function (item) {
-                                                    try {
-                                                        item.reject(new Error("Queue wait timeout"));
+                                        case 37: 
+                                        // 等待所有剩余的数据处理完成（事件驱动，无 10ms 轮询）
+                                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                                var check = function () {
+                                                    if (internalController.signal.aborted) {
+                                                        reject(new Error("Operation aborted"));
+                                                        return;
                                                     }
-                                                    catch (err) {
-                                                        console.warn("Error rejecting timeout promise:", err);
+                                                    if (processingQueue_1.length === 0 && !isProcessing_1) {
+                                                        resolve();
+                                                        return;
                                                     }
-                                                });
-                                                throw new Error("Queue processing timeout");
-                                            }
-                                            return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
-                                        case 39:
-                                            _o.sent();
-                                            return [3 /*break*/, 38];
-                                        case 40:
+                                                    // processNextBatch 结束时会通知这里
+                                                    batchDoneWaiters_1.push(check);
+                                                };
+                                                check();
+                                            })];
+                                        case 38:
+                                            // 等待所有剩余的数据处理完成（事件驱动，无 10ms 轮询）
+                                            _p.sent();
                                             // 检查是否已中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
                                             }
-                                            finalFrame = Http2Frame.createDataFrame(streamId_2, new Uint8Array(), true);
+                                            finalFrame = Http2Frame.createFrame(0x0, 0x01, streamId_2, new Uint8Array(0));
                                             return [4 /*yield*/, writeFrame_1(finalFrame)];
+                                        case 39:
+                                            _p.sent();
+                                            _p.label = 40;
+                                        case 40:
+                                            _p.trys.push([40, 42, , 43]);
+                                            return [4 /*yield*/, writer.flush(timeout)];
                                         case 41:
-                                            _o.sent();
-                                            _o.label = 42;
+                                            _p.sent();
+                                            return [3 /*break*/, 43];
                                         case 42:
-                                            _o.trys.push([42, 44, , 45]);
-                                            return [4 /*yield*/, writer_2.flush(timeout)];
-                                        case 43:
-                                            _o.sent();
-                                            return [3 /*break*/, 45];
+                                            _p.sent();
+                                            return [3 /*break*/, 43];
+                                        case 43: return [4 /*yield*/, writer.end()];
                                         case 44:
-                                            _o.sent();
-                                            return [3 /*break*/, 45];
-                                        case 45: return [4 /*yield*/, writer_2.end()];
-                                        case 46:
-                                            _o.sent();
-                                            _o.label = 47;
-                                        case 47:
+                                            _p.sent();
+                                            _p.label = 45;
+                                        case 45:
                                             // 检查是否已中止
                                             if (internalController.signal.aborted) {
                                                 throw new Error("Operation aborted");
                                             }
+                                            if (!!internalController.signal.aborted) return [3 /*break*/, 48];
                                             return [4 /*yield*/, parser_1.waitForEndOfStream(0)];
-                                        case 48:
-                                            _o.sent();
-                                            if (onEndCallback) {
+                                        case 46:
+                                            _p.sent();
+                                            // 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.
+                                            return [4 /*yield*/, Promise.resolve()];
+                                        case 47:
+                                            // 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.
+                                            _p.sent();
+                                            if (!internalController.signal.aborted && onEndCallback) {
                                                 onEndCallback();
                                             }
-                                            return [3 /*break*/, 64];
+                                            _p.label = 48;
+                                        case 48: return [3 /*break*/, 64];
                                         case 49:
-                                            err_6 = _o.sent();
+                                            err_6 = _p.sent();
                                             // 如果是由于取消导致的错误，使用特定的错误消息
                                             if (internalController.signal.aborted &&
                                                 err_6 instanceof Error &&
                                                 err_6.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_6);
                                             }
-                                            else {
+                                            else if (!errorCallbackFired) {
                                                 if (err_6 instanceof Error) {
                                                     console.error("asyncCall error:", err_6.message);
                                                 }
@@ -3763,45 +3996,53 @@
                                             return [3 /*break*/, 64];
                                         case 50:
                                             clearTimeout(timeoutHandle);
+                                            // 移除外部 abort 监听器，防止 AbortController 复用时触发迟到的 cancelOperation()
+                                            if (contextAbortHandler && (context === null || context === void 0 ? void 0 : context.signal)) {
+                                                context.signal.removeEventListener("abort", contextAbortHandler);
+                                            }
+                                            // 必须先 abort writer（立即强制停止 pushable + stream），再 close stream。
+                                            // 若顺序颠倒：stream.close() 等待服务端半关闭确认，网络异常时永久挂住，
+                                            // writer.abort() 永远不执行 → watchdog / pushable 泄漏。
+                                            // abort() 内部幂等，重复调用安全。
+                                            writer === null || writer === void 0 ? void 0 : writer.abort('Call cleanup');
                                             if (!stream) return [3 /*break*/, 54];
-                                            _o.label = 51;
+                                            _p.label = 51;
                                         case 51:
-                                            _o.trys.push([51, 53, , 54]);
+                                            _p.trys.push([51, 53, , 54]);
                                             return [4 /*yield*/, stream.close()];
                                         case 52:
-                                            _o.sent();
+                                            _p.sent();
                                             return [3 /*break*/, 54];
                                         case 53:
-                                            err_7 = _o.sent();
-                                            console.error("Error closing stream:", err_7);
+                                            _p.sent();
                                             return [3 /*break*/, 54];
                                         case 54:
                                             if (!(options === null || options === void 0 ? void 0 : options.freshConnection)) return [3 /*break*/, 63];
-                                            _o.label = 55;
+                                            _p.label = 55;
                                         case 55:
-                                            _o.trys.push([55, 62, , 63]);
-                                            conns = ((_l = (_k = this.node).getConnections) === null || _l === void 0 ? void 0 : _l.call(_k, this.peerAddr)) || [];
+                                            _p.trys.push([55, 62, , 63]);
+                                            conns = ((_m = (_l = this.node).getConnections) === null || _m === void 0 ? void 0 : _m.call(_l, this.peerAddr)) || [];
                                             _i = 0, conns_1 = conns;
-                                            _o.label = 56;
+                                            _p.label = 56;
                                         case 56:
                                             if (!(_i < conns_1.length)) return [3 /*break*/, 61];
                                             c = conns_1[_i];
-                                            _o.label = 57;
+                                            _p.label = 57;
                                         case 57:
-                                            _o.trys.push([57, 59, , 60]);
-                                            return [4 /*yield*/, ((_m = c.close) === null || _m === void 0 ? void 0 : _m.call(c))];
+                                            _p.trys.push([57, 59, , 60]);
+                                            return [4 /*yield*/, ((_o = c.close) === null || _o === void 0 ? void 0 : _o.call(c))];
                                         case 58:
-                                            _o.sent();
+                                            _p.sent();
                                             return [3 /*break*/, 60];
                                         case 59:
-                                            _o.sent();
+                                            _p.sent();
                                             return [3 /*break*/, 60];
                                         case 60:
                                             _i++;
                                             return [3 /*break*/, 56];
                                         case 61: return [3 /*break*/, 63];
                                         case 62:
-                                            _o.sent();
+                                            _p.sent();
                                             return [3 /*break*/, 63];
                                         case 63:
                                             if (streamSlotAcquired && state) {