grpc-libp2p-client 0.0.37 → 0.0.39

package/src/dc-http2/parser.ts

@@ -8,22 +8,24 @@ type ParserOptions = {
   compatibilityMode?: boolean
 }
 
+const HTTP2_PREFACE = new TextEncoder().encode("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
+
 export class HTTP2Parser {
   buffer: Uint8Array;
   settingsAckReceived: boolean;
   peerSettingsReceived: boolean;
   connectionWindowSize: number;
-  streams: Map<number, any>;
+  streams: Map<number, unknown>;
   defaultStreamWindowSize: number;
   // 发送方向（对端的接收窗口）跟踪
   sendConnWindow: number;
   sendStreamWindows: Map<number, number>;
   peerInitialStreamWindow: number;
   private sendWindowWaiters: Array<() => void>;
-  onSettings?: (frameHeader: any) => void;
-  onData?: (payload: Uint8Array, frameHeader: any) => void;
+  onSettings?: (frameHeader: Frame) => void;
+  onData?: (payload: Uint8Array, frameHeader: Frame) => void;
   onEnd?: () => void;
-  onHeaders?: (headers: Uint8Array, frameHeader: any) => void;
+  onHeaders?: (headers: Uint8Array, frameHeader: Frame) => void;
   onGoaway?: (info: { lastStreamId?: number; errorCode?: number }) => void;
   onSettingsParsed?: (settings: { maxConcurrentStreams?: number; initialWindowSize?: number }) => void;
   endFlag: boolean;
@@ -76,53 +78,58 @@ export class HTTP2Parser {
   }
 
   // 处理单个数据块
-  private _processChunk(chunk: any): void {
+  private _processChunk(chunk: Uint8Array | { subarray(): Uint8Array }): void {
     // chunk 是 Uint8ArrayList 或 Uint8Array
-    const newData = chunk.subarray ? chunk.subarray() : new Uint8Array(chunk);
-
-    // 累积数据到buffer
+    const newData: Uint8Array = 'subarray' in chunk && typeof chunk.subarray === 'function'
+      ? chunk.subarray()
+      : (chunk as Uint8Array);
+    
+    // 原作者之前的 O(N) 内存拷贝优化被保留，去掉了存在 onEnd 竞态的 setTimeout
     const newBuffer = new Uint8Array(this.buffer.length + newData.length);
     newBuffer.set(this.buffer);
     newBuffer.set(newData, this.buffer.length);
     this.buffer = newBuffer;
-    
+
     // 持续处理所有完整的帧
-    while (this.buffer.length >= 9) {
+    let readOffset = 0;
+    while (this.buffer.length - readOffset >= 9) {
       // 判断是否有HTTP/2前导
-      if (this.buffer.length >= 24 && this.isHttp2Preface(this.buffer)) {
-        this.buffer = this.buffer.slice(24);
+      if (this.buffer.length - readOffset >= 24 && this.isHttp2Preface(this.buffer.subarray(readOffset))) {
+        readOffset += 24;
         // 发送SETTINGS帧
         const settingFrame = Http2Frame.createSettingsFrame();
-        this.writer.write(settingFrame as any);
-        break;
+        this.writer.write(settingFrame);
+        continue;
       }
-      const frameHeader = this._parseFrameHeader(this.buffer);
+      
+      const frameHeader = this._parseFrameHeader(this.buffer.subarray(readOffset));
       const totalFrameLength = 9 + frameHeader.length;
 
       // 检查是否有完整的帧
-      if (this.buffer.length < totalFrameLength) {
+      if (this.buffer.length - readOffset < totalFrameLength) {
         break;
       }
       // 获取完整帧数据
-      const frameData = this.buffer.slice(0, totalFrameLength);
+      const frameData = this.buffer.subarray(readOffset, readOffset + totalFrameLength);
 
       // 处理不同类型的帧
       this._handleFrame(frameHeader, frameData).catch((err) => {
         console.error("Error handling frame:", err);
       });
 
-      // 移除已处理的帧
-      this.buffer = this.buffer.slice(totalFrameLength);
+      // 移动偏移量
+      readOffset += totalFrameLength;
+    }
+    
+    if (readOffset > 0) {
+      this.buffer = this.buffer.slice(readOffset);
     }
   }
 
   private isHttp2Preface(buffer: Uint8Array): boolean {
-    const PREFACE = new TextEncoder().encode(
-      "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
-    );
-    if (buffer.length < PREFACE.length) return false;
-    for (let i = 0; i < PREFACE.length; i++) {
-      if (buffer[i] !== PREFACE[i]) return false;
+    if (buffer.length < HTTP2_PREFACE.length) return false;
+    for (let i = 0; i < HTTP2_PREFACE.length; i++) {
+      if (buffer[i] !== HTTP2_PREFACE[i]) return false;
     }
     return true;
   }
@@ -209,7 +216,7 @@ export class HTTP2Parser {
   async waitForSendWindow(streamId: number, minBytes: number = 1, timeoutMs: number = 30000): Promise<void> {
     const start = Date.now();
     return new Promise((resolve, reject) => {
-      let interval: NodeJS.Timeout | null = null;
+      let interval: ReturnType<typeof setInterval> | null = null;
       let settled = false;
       const check = () => {
         const { conn, stream } = this.getSendWindows(streamId);
@@ -319,7 +326,7 @@ export class HTTP2Parser {
           this.peerSettingsReceived = true;
           // 唤醒等待窗口（以防部分实现通过 SETTINGS 改变有效窗口）
           const waiters = this.sendWindowWaiters.splice(0);
-          waiters.forEach(fn => { try { fn(); } catch {} });
+          waiters.forEach(fn => { try { fn(); } catch (e) { console.debug('waiter error', e); } });
         }
         break;
 
@@ -336,7 +343,7 @@ export class HTTP2Parser {
               frameHeader.streamId,
               frameHeader.length ?? 0
             );
-            this.writer.write(streamWindowUpdate as any);
+            this.writer.write(streamWindowUpdate);
           }
 
           // 更新连接级别的窗口
@@ -344,7 +351,7 @@ export class HTTP2Parser {
             0,
             frameHeader.length ?? 0
           );
-          this.writer.write(connWindowUpdate as any);
+          this.writer.write(connWindowUpdate);
         } catch (err) {
           console.error("[HTTP2] Error sending window update:", err);
         }
@@ -381,8 +388,7 @@ export class HTTP2Parser {
         // 处理窗口更新帧
         this.handleWindowUpdateFrame(
           frameHeader,
-          frameData,
-          frameHeader.streamId
+          frameData
         );
         // 更新发送窗口（对端接收窗口）
         try {
@@ -394,8 +400,8 @@ export class HTTP2Parser {
             this.sendStreamWindows.set(frameHeader.streamId, cur + inc);
           }
           const waiters = this.sendWindowWaiters.splice(0);
-          waiters.forEach(fn => { try { fn(); } catch {} });
-        } catch (e) {}
+          waiters.forEach(fn => { try { fn(); } catch (e) { console.debug('waiter error', e); } });
+        } catch { /* ignore WINDOW_UPDATE parse errors */ }
         break;
       case FRAME_TYPES.PING:
         // 处理PING帧
@@ -415,7 +421,7 @@ export class HTTP2Parser {
             console.warn('[HTTP2] GOAWAY received');
             info = {};
           }
-        } catch {}
+        } catch { /* ignore GOAWAY parse errors */ }
         try {
           this.onGoaway?.(info ?? {});
         } catch (err) {
@@ -473,7 +479,7 @@ export class HTTP2Parser {
     // 反馈PONG帧
     const pongFrame = Http2Frame.createPongFrame(frameData.slice(9));
     try {
-      this.writer.write(pongFrame as any);
+      this.writer.write(pongFrame);
     } catch (error) {
       console.error("Error sending PONG frame:", error);
       throw error;
@@ -489,7 +495,7 @@ export class HTTP2Parser {
         return;
       }
       // 如果是0 ,则不设置超时
-      let timeout: NodeJS.Timeout | null = null;
+      let timeout: ReturnType<typeof setTimeout> | null = null;
       if (waitTime > 0) {
         timeout = setTimeout(() => {
           clearInterval(interval);
@@ -561,8 +567,7 @@ export class HTTP2Parser {
   // 处理 WINDOW_UPDATE 帧
   handleWindowUpdateFrame(
     frameHeader: Frame,
-    payload: Uint8Array,
-    streamId: number
+    payload: Uint8Array
   ) {
     try {
       const windowUpdate = this.parseWindowUpdateFrame(payload, frameHeader);

package/src/dc-http2/stream.ts

@@ -41,13 +41,13 @@ export class StreamWriter {
   private lastBackpressureCheck = 0  // 添加时间戳缓存  
   private bytesDrained = 0 // 统计下游实际消化的字节数
   private lastDrainEventAt = 0
-  private watchdogTimer: any
+  private watchdogTimer: ReturnType<typeof setTimeout> | undefined
   private stallStartAt = 0
   private lastBytesDrainedSeen = 0
   private lastBpWarnAt = 0
   private isHandlingError = false // 防止重复错误处理
 
-  private log?: { trace?: (...args: any[]) => void }
+  private log?: { trace?: (...args: unknown[]) => void }
 
   constructor(  
     private stream: Stream,  
@@ -58,7 +58,7 @@ export class StreamWriter {
       throw new Error('StreamWriter requires a valid stream object')
     }
     
-    this.log = { trace: (...args: any[]) => console.debug('[StreamWriter]', ...args) }
+    this.log = { trace: (...args: unknown[]) => console.debug('[StreamWriter]', ...args) }
     
     if (options){
         this.options = {  
@@ -172,10 +172,10 @@ export class StreamWriter {
           // 等待 drain 事件
           await this.stream.onDrain()
         }
-      } catch (err: any) {
+      } catch (err: unknown) {
         // Gracefully handle stream closing errors - 不要传递到 handleError
-        const errMsg = err.message?.toLowerCase() || ''
-        if (err.name === 'StreamStateError' || 
+        const errMsg = (err instanceof Error ? err.message : '').toLowerCase()
+        if ((err instanceof Error && err.name === 'StreamStateError') || 
             errMsg.includes('closing') || 
             errMsg.includes('closed') ||
             errMsg.includes('write to a stream that is closed')) {
@@ -188,6 +188,7 @@ export class StreamWriter {
   }
 
   private createTransform() {  
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;  
     return async function* (source: AsyncIterable<Uint8Array>) {  
       for await (const chunk of source) {  
@@ -197,8 +198,8 @@ export class StreamWriter {
         // 因此这里统计的 bytesDrained 更接近实际被 sink 消费的字节数
         try {
           // 在下游消费后再扣减待消费队列，避免误判“next 没取”
-          if ((self.p as any)?._queueSize != null) {
-            (self.p as any)._queueSize = Math.max(0, (self.p as any)._queueSize - chunk.byteLength)
+          if (self.p._queueSize != null) {
+            self.p._queueSize = Math.max(0, self.p._queueSize - chunk.byteLength)
           }
           self.bytesDrained += chunk.byteLength
           const now = Date.now()
@@ -218,9 +219,10 @@ export class StreamWriter {
   }  
 
   // 简单的卡顿看门狗：当队列长期高位且 bytesDrained 无进展时发出 stalled 事件
+  // 使用递归 setTimeout 而非 setInterval，避免标签页后台恢复时回调堆积导致 Violation
   private startWatchdog(intervalMs: number = 500, stallMs: number = 1500) {
     if (this.watchdogTimer) return
-    this.watchdogTimer = setInterval(() => {
+    const tick = () => {
       if (this.abortController.signal.aborted) return
       const baseThreshold = this.options.bufferSize! * 0.7
       const q = this.queueSize
@@ -229,7 +231,13 @@ export class StreamWriter {
         if (this.lastBytesDrainedSeen === this.bytesDrained) {
           if (!this.stallStartAt) this.stallStartAt = now
           if (now - this.stallStartAt >= stallMs) {
-            this.dispatchEvent(new CustomEvent('stalled', { detail: { queueSize: q, drained: this.bytesDrained, sinceMs: now - this.stallStartAt } }))
+            // 异步触发事件，让当前 tick 立即返回，避免同步事件处理器阻塞主线程
+            const detail = { queueSize: q, drained: this.bytesDrained, sinceMs: now - this.stallStartAt }
+            setTimeout(() => {
+              if (!this.abortController.signal.aborted) {
+                this.dispatchEvent(new CustomEvent('stalled', { detail }))
+              }
+            }, 0)
             // 避免持续触发，推进起点
             this.stallStartAt = now
           }
@@ -242,10 +250,13 @@ export class StreamWriter {
         // 队列回落，重置
         this.stallStartAt = 0
       }
-    }, intervalMs)
+      // 本次 tick 完成后再安排下一次，不会因主线程繁忙而堆积
+      this.watchdogTimer = setTimeout(tick, intervalMs)
+    }
+    this.watchdogTimer = setTimeout(tick, intervalMs)
   }
 
-  async write(data: ArrayBuffer | Blob | string): Promise<void> {  
+  async write(data: ArrayBuffer | Uint8Array | Blob | string): Promise<void> {  
     // 静默处理 aborted 状态，避免在正常的流关闭场景下抛出错误
     if (this.abortController.signal.aborted) {
       return Promise.resolve()
@@ -272,9 +283,10 @@ export class StreamWriter {
     })  
   }  
 
-  private async convertToBuffer(data: ArrayBuffer | Blob | string): Promise<ArrayBuffer> {  
+  private async convertToBuffer(data: ArrayBuffer | Uint8Array | Blob | string): Promise<ArrayBuffer> {  
     if (data instanceof Blob) return data.arrayBuffer()  
-    if (typeof data === 'string') return new TextEncoder().encode(data).buffer  
+    if (typeof data === 'string') return new TextEncoder().encode(data).buffer as ArrayBuffer
+    if (data instanceof Uint8Array) return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer
     return data  
   }  
 
@@ -438,9 +450,9 @@ export class StreamWriter {
     if (this.stream && typeof this.stream.close === 'function') {
       try {
         await this.stream.close()
-      } catch (err: any) {
+      } catch (err: unknown) {
         // 忽略关闭已关闭流的错误
-        const errMsg = err.message?.toLowerCase() || ''
+        const errMsg = (err instanceof Error ? err.message : '').toLowerCase()
         if (!errMsg.includes('closed') && !errMsg.includes('closing')) {
           this.log?.trace?.('Stream close error:', err)
         }
@@ -461,15 +473,16 @@ export class StreamWriter {
       // 先检查流状态，避免在已关闭的流上调用 abort
       if (this.stream && typeof this.stream.abort === 'function') {
         // 检查流的状态，避免操作已关闭的流
-        const streamState = (this.stream as any).status || (this.stream as any).state
+        const streamState = (this.stream as { status?: string; state?: string }).status ||
+                             (this.stream as { status?: string; state?: string }).state
         if (streamState !== 'closed' && streamState !== 'closing') {
           this.stream.abort(new Error(reason))
         }
       }
-    } catch (err: any) {
+    } catch (err: unknown) {
       // Stream may already be closed, ignore all stream-related errors
       // 完全忽略流操作错误，避免在错误处理中再次抛出错误
-      const errMsg = err.message?.toLowerCase() || ''
+      const errMsg = (err instanceof Error ? err.message : '').toLowerCase()
       if (!errMsg.includes('closed') && !errMsg.includes('closing') && !errMsg.includes('write')) {
         this.log?.trace?.('Stream abort error:', err)
       }
@@ -494,17 +507,17 @@ export class StreamWriter {
     
     // 立即拒绝所有待处理的写入任务，避免它们继续执行
     const pendingTasks = this.writeQueue.splice(0)
-    pendingTasks.forEach(task => {
+    pendingTasks.forEach(() => {
       // 这些任务的 Promise 会在执行时因为检查到 aborted 而被拒绝
     })
     
     try {
       this.p.end()  
-    } catch (err) {
+    } catch {
       // Ignore errors when ending pushable
     }
     
-    if (this.watchdogTimer) { clearInterval(this.watchdogTimer); this.watchdogTimer = undefined }
+    if (this.watchdogTimer) { clearTimeout(this.watchdogTimer); this.watchdogTimer = undefined }
   }  
 
   // 等待内部队列被下游完全消费（用于在结束前确保尽量发送完数据）
@@ -526,7 +539,7 @@ export class StreamWriter {
   }
 
   // 事件系统  
-  private listeners = new Map<string, Function[]>()  
+  private listeners = new Map<string, ((event: CustomEvent) => void)[]>()  
   
   addEventListener(type: string, callback: (event: CustomEvent) => void) {  
     const handlers = this.listeners.get(type) || []  

package/src/dc-http2/types.ts

@@ -10,7 +10,7 @@ type Frame = {
     type: Byte;
     flags: Byte;
     streamId: number;
-    payload?: any;
+    payload?: unknown;
 }
 
 type FrameSettingPayload = { identifier: number; value: number }[]