tunnelfetch 1.6.5 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tunnelfetch",
-  "version": "1.6.5",
+  "version": "1.7.0",
   "description": "A fetch-shaped HTTP client that can route through HTTP CONNECT / HTTPS / SOCKS5 proxies on runtimes with only raw TCP, such as Cloudflare Workers. Implements TLS in userland because the runtime cannot verify a tunnelled peer.",
   "keywords": [
     "fetch",

package/src/client/decode.js

@@ -190,17 +190,53 @@ function decompressionStage(source, coding, maxBytes = Infinity) {
   })();
   ready.catch(() => {});
 
+  // The fast path: hand the decompressor's output to the runtime and never touch a chunk in JS.
+  //
+  // Measured on the edge, CPU per MB of decompressed output, all shapes interleaved in one isolate:
+  //
+  //     this wrapper, BYOB reads + counting        7.00
+  //     the same wrapper with counting removed     7.33   (counting is free; the WRAPPER is not)
+  //     a standard `new TransformStream()` hop    13.33   (JS-backed: every 4 KiB chunk queues)
+  //     an IdentityTransformStream hop             3.67   (native, and BYOB on its readable)
+  //     DecompressionStream + native collect       3.33   (the floor)
+  //
+  // So a native identity hop is 48% cheaper than this wrapper and lands within noise of the floor,
+  // while the standard TransformStream — the obvious way to write the same thing — is nearly twice
+  // as expensive as doing nothing at all. The difference is that one is C++ and one is JavaScript;
+  // nothing about the API surface says so.
+  //
+  // It applies only when there is no cap, and that is not a limitation to be worked around: the cap
+  // is enforced by counting bytes, counting requires seeing them in JS, and seeing them in JS is
+  // exactly the cost being removed. The two are mutually exclusive. `maxBodyBytes: Infinity` is
+  // already a caller saying they will bound the body themselves, so giving that caller the fast
+  // path is coherent — you gave up the guard, you get the speed — rather than a compromise.
+  if (maxBytes === Infinity && typeof globalThis.IdentityTransformStream === 'function') {
+    const relay = new globalThis.IdentityTransformStream();
+    (async () => {
+      const ds = await ready;
+      if (ds === null) {
+        await relay.writable.close().catch(() => {});
+        return;
+      }
+      // preventAbort: pipeTo's default is to abort the destination with the SOURCE's error, which
+      // would hand the consumer a bare zlib message from a stream it never asked about. Keeping
+      // the abort here is what lets the coding be named, the same as on the wrapper path.
+      await ds.readable.pipeTo(relay.writable, { preventAbort: true });
+      if (pumpDone) await pumpDone;
+      await relay.writable.close();
+    })().catch(async (e) => {
+      // The consumer sees the same typed error it would have seen through the wrapper; the relay is
+      // errored rather than closed so a truncated body can never read as a complete one.
+      await srcReader.cancel(wrapCoding(coding, e)).catch(() => {});
+      await relay.writable.abort(wrapCoding(coding, e)).catch(() => {});
+    });
+    return relay.readable;
+  }
+
   /** @type {ReadableStreamBYOBReader | ReadableStreamDefaultReader<Uint8Array> | null} */
   let out = null;
   let byob = false;
-  const wrap = (e) =>
-    e instanceof HttpError
-      ? e
-      : new HttpError(
-          codes.HTTP_CONTENT_ENCODING,
-          `decoding "${coding}" failed: ${e?.message ?? e}`,
-          { coding },
-        );
+  const wrap = (e) => wrapCoding(coding, e);
 
   return new ReadableStream({
     async pull(c) {
@@ -334,6 +370,14 @@ function capDecodedOutput(source, coding, maxBytes) {
   });
 }
 
+/** Name the coding in a decode failure, so a caller sees which one misbehaved rather than a bare
+ *  zlib message from somewhere downstream. */
+function wrapCoding(coding, e) {
+  return e instanceof HttpError
+    ? e
+    : new HttpError(codes.HTTP_CONTENT_ENCODING, `decoding "${coding}" failed: ${e?.message ?? e}`, { coding });
+}
+
 /** Byte at logical offset `i` across the buffered head chunks. */
 function firstBytes(chunks, i) {
   for (const c of chunks) {

package/src/util/bytes.js

@@ -398,11 +398,39 @@ export function equal(a, b) {
  */
 export function timingSafeEqual(a, b) {
   if (a.byteLength !== b.byteLength) return false;
+  // Prefer the runtime's own, which is compiled rather than interpreted and therefore actually has
+  // the property this function is named for. `crypto.subtle.timingSafeEqual` is a non-standard
+  // Cloudflare extension, so it is FEATURE-DETECTED rather than assumed — this package runs on
+  // Node, Deno and Bun as well, and inferring a capability from a runtime name is the mistake it
+  // refuses to make everywhere else. Detected once, at module load, because doing it per call would
+  // put a property lookup on a path whose whole point is uniform timing.
+  if (NATIVE_TIMING_SAFE_EQUAL) return NATIVE_TIMING_SAFE_EQUAL(a, b);
   let diff = 0;
   for (let i = 0; i < a.byteLength; i++) diff |= a[i] ^ b[i];
   return diff === 0;
 }
 
+/**
+ * The runtime's constant-time compare, bound once, or null where there is none.
+ *
+ * Bound with a probe rather than a typeof check: a property that exists but throws on real input
+ * would otherwise be discovered inside a TLS Finished verification, where the failure mode is a
+ * dead connection on a path that is supposed to be the careful one.
+ */
+const NATIVE_TIMING_SAFE_EQUAL = (() => {
+  const fn = globalThis.crypto?.subtle?.timingSafeEqual;
+  if (typeof fn !== 'function') return null;
+  try {
+    const one = Uint8Array.of(1, 2, 3);
+    const two = Uint8Array.of(1, 2, 4);
+    if (fn.call(globalThis.crypto.subtle, one, one) !== true) return null;
+    if (fn.call(globalThis.crypto.subtle, one, two) !== false) return null;
+  } catch {
+    return null;
+  }
+  return (a, b) => fn.call(globalThis.crypto.subtle, a, b);
+})();
+
 const HEX = '0123456789abcdef';
 /**
  * @param {Uint8Array} bytes