@blamejs/blamejs-shop 0.4.84 → 0.4.86

package/lib/vendor/blamejs/test/layer-0-primitives/mail-proxy-framing-bounds.test.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * SMTP client (b.mail.transports.smtp) + proxy CONNECT tunnel
+ * (b.network.proxy.agentFor) framing-buffer + wall-clock bounds.
+ *
+ * Both paths accumulate bytes off a peer socket until a delimiter
+ * (CRLF / CRLFCRLF). Without a cap, a peer that streams bytes and never
+ * sends the delimiter grows the accumulator without limit (OOM). Without
+ * an absolute deadline, a slow-trickle peer resets the per-socket idle
+ * timer forever and the operation hangs.
+ *
+ * These drive the real shipped consumer surface:
+ *   - b.mail.transports.smtp(...).send(msg)  against a hostile net.Server
+ *   - b.network.proxy.agentFor(url).createConnection(...) against a
+ *     hostile CONNECT proxy
+ *
+ * RED (pre-fix): unbounded `buffer += data` / `Buffer.concat` → the send
+ * never settles (the server streams forever); the test times out / OOMs.
+ * GREEN (post-fix): the send rejects promptly with a bounded-error code.
+ */
+
+var net = require("node:net");
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function listen(server) {
+  return new Promise(function (resolve, reject) {
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", function () {
+      resolve(server.address().port);
+    });
+  });
+}
+
+function closeServer(server) {
+  return new Promise(function (resolve) {
+    try { server.close(function () { resolve(); }); }
+    catch (_e) { resolve(); }
+  });
+}
+
+// ---- (1) SMTP: framing buffer is bounded against a never-CRLF peer ----
+
+async function testSmtpResponseTooLargeBounded() {
+  var streamTimer = null;
+  // A server that completes the TCP handshake, sends a 220 greeting (so
+  // the client moves past connect), then on the first client command
+  // streams non-CRLF bytes forever.
+  var server = net.createServer(function (sock) {
+    // Client destroys mid-blast at the cap; swallow the resulting ECONNRESET.
+    sock.on("error", function () { if (streamTimer) { clearInterval(streamTimer); streamTimer = null; } });
+    sock.write("220 evil.example ESMTP\r\n");
+    sock.on("data", function () {
+      // Client just sent EHLO; respond with an unbounded non-CRLF blast.
+      var blast = Buffer.alloc(16 * 1024, 0x41); // 16 KiB of 'A', no CRLF
+      streamTimer = setInterval(function () {
+        if (!sock.writable) { clearInterval(streamTimer); return; }
+        try { sock.write(blast); } catch (_e) { clearInterval(streamTimer); }
+      }, 1);
+    });
+  });
+  var port = await listen(server);
+
+  var transport = b.mail.transports.smtp({
+    host:    "127.0.0.1",
+    port:    port,
+    timeoutMs: 60000,          // idle timer kept high so it can't mask the cap
+  });
+
+  var err = null;
+  try {
+    await transport.send({
+      from: "ops@example.com",
+      to:   ["alice@dest.example"],
+      subject: "hi",
+      text: "body",
+    });
+  } catch (e) { err = e; }
+
+  if (streamTimer) clearInterval(streamTimer);
+  await closeServer(server);
+
+  check("smtp: never-CRLF peer rejects (does not hang/OOM)", err !== null);
+  check("smtp: rejects with response-too-large",
+    err && typeof err.message === "string" &&
+    err.message.indexOf("response-too-large") !== -1);
+  check("smtp: error is a MailError", err && err.isMailError === true);
+}
+
+// ---- (2) SMTP: absolute transaction deadline fires on a trickle peer ----
+
+async function testSmtpTransactionDeadlineBounded() {
+  var trickleTimer = null;
+  // A server that greets, then for each command emits a SINGLE
+  // continuation byte-pair periodically — never a final response. With a
+  // generous idle timeout but a tiny maxTransactionMs the send must still
+  // fail on the wall-clock deadline.
+  var server = net.createServer(function (sock) {
+    // Client destroys at the transaction deadline; swallow the ECONNRESET.
+    sock.on("error", function () { if (trickleTimer) { clearInterval(trickleTimer); trickleTimer = null; } });
+    sock.write("220 slow.example ESMTP\r\n");
+    sock.on("data", function () {
+      // Keep the socket "alive" with periodic continuation lines so the
+      // idle timer never trips, but never complete the EHLO response.
+      if (trickleTimer) return;
+      trickleTimer = setInterval(function () {
+        if (!sock.writable) { clearInterval(trickleTimer); return; }
+        try { sock.write("250-keepalive\r\n"); } catch (_e) { clearInterval(trickleTimer); }
+      }, 20);
+    });
+  });
+  var port = await listen(server);
+
+  var transport = b.mail.transports.smtp({
+    host:             "127.0.0.1",
+    port:             port,
+    timeoutMs:        60000,    // idle timer never trips (trickle keeps it warm)
+    maxTransactionMs: 300,      // absolute deadline — must fire
+  });
+
+  var started = Date.now();
+  var err = null;
+  try {
+    await transport.send({
+      from: "ops@example.com",
+      to:   ["alice@dest.example"],
+      subject: "hi",
+      text: "body",
+    });
+  } catch (e) { err = e; }
+  var elapsed = Date.now() - started;
+
+  if (trickleTimer) clearInterval(trickleTimer);
+  await closeServer(server);
+
+  check("smtp: trickle peer rejects (does not hang)", err !== null);
+  check("smtp: rejects with transaction-timeout",
+    err && typeof err.message === "string" &&
+    err.message.indexOf("transaction-timeout") !== -1);
+  check("smtp: deadline fired near maxTransactionMs (well under idle)", elapsed < 5000);
+}
+
+// ---- (3) maxTransactionMs is validated at config time ----
+
+function testMaxTransactionMsValidated() {
+  var threw = null;
+  try {
+    b.mail.transports.smtp({ host: "127.0.0.1", maxTransactionMs: -5 });
+  } catch (e) { threw = e; }
+  check("smtp: negative maxTransactionMs throws MailError",
+    threw && threw.isMailError === true && threw.code === "mail/smtp-misconfigured");
+}
+
+// ---- (4) Proxy CONNECT: framing buffer bounded against a never-CRLFCRLF proxy ----
+
+async function testProxyConnectHeadersTooLargeBounded() {
+  var streamTimer = null;
+  // A fake proxy that accepts the CONNECT, then streams bytes that never
+  // contain the CRLFCRLF header terminator.
+  var server = net.createServer(function (sock) {
+    // Client tears down once the cap trips; swallow the resulting ECONNRESET.
+    sock.on("error", function () { if (streamTimer) { clearInterval(streamTimer); streamTimer = null; } });
+    sock.on("data", function () {
+      if (streamTimer) return;
+      var blast = Buffer.alloc(16 * 1024, 0x42); // 16 KiB of 'B', no CRLFCRLF
+      streamTimer = setInterval(function () {
+        if (!sock.writable) { clearInterval(streamTimer); return; }
+        try { sock.write(blast); } catch (_e) { clearInterval(streamTimer); }
+      }, 1);
+    });
+  });
+  var port = await listen(server);
+
+  b.network.proxy.set({ http: "http://127.0.0.1:" + port });
+  var agent = b.network.proxy.agentFor("http://target.example/");
+
+  var err = null;
+  await new Promise(function (resolve) {
+    agent.createConnection({ host: "target.example", port: 80 }, function (e, sock) {
+      err = e;
+      if (sock) { try { sock.destroy(); } catch (_e) { /* ignore */ } }
+      resolve();
+    });
+  });
+
+  if (streamTimer) clearInterval(streamTimer);
+  b.network.proxy._resetForTest();
+  await closeServer(server);
+
+  check("proxy: never-CRLFCRLF reply rejects (does not hang/OOM)", err !== null);
+  check("proxy: rejects with connect-headers-too-large",
+    err && err.code === "proxy/connect-headers-too-large");
+}
+
+// ---- (5) Proxy CONNECT: ABSOLUTE wall-clock deadline (Codex P2, #362) ----
+// A proxy that trickles a byte just inside every idle window but never sends
+// CRLFCRLF would reset an idle socket.setTimeout forever and never trip the
+// 64 KiB cap. The connect must still fail via an ABSOLUTE deadline. RED when
+// the bound is socket.setTimeout (idle): the connect hangs past the deadline.
+async function testProxyConnectAbsoluteDeadlineBounded() {
+  var trickle = null;
+  var server = net.createServer(function (sock) {
+    // The client tears the socket down at the deadline; writing to it after
+    // emits ECONNRESET on the server side — expected, swallow it so the test
+    // process doesn't crash on an unhandled 'error'.
+    sock.on("error", function () { if (trickle) { clearInterval(trickle); trickle = null; } });
+    sock.on("data", function () {
+      if (trickle) return;
+      // One byte every 50ms — keeps an idle timer warm, stays far under the
+      // 64 KiB header cap, never sends the CRLFCRLF terminator.
+      trickle = setInterval(function () {
+        if (!sock.writable) { clearInterval(trickle); return; }
+        try { sock.write("x"); } catch (_e) { clearInterval(trickle); }
+      }, 50);
+    });
+  });
+  var port = await listen(server);
+
+  b.network.proxy._setConnectTimeoutForTest(300);   // small absolute deadline
+  b.network.proxy.set({ http: "http://127.0.0.1:" + port });
+  var agent = b.network.proxy.agentFor("http://target.example/");
+
+  var started = Date.now();
+  var err = null;
+  await new Promise(function (resolve) {
+    agent.createConnection({ host: "target.example", port: 80 }, function (e, sock) {
+      err = e;
+      if (sock) { try { sock.destroy(); } catch (_e) { /* ignore */ } }
+      resolve();
+    });
+  });
+  var elapsed = Date.now() - started;
+
+  if (trickle) clearInterval(trickle);
+  b.network.proxy._resetForTest();
+  await closeServer(server);
+
+  check("proxy: trickling CONNECT reply still fails (absolute deadline)", err !== null);
+  check("proxy: rejects with connect-timeout", err && err.code === "proxy/connect-timeout");
+  check("proxy: bounded by the absolute deadline (~timeout, not held open by trickle)",
+    elapsed < 3000);
+}
+
+// ---- Run ----
+
+async function run() {
+  await testSmtpResponseTooLargeBounded();
+  await testSmtpTransactionDeadlineBounded();
+  testMaxTransactionMsValidated();
+  await testProxyConnectHeadersTooLargeBounded();
+  await testProxyConnectAbsoluteDeadlineBounded();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[mail-proxy-framing-bounds] OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", (e && e.stack) || e); process.exit(1); }
+  );
+}

package/lib/vendor/blamejs/test/layer-0-primitives/network-dns-lookup-timeout-default.test.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * network-dns: every lookup has an effective wall-clock deadline out of
+ * the box, and a stalled upstream tears the socket down.
+ *
+ * Regression guard for the CWE-400 class: `lookupTimeoutMs` defaulted to
+ * 0 (no deadline) and `_withTimeout` was a no-op at 0, so a
+ * header-then-stall / accept-then-never-reply upstream hung the request
+ * forever. The raw transport sockets also had no req.setTimeout /
+ * socket.setTimeout, so even a rejected promise leaked the fd.
+ *
+ * Drives the real `b.network.dns.resolve(host, "SVCB", {transport:
+ * "system"})` consumer path against a TCP black-hole responder — the
+ * same raw-query code path (`_systemRawQuery`) an operator runs — and
+ * confirms a stalled upstream is torn down within the deadline rather
+ * than hanging forever.
+ */
+
+var net = require("node:net");
+
+var helpers = require("../helpers");
+var check = helpers.check;
+var b = helpers.b;
+
+var C = require("../../lib/constants");
+
+var dnsModule = b.network.dns;
+
+// A TCP server that accepts the connection but never sends a reply (and
+// never closes) — models a stalled upstream resolver. Returns the live
+// sockets it accepted so the test can assert teardown.
+function _startBlackHoleResponder() {
+  return new Promise(function (resolve) {
+    var accepted = [];
+    var srv = net.createServer(function (sock) {
+      accepted.push(sock);
+      // Swallow the query; deliberately never reply, never end.
+      sock.on("data", function () { /* black hole */ });
+      sock.on("error", function () { /* fixture best-effort */ });
+    });
+    srv.unref();
+    srv.listen(0, "127.0.0.1", function () {
+      resolve({ srv: srv, port: srv.address().port, accepted: accepted });
+    });
+  });
+}
+
+async function _throwsAsync(fn, expectedCodeSubstr) {
+  try { await fn(); return false; }
+  catch (e) {
+    if (!expectedCodeSubstr) return true;
+    var hay = (e.code || "") + " " + (e.message || "");
+    return hay.indexOf(expectedCodeSubstr) !== -1;
+  }
+}
+
+async function run() {
+  dnsModule._resetForTest();
+
+  // ----------------------------------------------------------------
+  // The default deadline is applied (not 0 = no-timeout).
+  // ----------------------------------------------------------------
+  check("default lookupTimeoutMs is a non-zero wall-clock deadline (10s)",
+    dnsModule._stateForTest().lookupTimeoutMs === C.TIME.seconds(10));
+
+  // ----------------------------------------------------------------
+  // A stalled upstream tears the socket down within the deadline AND
+  // rejects the consumer call — without any operator setLookupTimeoutMs.
+  // We shorten the deadline to keep the test fast; the *mechanism* under
+  // test (setTimeout teardown + non-zero default _withTimeout) is the
+  // same one the 10s default arms. On the buggy tree this hangs forever.
+  // ----------------------------------------------------------------
+  var hole = await _startBlackHoleResponder();
+  dnsModule.useSystemResolver();
+  dnsModule.setServers(["127.0.0.1:" + hole.port]);
+  dnsModule.setLookupTimeoutMs(500);
+
+  var rejected = await _throwsAsync(function () {
+    return dnsModule.resolve("stall.example.com", "SVCB", { transport: "system" });
+  }, "dns/lookup-timeout");
+  check("resolve(...,'SVCB',system) against a black-hole upstream rejects with dns/lookup-timeout (does not hang)",
+    rejected);
+
+  // The accepted socket(s) must be destroyed — the deadline teardown,
+  // not just a promise-level reject leaving the fd alive.
+  await helpers.waitUntil(function () {
+    return hole.accepted.length > 0 &&
+      hole.accepted.every(function (s) { return s.destroyed; });
+  }, {
+    timeoutMs: 5000,
+    label:     "network-dns timeout: stalled upstream socket torn down",
+  });
+  check("stalled upstream socket is torn down (fd not leaked)",
+    hole.accepted.length > 0 && hole.accepted.every(function (s) { return s.destroyed; }));
+
+  hole.srv.close();
+  dnsModule._resetForTest();
+
+  // ----------------------------------------------------------------
+  // Operator opt-out (0) still disables the deadline — the override path
+  // survives the default change.
+  // ----------------------------------------------------------------
+  dnsModule.setLookupTimeoutMs(0);
+  check("operator can disable the deadline (lookupTimeoutMs = 0)",
+    dnsModule._stateForTest().lookupTimeoutMs === 0);
+  dnsModule._resetForTest();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[network-dns-lookup-timeout-default] OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error(e && e.stack || e); process.exit(1); }
+  );
+}

package/lib/vendor/blamejs/test/layer-0-primitives/network-dns-resolver-timeout.test.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * b.network.dns.resolver — per-query upstream timeout.
+ *
+ * A non-responsive / slow / stalling DoH endpoint (or a transport whose
+ * lookup never resolves — the wire-level analogue of a server that sends
+ * 200 headers then never ends the body) must not hold the await pending
+ * forever. Every query() and every followCnames hop is bounded by the
+ * create({ timeoutMs }) wall-clock deadline. RED on the pre-fix tree:
+ * queryA() never settles and the test hangs until the harness kills it.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+// A transport whose lookup never resolves — models a DoH endpoint that
+// accepts the connection, sends headers, then stalls the body forever.
+function _hangingTransport() {
+  return {
+    lookupCalls: 0,
+    lookup: function () {
+      this.lookupCalls += 1;
+      return new Promise(function () { /* never settles */ });
+    },
+  };
+}
+
+// Bound a promise so a regressed (hanging) tree fails as a timeout instead of
+// stalling the whole suite. Polls via helpers.waitUntil (not a fixed
+// setTimeout sleep) for the promise to settle, then rethrows its rejection —
+// a genuine hang surfaces as a waitUntil timeout rather than hanging forever.
+function _within(promise, ms, label) {
+  var state = { done: false, value: undefined, error: undefined };
+  promise.then(
+    function (v) { state.done = true; state.value = v; },
+    function (e) { state.done = true; state.error = e; }
+  );
+  return helpers.waitUntil(function () { return state.done; }, { timeoutMs: ms, label: label })
+    .then(function () { if (state.error) throw state.error; return state.value; });
+}
+
+async function testQueryTimesOutOnHangingTransport() {
+  var transport = _hangingTransport();
+  var r = b.network.dns.resolver.create({ transport: transport, timeoutMs: 80 });
+
+  var threw = null;
+  try {
+    await _within(r.queryA("example.com"), 4000,
+      "queryA against a hanging transport");
+  } catch (e) {
+    threw = e;
+  }
+  check("queryA rejects on a hanging transport (does not hang)", threw !== null);
+  var msg = threw ? String(threw.message) : "";
+  check("rejection is the resolver deadline, not the test backstop",
+    /timed out/i.test(msg) && !/TEST-DEADLINE/.test(msg));
+  check("transport.lookup was actually invoked", transport.lookupCalls === 1);
+}
+
+async function testFollowCnamesHopTimesOut() {
+  // followCnames loops query() per hop; the first hop's transport stall
+  // must bound the whole walk, not hang it.
+  var transport = _hangingTransport();
+  var r = b.network.dns.resolver.create({ transport: transport, timeoutMs: 80 });
+
+  var threw = null;
+  try {
+    await _within(r.followCnames("alias.example.com", "A"), 4000,
+      "followCnames against a hanging transport");
+  } catch (e) {
+    threw = e;
+  }
+  check("followCnames rejects when a hop's transport stalls", threw !== null);
+  var msg2 = threw ? String(threw.message) : "";
+  check("followCnames rejection is the resolver deadline",
+    /timed out/i.test(msg2) && !/TEST-DEADLINE/.test(msg2));
+}
+
+async function testBadTimeoutRejectedAtCreate() {
+  var cases = [0, -1, NaN, Infinity];
+  for (var i = 0; i < cases.length; i += 1) {
+    var threw = null;
+    try {
+      b.network.dns.resolver.create({ timeoutMs: cases[i] });
+    } catch (e) {
+      threw = e;
+    }
+    check("create rejects timeoutMs=" + cases[i],
+      threw !== null && threw.code === "resolver/bad-input");
+  }
+}
+
+async function testDefaultTimeoutAccepted() {
+  // No timeoutMs supplied — create() must still build (uses the default)
+  // and a fast fake transport resolves normally.
+  var r = b.network.dns.resolver.create({
+    transport: { lookup: function () { return Promise.reject(new Error("boom")); } },
+  });
+  var threw = null;
+  try {
+    await r.queryA("example.com");
+  } catch (e) {
+    threw = e;
+  }
+  // A transport error (not a timeout) surfaces as upstream-failed — proves
+  // the default-timeout path doesn't swallow real fast failures.
+  check("default timeout path surfaces fast transport errors",
+    threw !== null && threw.code === "resolver/upstream-failed");
+}
+
+async function run() {
+  await testQueryTimesOutOnHangingTransport();
+  await testFollowCnamesHopTimesOut();
+  await testBadTimeoutRejectedAtCreate();
+  await testDefaultTimeoutAccepted();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) run().then(function () {
+  process.stdout.write("PASS: network-dns-resolver-timeout\n");
+}).catch(function (e) {
+  process.stderr.write("FAIL: " + (e && e.stack || e) + "\n");
+  process.exit(1);
+});

package/lib/vendor/blamejs/test/layer-0-primitives/network-nts-handshake-byte-cap.test.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * b.* NTS-KE handshake byte-cap.
+ *
+ * The NTS-KE (RFC 8915) key-establishment handshake reader accumulates
+ * received bytes until a REC_END record terminates the exchange. A
+ * wall-clock timer bounds the handshake by time, but NOT by memory: a
+ * server that streams non-END records fast enough OOMs the process
+ * before the timer fires. The reader must cap the accumulated buffer at
+ * a sane ceiling (64 KiB) and fail closed with an nts/* typed error.
+ *
+ * This drives the real consumer path — network-nts.performKeHandshake
+ * against a live loopback TLS server negotiating ALPN "ntske/1" that
+ * streams > 64 KiB of non-END records.
+ */
+
+var helpers = require("../helpers");
+var check   = helpers.check;
+var nts     = require("../../lib/network-nts");
+var nodeTls = require("node:tls");
+
+var REC_NEW_COOKIE = 5;
+
+// Encode an NTS-KE record: u16 type (top bit = critical) || u16 length
+// || body. We emit non-critical NEW_COOKIE records that never include a
+// REC_END (type 0), so a conformant reader keeps accumulating.
+function _encodeRecord(type, body) {
+  var hdr = Buffer.alloc(4);
+  hdr.writeUInt16BE(type & 0x7fff, 0);
+  hdr.writeUInt16BE(body.length, 2);
+  return Buffer.concat([hdr, body]);
+}
+
+function testHandshakeByteCapFailsClosed() {
+  return new Promise(function (resolve, reject) {
+    (async function () {
+      var server = null;
+      try {
+        var ca = await helpers.b.mtlsEngine.generateCa({ name: "nts-test-ca" });
+        var leaf = await helpers.b.mtlsEngine.signClientCert({
+          cn:           "localhost",
+          caCertPem:    ca.caCertPem,
+          caKeyPem:     ca.caKeyPem,
+          usage:        "server",
+          sans:         ["DNS:localhost", "IP:127.0.0.1"],
+          validityDays: 1,
+        });
+
+        // One ~1 KiB non-END record; streamed enough times to exceed the
+        // 64 KiB ceiling without ever sending REC_END.
+        var oneRecord = _encodeRecord(REC_NEW_COOKIE, Buffer.alloc(1020, 0x41));
+        var TOTAL_BYTES = 128 * 1024; // 2x the 64 KiB cap
+
+        server = nodeTls.createServer({
+          key:           leaf.key,
+          cert:          leaf.cert,
+          minVersion:    "TLSv1.3",
+          maxVersion:    "TLSv1.3",
+          ALPNProtocols: ["ntske/1"],
+        }, function (sock) {
+          sock.on("error", function () { /* client tears down mid-stream */ });
+          var sent = 0;
+          function pump() {
+            while (sent < TOTAL_BYTES) {
+              sent += oneRecord.length;
+              if (!sock.write(oneRecord)) {
+                sock.once("drain", pump);
+                return;
+              }
+            }
+          }
+          pump();
+        });
+
+        server.listen(0, "127.0.0.1", function () {
+          var port = server.address().port;
+          var startedAt = Date.now();
+          nts.performKeHandshake({
+            host:       "127.0.0.1",
+            port:       port,
+            servername: "localhost",
+            ca:         ca.caCertPem,
+            // Generous timeout: a passing run must reject on the byte cap
+            // FAST (well under this), proving the cap — not the timer —
+            // bounded the read.
+            timeoutMs:  30000,
+          }).then(function () {
+            server.close();
+            reject(new Error("handshake resolved despite > 64 KiB of non-END records"));
+          }).catch(function (e) {
+            var elapsed = Date.now() - startedAt;
+            try { server.close(); } catch (_e) { /* best-effort */ }
+            try {
+              check("handshake rejects on oversized stream",
+                    e && e.code === "nts/ke-too-large");
+              check("rejection is NtsError typed",
+                    e instanceof nts.NtsError);
+              check("rejection is bounded, not the wall-clock timeout",
+                    e.code !== "nts/ke-timeout");
+              check("bounded fast (well under the 30s timer)",
+                    elapsed < 15000);
+              resolve();
+            } catch (assertErr) {
+              reject(assertErr);
+            }
+          });
+        });
+
+        server.on("error", function (e) { reject(e); });
+      } catch (e) {
+        if (server) { try { server.close(); } catch (_e) { /* best-effort */ } }
+        reject(e);
+      }
+    })();
+  });
+}
+
+async function run() {
+  await testHandshakeByteCapFailsClosed();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e.stack || e); process.exit(1); });
+}