stealth-fetch-plus 0.1.1

package/dist/http2/connection.js

@@ -0,0 +1,666 @@
+import { Buffer } from "node:buffer";
+import { EventEmitter } from "node:events";
+import {
+  FrameType,
+  FrameFlags,
+  SettingsId,
+  ErrorCode,
+  CONNECTION_PREFACE,
+  DEFAULT_INITIAL_WINDOW_SIZE,
+  DEFAULT_MAX_FRAME_SIZE,
+  DEFAULT_MAX_HEADER_LIST_SIZE,
+  OPTIMIZED_MAX_FRAME_SIZE,
+  OPTIMIZED_HEADER_TABLE_SIZE,
+  OPTIMIZED_STREAM_WINDOW_SIZE,
+  OPTIMIZED_CONNECTION_WINDOW_SIZE
+} from "./constants.js";
+import {
+  encodeSettings,
+  encodeWindowUpdate,
+  encodePing,
+  encodeGoaway,
+  encodeHeaders,
+  encodeData,
+  encodeRstStream,
+  encodeContinuation
+} from "./framer.js";
+import { FrameParser } from "./parser.js";
+import { HpackEncoder, HpackDecoder } from "./hpack.js";
+import { FlowControlWindow } from "./flow-control.js";
+import { Http2Stream } from "./stream.js";
+class Http2Connection extends EventEmitter {
+  socket;
+  parser;
+  hpackEncoder;
+  hpackDecoder;
+  // Connection state
+  remoteSettings = /* @__PURE__ */ new Map();
+  localSettings = /* @__PURE__ */ new Map();
+  nextStreamId = 1;
+  // client uses odd IDs
+  streams = /* @__PURE__ */ new Map();
+  connectionSendWindow;
+  connectionRecvWindowSize;
+  connectionRecvWindowConsumed = 0;
+  goawayReceived = false;
+  goawaySent = false;
+  initialized = false;
+  closed = false;
+  lastRemoteInitialWindowSize = DEFAULT_INITIAL_WINDOW_SIZE;
+  // Write coalescing
+  pendingWrites = [];
+  flushScheduled = false;
+  flushPromiseResolvers = [];
+  // Settings exchange
+  settingsAckResolve = null;
+  remoteSettingsResolve = null;
+  readyPromise = null;
+  settingsTimeout;
+  // Continuation state
+  continuationStreamId = null;
+  continuationBuffer = [];
+  continuationBufferSize = 0;
+  continuationEndStream = false;
+  constructor(socket, options = {}) {
+    super();
+    this.socket = socket;
+    this.parser = new FrameParser(OPTIMIZED_MAX_FRAME_SIZE);
+    this.connectionSendWindow = new FlowControlWindow(DEFAULT_INITIAL_WINDOW_SIZE);
+    this.connectionRecvWindowSize = options.connectionWindowSize ?? OPTIMIZED_CONNECTION_WINDOW_SIZE;
+    this.settingsTimeout = options.settingsTimeout ?? 5e3;
+    const tableSize = options.headerTableSize ?? OPTIMIZED_HEADER_TABLE_SIZE;
+    this.hpackEncoder = new HpackEncoder(tableSize);
+    this.hpackDecoder = new HpackDecoder(tableSize);
+    this.localSettings.set(SettingsId.ENABLE_PUSH, 0);
+    this.localSettings.set(
+      SettingsId.INITIAL_WINDOW_SIZE,
+      options.initialWindowSize ?? OPTIMIZED_STREAM_WINDOW_SIZE
+    );
+    this.localSettings.set(SettingsId.MAX_FRAME_SIZE, OPTIMIZED_MAX_FRAME_SIZE);
+    this.localSettings.set(SettingsId.HEADER_TABLE_SIZE, tableSize);
+    this.parser.on("frame", (frame) => this.handleFrame(frame));
+    this.parser.on("error", (err) => this.handleError(err));
+    this.socket.on("data", (chunk) => {
+      this.parser.feed(chunk);
+    });
+    this.socket.on("error", (err) => this.handleError(err));
+    this.socket.on("close", () => this.handleSocketClose());
+  }
+  /**
+   * Initialize the HTTP/2 connection.
+   * Sends connection preface + SETTINGS, waits for peer SETTINGS + ACK.
+   */
+  async initialize(timeout = 5e3) {
+    await this.startInitialize();
+    await this.waitForReady(timeout);
+  }
+  /**
+   * Non-blocking initialization: sends connection preface + SETTINGS
+   * immediately without waiting for the peer's response.
+   * Call waitForReady() before sending the first request.
+   */
+  async startInitialize() {
+    await this.writeRaw(CONNECTION_PREFACE);
+    const settings = [];
+    for (const [id, value] of this.localSettings) {
+      settings.push([id, value]);
+    }
+    const initFrames = [encodeSettings(settings)];
+    const connectionWindowDelta = this.connectionRecvWindowSize - DEFAULT_INITIAL_WINDOW_SIZE;
+    if (connectionWindowDelta > 0) {
+      initFrames.push(encodeWindowUpdate(0, connectionWindowDelta));
+    }
+    await this.writeMulti(initFrames);
+    const remoteSettingsPromise = new Promise((resolve) => {
+      this.remoteSettingsResolve = resolve;
+    });
+    const settingsAckPromise = new Promise((resolve) => {
+      this.settingsAckResolve = resolve;
+    });
+    this.readyPromise = Promise.all([remoteSettingsPromise, settingsAckPromise]).then(() => {
+    });
+  }
+  /**
+   * Wait for the peer's SETTINGS + ACK to complete the handshake.
+   * Must be called after startInitialize().
+   */
+  async waitForReady(timeout = 5e3) {
+    if (this.initialized) return;
+    if (!this.readyPromise) {
+      throw new Error("startInitialize() must be called first");
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("HTTP/2 SETTINGS exchange timeout")), timeout);
+    });
+    await Promise.race([this.readyPromise, timeoutPromise]);
+    this.initialized = true;
+  }
+  /**
+   * Create a new HTTP/2 stream for a request.
+   */
+  createStream() {
+    if (this.goawayReceived || this.closed) {
+      throw new Error("Connection is closed or received GOAWAY");
+    }
+    if (this.nextStreamId > 2147483647) {
+      throw new Error("Stream ID space exhausted");
+    }
+    const maxStreams = this.maxConcurrentStreams;
+    if (this.streams.size >= maxStreams) {
+      throw new Error(`MAX_CONCURRENT_STREAMS limit reached (${maxStreams})`);
+    }
+    const streamId = this.nextStreamId;
+    this.nextStreamId += 2;
+    const initialSendWindowSize = this.remoteSettings.get(SettingsId.INITIAL_WINDOW_SIZE) ?? DEFAULT_INITIAL_WINDOW_SIZE;
+    const recvWindowSize = this.localSettings.get(SettingsId.INITIAL_WINDOW_SIZE) ?? OPTIMIZED_STREAM_WINDOW_SIZE;
+    const stream = new Http2Stream(streamId, initialSendWindowSize, recvWindowSize);
+    this.streams.set(streamId, stream);
+    stream.setOnBodyCancel((id) => {
+      if (this.streams.has(id) && !this.closed) {
+        this.writeRaw(encodeRstStream(id, ErrorCode.CANCEL)).catch(() => {
+        });
+        stream.handleRstStream(ErrorCode.CANCEL);
+      }
+    });
+    stream.setOnSendRst((id, code) => {
+      if (this.streams.has(id) && !this.closed) {
+        this.writeRaw(encodeRstStream(id, code)).catch(() => {
+        });
+      }
+    });
+    stream.on("close", () => {
+      this.streams.delete(streamId);
+    });
+    return stream;
+  }
+  /**
+   * Send HEADERS frame for a stream.
+   * Handles CONTINUATION if header block exceeds max frame size.
+   * Auto-waits for SETTINGS exchange if not yet complete.
+   */
+  async sendHeaders(stream, headers, endStream) {
+    if (stream.state === "half-closed-local" || stream.state === "closed") {
+      throw new Error(`Cannot send HEADERS on stream in state: ${stream.state}`);
+    }
+    const [headerBlock] = await Promise.all([
+      this.hpackEncoder.encode(headers),
+      this.initialized ? Promise.resolve() : this.waitForReady(this.settingsTimeout)
+    ]);
+    const maxPayload = this.remoteSettings.get(SettingsId.MAX_FRAME_SIZE) ?? DEFAULT_MAX_FRAME_SIZE;
+    if (headerBlock.length <= maxPayload) {
+      await this.writeRaw(encodeHeaders(stream.id, headerBlock, endStream, true));
+    } else {
+      const frames = [];
+      const firstChunk = headerBlock.subarray(0, maxPayload);
+      frames.push(encodeHeaders(stream.id, firstChunk, endStream, false));
+      let offset = maxPayload;
+      while (offset < headerBlock.length) {
+        const remaining = headerBlock.length - offset;
+        const chunkSize = Math.min(remaining, maxPayload);
+        const chunk = headerBlock.subarray(offset, offset + chunkSize);
+        const endHeaders = offset + chunkSize >= headerBlock.length;
+        frames.push(encodeContinuation(stream.id, chunk, endHeaders));
+        offset += chunkSize;
+      }
+      await this.writeMulti(frames);
+    }
+    stream.open();
+    if (endStream) {
+      stream.halfCloseLocal();
+    }
+  }
+  /**
+   * Send DATA frame(s) for a stream, respecting flow control.
+   * Accepts Buffer (buffered) or ReadableStream (streaming).
+   */
+  async sendData(stream, data, endStream) {
+    if (stream.state === "half-closed-local" || stream.state === "closed") {
+      throw new Error(`Cannot send DATA on stream in state: ${stream.state}`);
+    }
+    if (data instanceof ReadableStream) {
+      return this.sendStreamData(stream, data, endStream);
+    }
+    return this.sendBufferData(stream, data, endStream);
+  }
+  async sendBufferData(stream, data, endStream) {
+    const maxPayload = this.remoteSettings.get(SettingsId.MAX_FRAME_SIZE) ?? DEFAULT_MAX_FRAME_SIZE;
+    let offset = 0;
+    while (offset < data.length) {
+      const remaining = data.length - offset;
+      const chunkSize = Math.min(remaining, maxPayload);
+      try {
+        await this.connectionSendWindow.consume(chunkSize);
+        await stream.sendWindow.consume(chunkSize);
+      } catch (err) {
+        if (err.message?.includes("cancelled")) return;
+        throw err;
+      }
+      const chunk = data.subarray(offset, offset + chunkSize);
+      const isLast = offset + chunkSize >= data.length;
+      await this.writeRaw(encodeData(stream.id, chunk, isLast && endStream));
+      offset += chunkSize;
+    }
+    if (data.length === 0 && endStream) {
+      await this.writeRaw(encodeData(stream.id, Buffer.alloc(0), true));
+    }
+    if (endStream) {
+      stream.halfCloseLocal();
+    }
+  }
+  /** Stream a ReadableStream body as DATA frames with flow control (pull model). */
+  async sendStreamData(stream, body, endStream) {
+    const maxPayload = this.remoteSettings.get(SettingsId.MAX_FRAME_SIZE) ?? DEFAULT_MAX_FRAME_SIZE;
+    const reader = body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const buf = Buffer.from(value);
+        let offset = 0;
+        while (offset < buf.length) {
+          const size = Math.min(buf.length - offset, maxPayload);
+          try {
+            await this.connectionSendWindow.consume(size);
+            await stream.sendWindow.consume(size);
+          } catch (err) {
+            if (err.message?.includes("cancelled")) {
+              reader.cancel().catch(() => {
+              });
+              return;
+            }
+            throw err;
+          }
+          const slice = buf.subarray(offset, offset + size);
+          await this.writeRaw(encodeData(stream.id, slice, false));
+          offset += size;
+        }
+      }
+    } catch (err) {
+      reader.cancel(err).catch(() => {
+      });
+      throw err;
+    } finally {
+      reader.releaseLock();
+    }
+    if (endStream) {
+      await this.writeRaw(encodeData(stream.id, Buffer.alloc(0), true));
+      stream.halfCloseLocal();
+    }
+  }
+  /**
+   * Gracefully close the connection.
+   */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const lastStreamId = Math.max(0, this.nextStreamId - 2);
+    await this.writeRaw(encodeGoaway(lastStreamId, ErrorCode.NO_ERROR)).catch(() => {
+    });
+    for (const stream of this.streams.values()) {
+      stream.handleRstStream(ErrorCode.CANCEL);
+    }
+    this.streams.clear();
+    this.connectionSendWindow.cancel();
+    this.socket.end();
+  }
+  // --- Frame dispatch ---
+  handleFrame(frame) {
+    if (this.continuationStreamId !== null) {
+      if (frame.type !== FrameType.CONTINUATION || frame.streamId !== this.continuationStreamId) {
+        this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+        return;
+      }
+      this.continuationBufferSize += frame.payload.length;
+      if (this.continuationBufferSize > DEFAULT_MAX_HEADER_LIST_SIZE) {
+        this.continuationStreamId = null;
+        this.continuationBuffer = [];
+        this.continuationBufferSize = 0;
+        this.sendGoawayAndClose(ErrorCode.ENHANCE_YOUR_CALM);
+        return;
+      }
+      this.continuationBuffer.push(frame.payload);
+      if (frame.flags & FrameFlags.END_HEADERS) {
+        const fullBlock = Buffer.concat(this.continuationBuffer);
+        const streamId = this.continuationStreamId;
+        const endStream = this.continuationEndStream;
+        this.continuationStreamId = null;
+        this.continuationBuffer = [];
+        this.continuationBufferSize = 0;
+        this.continuationEndStream = false;
+        this.processHeaderBlock(streamId, fullBlock, endStream);
+      }
+      return;
+    }
+    switch (frame.type) {
+      case FrameType.DATA:
+        this.handleDataFrame(frame);
+        break;
+      case FrameType.HEADERS:
+        this.handleHeadersFrame(frame);
+        break;
+      case FrameType.SETTINGS:
+        this.handleSettingsFrame(frame);
+        break;
+      case FrameType.WINDOW_UPDATE:
+        this.handleWindowUpdateFrame(frame);
+        break;
+      case FrameType.PING:
+        this.handlePingFrame(frame);
+        break;
+      case FrameType.GOAWAY:
+        this.handleGoawayFrame(frame);
+        break;
+      case FrameType.RST_STREAM:
+        this.handleRstStreamFrame(frame);
+        break;
+      case FrameType.PUSH_PROMISE:
+        this.writeRaw(encodeGoaway(0, ErrorCode.PROTOCOL_ERROR)).catch(() => {
+        });
+        break;
+      default:
+        break;
+    }
+  }
+  handleDataFrame(frame) {
+    const stream = this.streams.get(frame.streamId);
+    if (!stream) return;
+    if (stream.state === "half-closed-remote" || stream.state === "closed") {
+      this.writeRaw(encodeRstStream(frame.streamId, ErrorCode.STREAM_CLOSED)).catch(() => {
+      });
+      return;
+    }
+    const endStream = !!(frame.flags & FrameFlags.END_STREAM);
+    let payload = frame.payload;
+    if (frame.flags & FrameFlags.PADDED) {
+      if (payload.length < 1) {
+        this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+        return;
+      }
+      const padLength = payload[0];
+      if (padLength >= payload.length) {
+        this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+        return;
+      }
+      payload = payload.subarray(1, payload.length - padLength);
+    }
+    stream.handleData(payload, endStream);
+    if (frame.payload.length > 0) {
+      this.connectionRecvWindowConsumed += frame.payload.length;
+      stream.recvWindowConsumed += frame.payload.length;
+      const updates = [];
+      if (this.connectionRecvWindowConsumed >= this.connectionRecvWindowSize >>> 1) {
+        updates.push(encodeWindowUpdate(0, this.connectionRecvWindowConsumed));
+        this.connectionRecvWindowConsumed = 0;
+      }
+      if (!endStream && stream.recvWindowConsumed >= stream.recvWindowSize >>> 1) {
+        updates.push(encodeWindowUpdate(frame.streamId, stream.recvWindowConsumed));
+        stream.recvWindowConsumed = 0;
+      }
+      if (updates.length > 0) {
+        this.writeMulti(updates).catch(() => {
+        });
+      }
+    }
+  }
+  handleHeadersFrame(frame) {
+    const endHeaders = !!(frame.flags & FrameFlags.END_HEADERS);
+    const endStream = !!(frame.flags & FrameFlags.END_STREAM);
+    let payload = frame.payload;
+    let offset = 0;
+    if (frame.flags & FrameFlags.PADDED) {
+      if (payload.length < 1) {
+        this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+        return;
+      }
+      const padLength = payload[0];
+      offset = 1;
+      if (padLength > payload.length - offset) {
+        this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+        return;
+      }
+      payload = payload.subarray(offset, payload.length - padLength);
+      offset = 0;
+    }
+    if (frame.flags & FrameFlags.PRIORITY) {
+      if (payload.length < 5) {
+        this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+        return;
+      }
+      payload = payload.subarray(5);
+    }
+    if (endHeaders) {
+      this.processHeaderBlock(frame.streamId, payload, endStream);
+    } else {
+      this.continuationStreamId = frame.streamId;
+      this.continuationBuffer = [payload];
+      this.continuationBufferSize = payload.length;
+      this.continuationEndStream = endStream;
+    }
+  }
+  async processHeaderBlock(streamId, headerBlock, endStream) {
+    const stream = this.streams.get(streamId);
+    if (!stream) return;
+    if (stream.state === "half-closed-remote" || stream.state === "closed") {
+      this.writeRaw(encodeRstStream(streamId, ErrorCode.STREAM_CLOSED)).catch(() => {
+      });
+      return;
+    }
+    try {
+      const headers = await this.hpackDecoder.decode(headerBlock);
+      stream.handleHeaders(headers, endStream);
+    } catch {
+      this.sendGoawayAndClose(ErrorCode.COMPRESSION_ERROR);
+    }
+  }
+  handleSettingsFrame(frame) {
+    if (frame.streamId !== 0) {
+      this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+      return;
+    }
+    if (frame.flags & FrameFlags.ACK) {
+      if (frame.payload.length !== 0) {
+        this.sendGoawayAndClose(ErrorCode.FRAME_SIZE_ERROR);
+        return;
+      }
+      if (this.settingsAckResolve) {
+        this.settingsAckResolve();
+        this.settingsAckResolve = null;
+      }
+      return;
+    }
+    const payload = frame.payload;
+    if (payload.length % 6 !== 0) {
+      this.sendGoawayAndClose(ErrorCode.FRAME_SIZE_ERROR);
+      return;
+    }
+    for (let i = 0; i + 5 < payload.length; i += 6) {
+      const id = payload.readUInt16BE(i);
+      const value = payload.readUInt32BE(i + 2);
+      if (id === SettingsId.INITIAL_WINDOW_SIZE && value > 2147483647) {
+        this.sendGoawayAndClose(ErrorCode.FLOW_CONTROL_ERROR);
+        return;
+      }
+      if (id === SettingsId.MAX_FRAME_SIZE && (value < 16384 || value > 16777215)) {
+        this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+        return;
+      }
+      if (id === SettingsId.ENABLE_PUSH && value > 1) {
+        this.sendGoawayAndClose(ErrorCode.PROTOCOL_ERROR);
+        return;
+      }
+      this.remoteSettings.set(id, value);
+      if (id === SettingsId.INITIAL_WINDOW_SIZE) {
+        const oldSize = this.lastRemoteInitialWindowSize;
+        for (const stream of this.streams.values()) {
+          stream.sendWindow.reset(value, oldSize);
+        }
+        this.lastRemoteInitialWindowSize = value;
+      }
+    }
+    this.writeRaw(encodeSettings([], true)).catch(() => {
+    });
+    if (this.remoteSettingsResolve) {
+      this.remoteSettingsResolve();
+      this.remoteSettingsResolve = null;
+    }
+  }
+  handleWindowUpdateFrame(frame) {
+    if (frame.payload.length !== 4) {
+      this.sendGoawayAndClose(ErrorCode.FRAME_SIZE_ERROR);
+      return;
+    }
+    const increment = frame.payload.readUInt32BE(0) & 2147483647;
+    if (increment === 0) {
+      if (frame.streamId === 0) {
+        this.writeRaw(encodeGoaway(0, ErrorCode.PROTOCOL_ERROR)).catch(() => {
+        });
+      } else {
+        this.writeRaw(encodeRstStream(frame.streamId, ErrorCode.PROTOCOL_ERROR)).catch(() => {
+        });
+      }
+      return;
+    }
+    try {
+      if (frame.streamId === 0) {
+        this.connectionSendWindow.update(increment);
+      } else {
+        const stream = this.streams.get(frame.streamId);
+        if (stream) {
+          stream.handleWindowUpdate(increment);
+        }
+      }
+    } catch {
+      if (frame.streamId === 0) {
+        this.sendGoawayAndClose(ErrorCode.FLOW_CONTROL_ERROR);
+      } else {
+        this.writeRaw(encodeRstStream(frame.streamId, ErrorCode.FLOW_CONTROL_ERROR)).catch(
+          () => {
+          }
+        );
+      }
+    }
+  }
+  handlePingFrame(frame) {
+    if (frame.payload.length !== 8) {
+      this.sendGoawayAndClose(ErrorCode.FRAME_SIZE_ERROR);
+      return;
+    }
+    if (frame.flags & FrameFlags.ACK) return;
+    this.writeRaw(encodePing(frame.payload, true)).catch(() => {
+    });
+  }
+  handleGoawayFrame(frame) {
+    if (frame.payload.length < 8) {
+      this.sendGoawayAndClose(ErrorCode.FRAME_SIZE_ERROR);
+      return;
+    }
+    this.goawayReceived = true;
+    const lastStreamId = frame.payload.readUInt32BE(0) & 2147483647;
+    const errorCode = frame.payload.readUInt32BE(4);
+    for (const [id, stream] of this.streams) {
+      if (id > lastStreamId) {
+        stream.handleRstStream(ErrorCode.REFUSED_STREAM);
+        this.streams.delete(id);
+      }
+    }
+    this.emit("goaway", { lastStreamId, errorCode });
+  }
+  handleRstStreamFrame(frame) {
+    if (frame.payload.length !== 4) {
+      this.sendGoawayAndClose(ErrorCode.FRAME_SIZE_ERROR);
+      return;
+    }
+    const stream = this.streams.get(frame.streamId);
+    if (stream) {
+      const errorCode = frame.payload.readUInt32BE(0);
+      stream.handleRstStream(errorCode);
+    }
+  }
+  /** Send GOAWAY with given error code and close the connection. */
+  sendGoawayAndClose(errorCode) {
+    if (this.closed) return;
+    const lastStreamId = Math.max(0, this.nextStreamId - 2);
+    this.writeRaw(encodeGoaway(lastStreamId, errorCode)).catch(() => {
+    });
+    this.closed = true;
+    for (const stream of this.streams.values()) {
+      stream.handleRstStream(ErrorCode.CANCEL);
+    }
+    this.streams.clear();
+    this.connectionSendWindow.cancel();
+    this.socket.end();
+    this.emit("goaway", { lastStreamId, errorCode });
+  }
+  handleError(err) {
+    const errorCode = err.message?.includes("Frame size") ? ErrorCode.FRAME_SIZE_ERROR : ErrorCode.PROTOCOL_ERROR;
+    this.sendGoawayAndClose(errorCode);
+    this.emit("error", err);
+  }
+  handleSocketClose() {
+    if (!this.closed) {
+      this.closed = true;
+      for (const stream of this.streams.values()) {
+        stream.handleRstStream(ErrorCode.CANCEL);
+      }
+      this.streams.clear();
+      this.connectionSendWindow.cancel();
+      this.emit("close");
+    }
+  }
+  /**
+   * Queue a frame for writing. Frames queued in the same microtask
+   * are coalesced into a single socket.write() call.
+   */
+  writeRaw(data) {
+    return new Promise((resolve, reject) => {
+      this.pendingWrites.push(data);
+      this.flushPromiseResolvers.push({ resolve, reject });
+      if (!this.flushScheduled) {
+        this.flushScheduled = true;
+        queueMicrotask(() => this.flush());
+      }
+    });
+  }
+  /** Flush all pending writes as a single socket.write(). */
+  flush() {
+    this.flushScheduled = false;
+    const writes = this.pendingWrites;
+    const resolvers = this.flushPromiseResolvers;
+    this.pendingWrites = [];
+    this.flushPromiseResolvers = [];
+    if (writes.length === 0) return;
+    const merged = writes.length === 1 ? writes[0] : Buffer.concat(writes);
+    this.socket.write(merged, (err) => {
+      for (const r of resolvers) {
+        if (err) r.reject(err);
+        else r.resolve();
+      }
+    });
+  }
+  /** Write multiple frames as a single socket.write() immediately (no microtask delay). */
+  writeMulti(frames) {
+    if (frames.length === 0) return Promise.resolve();
+    const merged = frames.length === 1 ? frames[0] : Buffer.concat(frames);
+    return new Promise((resolve, reject) => {
+      this.socket.write(merged, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  /** Whether the connection has been initialized and is usable */
+  get isReady() {
+    return this.initialized && !this.closed && !this.goawayReceived;
+  }
+  /** Number of currently active (open) streams */
+  get activeStreamCount() {
+    return this.streams.size;
+  }
+  /** Remote peer's MAX_CONCURRENT_STREAMS setting (default: 100) */
+  get maxConcurrentStreams() {
+    return this.remoteSettings.get(SettingsId.MAX_CONCURRENT_STREAMS) ?? 100;
+  }
+}
+export {
+  Http2Connection
+};