quico 0.7.0 → 0.8.0

package/index.js

@@ -28,8 +28,10 @@ import lemonTls from 'lemon-tls';
 
 // Encrypted Client Hello keys (RFC 9849) — LemonTLS's; for createServer's `ech`.
 const generateEchKey = lemonTls.generateEchKey;
-import { WebTransport, WebTransportError } from './src/webtransport.js';
+import { WebTransport, WebTransportError, WebTransportBidirectionalStream, WebTransportReceiveStream, WebTransportSendStream,
+         WebTransportWriter, WebTransportSendGroup, WebTransportDatagramsWritable, WebTransportDatagramDuplexStream } from './src/webtransport.js';
 import { WebSocket } from './src/ws_client.js';
+import { WebSocketStream, WebSocketError } from './src/ws_stream.js';
 import { connectUdp } from './src/connect_udp_client.js';
 import { WebSocketServer, upgradeWebSocket } from './src/ws_server.js';
 import { ja4h } from './src/ja4h.js';
@@ -52,7 +54,8 @@ import { request as h3Request } from './src/h3_client.js';
 const api = {
   createServer, request, get, Agent, globalAgent,
   IncomingMessage, ServerResponse, ClientRequest,
-  connectUdp, createSecureContext, generateEchKey, WebTransport, WebTransportError, WebSocket, WebSocketServer, upgradeWebSocket,
+  connectUdp, createSecureContext, generateEchKey, WebTransport, WebTransportError, WebTransportBidirectionalStream, WebTransportReceiveStream, WebTransportSendStream,
+  WebTransportWriter, WebTransportSendGroup, WebTransportDatagramsWritable, WebTransportDatagramDuplexStream, WebSocket, WebSocketStream, WebSocketError, WebSocketServer, upgradeWebSocket,
   ja4h, h2Fingerprint, h3Fingerprint, observeH2, profileRequest,
   createQuicServer, createQuicClientSocket, createTcpListener,
   createH1Server, createH2Server, createH3Server,
@@ -62,7 +65,8 @@ const api = {
 export {
   createServer, request, get, Agent, globalAgent,
   IncomingMessage, ServerResponse, ClientRequest,
-  connectUdp, createSecureContext, generateEchKey, WebTransport, WebTransportError, WebSocket, WebSocketServer, upgradeWebSocket,
+  connectUdp, createSecureContext, generateEchKey, WebTransport, WebTransportError, WebTransportBidirectionalStream, WebTransportReceiveStream, WebTransportSendStream,
+  WebTransportWriter, WebTransportSendGroup, WebTransportDatagramsWritable, WebTransportDatagramDuplexStream, WebSocket, WebSocketStream, WebSocketError, WebSocketServer, upgradeWebSocket,
   ja4h, h2Fingerprint, h3Fingerprint, observeH2, profileRequest,
   createQuicServer, createQuicClientSocket, createTcpListener,
   createH1Server, createH2Server, createH3Server,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quico",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "A pure JavaScript implementation of QUIC, HTTP/3, QPACK, and WebTransport for Node.js",
   "type": "module",
   "main": "index.cjs",
@@ -12,7 +12,7 @@
     }
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=24.0.0"
   },
   "types": "index.d.ts",
   "files": [
@@ -37,6 +37,9 @@
     "http3-client",
     "h3-node",
     "webtransport",
+    "moqt",
+    "masque",
+    "connect-udp",
     "websocket",
     "datagram",
     "udp",
@@ -65,7 +68,7 @@
     "email": "support@quicojs.dev",
     "url": "https://github.com/colocohen/quico/issues"
   },
-  "homepage": "https://github.com/colocohen/quico#readme",
+  "homepage": "https://quicojs.dev",
   "funding": [
     {
       "type": "github",
@@ -78,6 +81,6 @@
   ],
   "dependencies": {
     "flat-ranges": "^2.2.0",
-    "lemon-tls": "^0.9.0"
+    "lemon-tls": "^0.10.0"
   }
 }

package/src/connect_udp_client.js

@@ -407,6 +407,15 @@ function ProxyH3Connection(key, proxy, o, ech) {
       // Each ticket the proxy sends: the agent's, and each tunnel's 'session'.
       onSocket: function (q) {
         self.quic = q;
+        // The connection is over the moment either side's CONNECTION_CLOSE is
+        // known ('closing'), not when its draining period (RFC 9000 §10.2,
+        // some 3 s) ends and 'close' comes: each tunnel on it is told at
+        // once, and the connection leaves the pool at once — a tunnel opened
+        // meanwhile joined a connection already closed, and failed. As the
+        // WebTransport client hears it (r69). Only once open: a handshake
+        // that ends is onError's to report — an ECH rejection is retried
+        // there with the server's new keys, not failed.
+        q.on('closing', function () { if (self.quic === q && self.state === 'open') self._gone(); });
         q.on('session', function (s) {
           self.sessions.keep(s);
           self.tunnels.forEach(function (t) { if (t.session) t.session(s); });

package/src/h1_server.js

@@ -155,6 +155,8 @@ function createServer(options, handler) {
 
     socket.on('data', function (chunk) {
       if (destroyed) return;
+      // A request is arriving: not idle (closeIdleConnections, close()).
+      socket._quicoBusy = true;
 
       try {
         parser.execute(chunk);
@@ -231,6 +233,7 @@ function createServer(options, handler) {
     });
 
     parser.on('headers', function (info) {
+      socket._quicoBusy = true;
       clearTimer();
       setTimer(requestTimeout, 'request');
       served++;
@@ -359,6 +362,7 @@ function createServer(options, handler) {
         socket: socket
       });
       req.rawHeaders = info.rawHeaders;
+      req.upgrade = true;
       req._endData();
 
       // Hand the raw socket over, exactly as node:http does. `head` is the
@@ -452,7 +456,7 @@ function createServer(options, handler) {
         willClose = !keepAlive;
 
         if (keepAlive && info.httpVersion === '1.0') headers['keep-alive'] = 'timeout=5';
-        if (!('date' in headers)) headers['date'] = httpDate();
+        if (!('date' in headers) && res.sendDate !== false) headers['date'] = httpDate();
         // A function when the server was built before its port was known —
         // the unified server builds its layers at creation and learns the
         // port from listen(), or from options.port when fed from outside.
@@ -484,6 +488,13 @@ function createServer(options, handler) {
         if (typeof callback === 'function') process.nextTick(callback);
       };
 
+      // 102 Processing (node:http's writeProcessing): an interim response,
+      // as Early Hints are.
+      res.writeProcessing = function () {
+        if (res.headersSent || info.httpVersion === '1.0' || destroyed) return;
+        try { socket.write(buildResponseHead(102, null, {})); } catch (e) {}
+      };
+
       res._write = function (chunk, encoding, callback) {
         if (!res.headersSent) res._flushHeaders();
         if (typeof chunk === 'string') chunk = Buffer.from(chunk, encoding);
@@ -526,6 +537,7 @@ function createServer(options, handler) {
       function onResponseComplete() {
         clearTimer();
         current = null;
+        socket._quicoBusy = false;
         // Whatever of the body is still to come is dropped from here on (the
         // parser reads it, to find the next request): the reader no longer
         // holds the socket back.
@@ -573,7 +585,7 @@ function createServer(options, handler) {
       ca: options.ca,
       SNICallback: options.SNICallback
     });
-    tcpServer.register('http/1.1', handleConnection);
+    tcpServer.register('http/1.1', handleConnection, { managesClose: true });
     tcpServer.on('error', function (err) { ev.emit('error', err); });
     tcpServer.on('clientError', function (err, sock) { ev.emit('clientError', err, sock); });
     tcpServer.on('tlsClientError', function (err, sock) { ev.emit('tlsClientError', err, sock); });
@@ -584,17 +596,42 @@ function createServer(options, handler) {
     return server;
   }
 
-  function close(callback) {
+  // ---- Closing, as node:http ----
+  //
+  // Idle: a connection between requests (or before its first) — no request
+  // arriving, no response being written. Closing one costs nothing.
+  function closeIdleConnections() {
+    for (var s of connections) if (!s._quicoBusy) { try { s.destroy(); } catch (e) {} }
+  }
+  // All, mid-request too. Not the sockets handed to 'upgrade' (a WebSocket):
+  // those left this server at the upgrade, as in node:http.
+  function closeAllConnections() {
+    for (var s of connections) { try { s.destroy(); } catch (e) {} }
+  }
+  // No new connections, the idle ones closed; each busy one closes as its
+  // response completes (onResponseComplete). It used to end every socket at
+  // once: a response being written was cut off.
+  function beginClose() {
     closing = true;
-    if (!tcpServer) {
-      // Sockets we were handed rather than accepted: still ours to close.
-      for (var s of connections) { try { s.end(); } catch (e) {} }
-      if (callback) callback();
-      return;
-    }
+    closeIdleConnections();
+  }
+
+  function close(callback) {
+    beginClose();
+    if (!tcpServer) { if (callback) callback(); return; }
     tcpServer.close(callback);
   }
 
+  // node:http's timeouts and limits, changed while the server runs: from
+  // the next request (or connection) on.
+  function setLimits(o) {
+    if (o.headersTimeout !== undefined) headersTimeout = o.headersTimeout;
+    if (o.keepAliveTimeout !== undefined) keepAliveTimeout = o.keepAliveTimeout;
+    if (o.requestTimeout !== undefined) requestTimeout = o.requestTimeout;
+    if (o.maxHeaderCount !== undefined) maxHeaderCount = o.maxHeaderCount;
+    if (o.maxRequestsPerSocket !== undefined) maxRequests = maxRequestsPerSocket(o.maxRequestsPerSocket);
+  }
+
   function address() {
     return tcpServer && tcpServer.address ? tcpServer.address() : null;
   }
@@ -610,6 +647,11 @@ function createServer(options, handler) {
     emit: function () { ev.emit.apply(ev, arguments); return server; },
     listenerCount: function (n) { return ev.listenerCount(n); },
     setTimeout: function (ms) { headersTimeout = ms; return server; },
+    closeIdleConnections: closeIdleConnections,
+    closeAllConnections: closeAllConnections,
+    beginClose: beginClose,
+    setLimits: setLimits,
+    get connectionCount() { return connections.size; },
 
     /** Attach an already-connected Duplex, bypassing the listener. Lets the
      *  unified server share one TCP port, and makes the whole stack testable

package/src/h2_server.js

@@ -255,6 +255,20 @@ function createServer(options, handler) {
     });
 
     connections.add(socket);
+    socket._quicoH2 = {
+      idle: function () { return h2.activeStreams === 0; },
+      drain: function () {
+        if (destroyed || draining) return;
+        draining = true;
+        try { h2.sendGoaway(F.ERROR.NO_ERROR); } catch (e) {}
+        finishIfDone();
+      },
+      destroy: function () {
+        if (destroyed) return;
+        try { h2.sendGoaway(F.ERROR.NO_ERROR); } catch (e) {}
+        destroy(null, true);
+      }
+    };
 
     // `linger`: end the socket rather than destroy it — what was written last
     // (the GOAWAY saying why) leaves first — and destroy it if the peer has
@@ -340,8 +354,12 @@ function createServer(options, handler) {
     // only (HTTP/1.1 ends its socket with the client's, as node:http does).
     socket.allowHalfOpen = true;
     var peerEnded = false;
+    // Closing (server.close(), closeIdleConnections): GOAWAY sent — no new
+    // streams — and the connection ends with its last stream, as when the
+    // peer half-closes.
+    var draining = false;
     function finishIfDone() {
-      if (destroyed || !peerEnded || h2.activeStreams > 0) return;
+      if (destroyed || !(peerEnded || draining) || h2.activeStreams > 0) return;
       try { h2.sendGoaway(F.ERROR.NO_ERROR); } catch (e) {}
       destroy(null, true);
     }
@@ -375,7 +393,7 @@ function createServer(options, handler) {
       // a long-lived connection kept every WebSocket it ever carried).
       var st = streams[id];
       if (st && st.duplex) delete streams[id];
-      if (peerEnded) process.nextTick(finishIfDone);
+      if (peerEnded || draining) process.nextTick(finishIfDone);
     });
     // A response that waits for the client to open a window, from a client
     // that has half-closed: it sends nothing more — no WINDOW_UPDATE either —
@@ -435,6 +453,7 @@ function createServer(options, handler) {
           delete streams[streamId];
           return;
         }
+        creq.upgrade = true;
         ev.emit('upgrade', creq, stream, Buffer.alloc(0));
         return;
       }
@@ -686,7 +705,7 @@ function createServer(options, handler) {
 
         bodyAllowed = !statusHasNoBody(code) && req.method !== 'HEAD';
 
-        if (!('date' in headers)) headers['date'] = httpDate();
+        if (!('date' in headers) && res.sendDate !== false) headers['date'] = httpDate();
         // A function when the server was built before its port was known —
         // the unified server builds its layers at creation and learns the
         // port from listen(), or from options.port when fed from outside.
@@ -767,6 +786,12 @@ function createServer(options, handler) {
         if (typeof callback === 'function') process.nextTick(callback);
       };
 
+      // 102 Processing (node:http's writeProcessing), as Early Hints go.
+      res.writeProcessing = function () {
+        if (res.headersSent || res._aborted || destroyed) return;
+        try { h2.sendHeaders(streamId, buildResponsePseudoHeaders(102, {}), false); } catch (e) {}
+      };
+
       /**
        * The response's priority, as the server decides it: { urgency (0..7,
        * 0 first), incremental } — RFC 9218, as h3_server's. It replaces what
@@ -821,7 +846,7 @@ function createServer(options, handler) {
       ca: options.ca,
       SNICallback: options.SNICallback
     });
-    listener.register('h2', handleConnection);
+    listener.register('h2', handleConnection, { managesClose: true });
     listener.on('error', function (err) { ev.emit('error', err); });
     listener.on('clientError', function (err, sock) { ev.emit('clientError', err, sock); });
     listener.on('tlsClientError', function (err, sock) { ev.emit('tlsClientError', err, sock); });
@@ -832,16 +857,35 @@ function createServer(options, handler) {
     return server;
   }
 
-  function close(callback) {
+  // ---- Closing, as node:http (see h1_server) ----
+  // Idle: no stream open. Closed with GOAWAY first, so the client knows
+  // nothing it sent was lost.
+  function closeIdleConnections() {
+    for (var s of connections) if (s._quicoH2 && s._quicoH2.idle()) s._quicoH2.drain();
+  }
+  function closeAllConnections() {
+    for (var s of connections) if (s._quicoH2) s._quicoH2.destroy();
+  }
+  // GOAWAY on every connection: those idle end now, the others when their
+  // last stream does. It used to end every socket at once — responses in
+  // progress were cut off.
+  function beginClose() {
     closing = true;
-    if (!listener) {
-      for (var s of connections) { try { s.end(); } catch (e) {} }
-      if (callback) callback();
-      return;
-    }
+    for (var s of connections) if (s._quicoH2) s._quicoH2.drain();
+  }
+
+  function close(callback) {
+    beginClose();
+    if (!listener) { if (callback) callback(); return; }
     listener.close(callback);
   }
 
+  function setLimits(o) {
+    if (o.headersTimeout !== undefined) headersTimeout = o.headersTimeout;
+    if (o.requestTimeout !== undefined) requestTimeout = o.requestTimeout;
+    if (o.maxRequestsPerSocket !== undefined) maxRequests = maxRequestsPerSocket(o.maxRequestsPerSocket);
+  }
+
 
   var server = {
     listen: listen,
@@ -852,7 +896,12 @@ function createServer(options, handler) {
     once: function (n, f) { ev.once(n, f); return server; },
     off: function (n, f) { ev.off(n, f); return server; },
     emit: function () { ev.emit.apply(ev, arguments); return server; },
-    listenerCount: function (n) { return ev.listenerCount(n); }
+    listenerCount: function (n) { return ev.listenerCount(n); },
+    closeIdleConnections: closeIdleConnections,
+    closeAllConnections: closeAllConnections,
+    beginClose: beginClose,
+    setLimits: setLimits,
+    get connectionCount() { return connections.size; }
   };
 
   return server;

package/src/h3.js

@@ -87,8 +87,12 @@ import {
 //  deliberately NOT part of this move.
 // ============================================================
 
+// One decoder for the module: decode() holds no state between calls (no
+// `stream` option), and constructing one per name and per value cost more
+// than the decoding itself.
+var _utf8Decoder = new TextDecoder();
 function _text(bytes) {
-  return new TextDecoder().decode(bytes);
+  return _utf8Decoder.decode(bytes);
 }
 
 // Every decodeStringLiteral() call below passes strict = true, enabling the
@@ -249,7 +253,10 @@ function parseQpackHeaderBlock(buf, dynamicTable, totalInserts, maxEntries, maxS
 
 
 // ============================================================
-//  H3 Frame build/parse
+//  H3 Frame build
+//
+//  Frames are read in place, from each stream's own buffer, as the bytes
+//  arrive: processBidiStream and processControlStream in H3Connection.
 // ============================================================
 
 function buildH3Frames(frames) {
@@ -262,43 +269,6 @@ function buildH3Frames(frames) {
   return concatUint8Arrays(parts);
 }
 
-function extractH3Frames(chunks, fromOffset) {
-  if (!chunks || chunks.length === 0) return { frames: [], new_from_offset: fromOffset };
-
-  var buffers = [];
-  var acc = 0;
-  for (var i = 0; i < chunks.length; i++) {
-    var nextAcc = acc + chunks[i].length;
-    if (fromOffset < nextAcc) {
-      buffers.push(chunks[i].slice(fromOffset - acc));
-      for (var j = i + 1; j < chunks.length; j++) buffers.push(chunks[j]);
-      break;
-    }
-    acc = nextAcc;
-  }
-
-  if (buffers.length === 0) return { frames: [], new_from_offset: fromOffset };
-
-  var combined = concatUint8Arrays(buffers);
-  var offset = 0, frames = [];
-
-  while (offset < combined.length) {
-    var start = offset;
-    var ft = readVarInt(combined, offset);
-    if (!ft) break;
-    offset += ft.byteLength;
-    var len = readVarInt(combined, offset);
-    if (!len) { offset = start; break; }
-    offset += len.byteLength;
-    if (offset + len.value > combined.length) { offset = start; break; }
-    frames.push({ frame_type: ft.value, payload: combined.slice(offset, offset + len.value) });
-    offset += len.value;
-  }
-
-  return { frames: frames, new_from_offset: fromOffset + offset };
-}
-
-
 // ============================================================
 //  H3 Settings
 // ============================================================
@@ -369,24 +339,14 @@ function parseSettingsPayload(buf) {
 //  QPACK Encoder Instructions (from peer's encoder stream)
 // ============================================================
 
-function parseQpackEncoderInstructions(chunks, fromOffset, maxLiteral) {
-  if (!chunks || chunks.length === 0) return { instructions: [], new_from_offset: fromOffset, need: 0 };
+// Parse the encoder-stream instructions in `combined` — the stream's unparsed
+// bytes, from its read position. Returns the complete instructions, how many
+// bytes they took (consumed), and, when the last one is cut short, how many
+// bytes it needs (need). It used to take the stream's chunks and an offset
+// and join them itself; the one caller already hands it a single buffer.
+function parseQpackEncoderInstructions(combined, maxLiteral) {
+  if (!combined || combined.length === 0) return { instructions: [], consumed: 0, need: 0 };
   if (maxLiteral === undefined) maxLiteral = Infinity;
-
-  var buffers = [];
-  var acc = 0;
-  for (var i = 0; i < chunks.length; i++) {
-    var nextAcc = acc + chunks[i].length;
-    if (fromOffset < nextAcc) {
-      buffers.push(chunks[i].slice(fromOffset - acc));
-      for (var j = i + 1; j < chunks.length; j++) buffers.push(chunks[j]);
-      break;
-    }
-    acc = nextAcc;
-  }
-  if (buffers.length === 0) return { instructions: [], new_from_offset: fromOffset, need: 0 };
-
-  var combined = buffers.length === 1 ? buffers[0] : concatUint8Arrays(buffers);
   var pos = 0;
   var instructions = [];
   // When the last instruction is cut short: how many bytes, from its start,
@@ -457,7 +417,7 @@ function parseQpackEncoderInstructions(chunks, fromOffset, maxLiteral) {
     }
   }
 
-  return { instructions: instructions, new_from_offset: fromOffset + pos,
+  return { instructions: instructions, consumed: pos,
            need: needAbs > pos ? needAbs - pos : 0 };
 }
 
@@ -1700,7 +1660,7 @@ function H3Connection(options) {
       // Only the unparsed bytes are copied (once per completed instruction,
       // given `need`), and no literal larger than our table can hold is
       // waited for.
-      ext = parseQpackEncoderInstructions([copyBytes(s, s.buffered)], 0,
+      ext = parseQpackEncoderInstructions(copyBytes(s, s.buffered),
                                           context.local_qpack_max_table_capacity);
     } catch (err) {
       // RFC 9204 §4.2: a malformed encoder stream is QPACK_ENCODER_STREAM_ERROR,
@@ -1708,7 +1668,7 @@ function H3Connection(options) {
       err.h3ErrorCode = H3_ERR.QPACK_ENCODER_STREAM_ERROR;
       throw err;
     }
-    consumeBytes(s, ext.new_from_offset);
+    consumeBytes(s, ext.consumed);
     s.need = ext.need;
     if (ext.instructions.length === 0) return;
 
@@ -2000,6 +1960,11 @@ function H3Connection(options) {
       if (avail < headLen + len.value) break;
       // Waits for the encoder stream when it must (see sectionBlocked): the
       // frame stays in the buffer, read again once unblocked.
+      // Already waiting, and the inserts it needs are not here yet: nothing
+      // to do. The frame was copied and its prefix decoded again on every
+      // packet that arrived on the stream meanwhile.
+      if (_blocked.has(Number(streamId)) &&
+          _blocked.get(Number(streamId)) > context.remote_qpack_table_base_index) return;
       var whole = copyBytes(s, headLen + len.value);
       var payload = whole.subarray(headLen);
       if (sectionBlocked(Number(streamId), payload)) return;
@@ -2138,7 +2103,11 @@ function H3Connection(options) {
     var list = [];
     for (var hname in headers) {
       if (Object.prototype.hasOwnProperty.call(headers, hname)) {
-        list.push([hname, headers[hname]]);
+        // A list: one field line per value (Set-Cookie above all, which may
+        // not be combined), not String(list).
+        var hv = headers[hname];
+        if (Array.isArray(hv)) { for (var hi = 0; hi < hv.length; hi++) list.push([hname, String(hv[hi])]); }
+        else list.push([hname, hv]);
       }
     }
     var enc = qpackEncodeHeaderBlock(list, encoderTable, {

package/src/h3_client.js

@@ -476,7 +476,11 @@ function request(options, callback) {
         return e;
       });
     });
-    conn.quic.on('close', function () {
+    // On 'closing' — the moment the connection is over (a CONNECTION_CLOSE
+    // either way, the idle timeout) — not only on 'close', which waits out
+    // the draining period (RFC 9000 §10.2, ~3 s): a response the server cut
+    // off hung that long before it failed.
+    function connectionOver() {
       failAll(0, function (sid) {
         var e = new Error('HTTP/3 connection closed before the response ended');
         e.code = 'ERR_HTTP3_CONNECTION_CLOSED';
@@ -484,7 +488,9 @@ function request(options, callback) {
         e.retryable = sid >= conn._goawayId;
         return e;
       });
-    });
+    }
+    conn.quic.on('closing', connectionOver);
+    conn.quic.on('close', connectionOver);
   }
 
 
@@ -662,17 +668,28 @@ function request(options, callback) {
     else if (reqBody.length) startStreaming();
   }
 
-  function requestHeaders() {
+  // contentLength: the body's size when it is known whole (ended before it
+  // went) — sent as h2_client and node:https send it, and as browsers do. A
+  // server that decides whether there is a body from the headers (Express's
+  // body-parser: content-length or transfer-encoding) saw none over HTTP/3,
+  // and req.body came out empty.
+  function requestHeaders(contentLength) {
     var h3Headers = {
       ':method': method,
       ':scheme': 'https',
       ':authority': hostname + (port !== 443 ? ':' + port : ''),
       ':path': path
     };
-    for (var name in headers) h3Headers[name.toLowerCase()] = String(headers[name]);
+    // A repeated field (an array) stays one line per value: String(list)
+    // made two cookies "a=1,b=2", which the server reads as one cookie.
+    for (var name in headers) {
+      var v = headers[name];
+      h3Headers[name.toLowerCase()] = Array.isArray(v) ? v.map(String) : String(v);
+    }
     if (!h3Headers['user-agent']) h3Headers['user-agent'] = 'quico/1.0';
     if (!h3Headers['accept']) h3Headers['accept'] = '*/*';
     if (!h3Headers['accept-encoding']) h3Headers['accept-encoding'] = 'identity';
+    if (contentLength != null && h3Headers['content-length'] === undefined) h3Headers['content-length'] = String(contentLength);
     return h3Headers;
   }
 
@@ -687,7 +704,9 @@ function request(options, callback) {
     // Early: kept, to go again if the server refuses it.
     if (earlyTried && !handshaken) earlyBody = { body: body.slice(), trailers: reqTrailers };
     if (body.length === 0 && !reqTrailers) { h3.sendHeaders(streamId, requestHeaders(), true); return; }
-    h3.sendHeaders(streamId, requestHeaders(), false);
+    var bodyLength = 0;
+    for (var bi = 0; bi < body.length; bi++) bodyLength += body[bi].byteLength;
+    h3.sendHeaders(streamId, requestHeaders(body.length ? bodyLength : null), false);
     for (var i = 0; i < body.length; i++) h3.sendBody(streamId, body[i], i === body.length - 1 && !reqTrailers);
     if (reqTrailers) h3.sendHeaders(streamId, reqTrailers, true);
   }