@blamejs/blamejs-shop 0.4.101 → 0.4.102

package/lib/vendor/blamejs/test/layer-0-primitives/http-client-cache.test.js

@@ -676,24 +676,47 @@ async function test304MergesHeaders() {
 // ---- Run ----------------------------------------------------------------
 
 async function run() {
-  testSurface();
-  testCreateBadOpts();
-  await testMissThenHit();
-  await testNoStoreSkips();
-  await testNoCacheRevalidatesEveryRead();
-  await testPrivateRefusedInSharedCache();
-  await testVarySplitsEntries();
-  await testRevalidate304();
-  await testStaleWhileRevalidate();
-  await testStaleIfError();
-  await testEvictionAtMaxBytes();
-  await testEvictionAtMaxEntries();
-  await testHeuristicFreshnessFromLastModified();
-  await testPragmaNoCache();
-  await testPostBypassesCache();
-  await testInvalidateInspectClear();
-  await testAuditAndObservabilityWired();
-  await test304MergesHeaders();
+  try {
+    testSurface();
+    testCreateBadOpts();
+    await testMissThenHit();
+    await testNoStoreSkips();
+    await testNoCacheRevalidatesEveryRead();
+    await testPrivateRefusedInSharedCache();
+    await testVarySplitsEntries();
+    await testRevalidate304();
+    await testStaleWhileRevalidate();
+    await testStaleIfError();
+    await testEvictionAtMaxBytes();
+    await testEvictionAtMaxEntries();
+    await testHeuristicFreshnessFromLastModified();
+    await testPragmaNoCache();
+    await testPostBypassesCache();
+    await testInvalidateInspectClear();
+    await testAuditAndObservabilityWired();
+    await test304MergesHeaders();
+  } finally {
+    // Tear down the httpClient's keep-alive transport pool so the
+    // client-side sockets it cached don't outlive run() and keep the
+    // forked worker's event loop open (delays exit on a slow runner).
+    // agent.destroy() schedules the socket teardown asynchronously, so
+    // poll until the TCP handles have actually drained before returning.
+    await _drainTcpHandles();
+  }
+}
+
+// Destroy the httpClient transport pool and wait for every TCP handle
+// (client sockets + any server-side sockets they kept open) to close.
+// Polling drives real event-loop turns so the close completes inside
+// run(), not in the worker's post-run grace window.
+async function _drainTcpHandles() {
+  b.httpClient._resetForTest();
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "http-client-cache: TCP handle drain after _resetForTest" });
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/http-client-stream.test.js

@@ -465,21 +465,40 @@ async function testThrottleTransformValidation() {
     { url: "https://x.example/", uploadTransform: { not: "a stream" } });
 }
 
+// Destroy the httpClient transport pool and wait for every TCP handle
+// (client sockets the keep-alive agent cached, plus any server-side
+// sockets they kept open) to close. Polling drives real event-loop
+// turns so the asynchronous socket teardown completes inside run(),
+// not in the forked worker's post-run grace window.
+async function _drainTcpHandles() {
+  b.httpClient._resetForTest();
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "http-client-stream: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  testSurface();
-  await testBandwidthThrottle();
-  await testDownloadTransformInterpose();
-  await testThrottleTransformValidation();
-  await testDownloadHappyPath();
-  await testDownloadExpectedHashMatch();
-  await testDownloadHashMismatch();
-  await testDownloadHttpError();
-  await testStreamErrorBodyPreserved();
-  await testDownloadTempCreateIsExclusiveNoFollow();
-  await testDownloadBadOpts();
-  await testUploadHappyPath();
-  await testUploadMissingFile();
-  await testUploadBadOpts();
+  try {
+    testSurface();
+    await testBandwidthThrottle();
+    await testDownloadTransformInterpose();
+    await testThrottleTransformValidation();
+    await testDownloadHappyPath();
+    await testDownloadExpectedHashMatch();
+    await testDownloadHashMismatch();
+    await testDownloadHttpError();
+    await testStreamErrorBodyPreserved();
+    await testDownloadTempCreateIsExclusiveNoFollow();
+    await testDownloadBadOpts();
+    await testUploadHappyPath();
+    await testUploadMissingFile();
+    await testUploadBadOpts();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/http-client-throttle-transform.test.js

@@ -75,9 +75,28 @@ async function testUploadTransformSizeChangeNotTruncated() {
   });
 }
 
+// Destroy the httpClient transport pool and wait for every TCP handle
+// (the keep-alive agent's client sockets + any server-side sockets they
+// kept open) to close. Polling drives real event-loop turns so the
+// asynchronous teardown completes inside run(), not in the forked
+// worker's post-run grace window.
+async function _drainTcpHandles() {
+  b.httpClient._resetForTest();
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "http-client-throttle-transform: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  await testDownloadTransformAppliesInBufferMode();
-  await testUploadTransformSizeChangeNotTruncated();
+  try {
+    await testDownloadTransformAppliesInBufferMode();
+    await testUploadTransformSizeChangeNotTruncated();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/incident-report.test.js

@@ -3,7 +3,7 @@ var helpers = require("../helpers");
 var b = helpers.b;
 var check = helpers.check;
 
-(async function run() {
+async function run() {
   var ir = b.incident.report.create({ audit: false });
   var rec = await ir.open({ regime: "gdpr", detectedAt: Date.now() });
   check("incident.open returns id", typeof rec.id === "string");
@@ -91,4 +91,7 @@ var check = helpers.check;
   clk2.stop();
 
   console.log("OK — incident.report tests");
-})().catch(function (e) { console.error(e); process.exit(1); });
+}
+
+module.exports = { run: run };
+if (require.main === module) run().catch(function (e) { console.error(e); process.exit(1); });

package/lib/vendor/blamejs/test/layer-0-primitives/log-stream-otlp.test.js

@@ -9,6 +9,20 @@ var otlp = require("../../lib/log-stream-otlp");
 function _mockCollector(opts) {
   opts = opts || {};
   var received = [];
+  // Timers a responder schedules to delay/hang a response. Tracked so close()
+  // clears any still-pending one — an uncleared responder timer (e.g. the
+  // 5000ms hang in the overflow test) outlives the server and lingers as a
+  // referenced Timeout handle past run().
+  var pendingTimers = [];
+  function deferResponse(fn, ms) {
+    var t = setTimeout(function () {
+      var idx = pendingTimers.indexOf(t);
+      if (idx !== -1) pendingTimers.splice(idx, 1);
+      fn();
+    }, ms);
+    pendingTimers.push(t);
+    return t;
+  }
   var responder = opts.responder || function (_req, res) {
     res.statusCode = 200;
     res.setHeader("content-type", "application/json");
@@ -30,7 +44,7 @@ function _mockCollector(opts) {
       } catch (e) {
         received.push({ url: req.url, error: e.message });
       }
-      responder(req, res);
+      responder(req, res, deferResponse);
     });
   });
   return new Promise(function (resolve) {
@@ -39,7 +53,10 @@ function _mockCollector(opts) {
       resolve({
         url:      "http://127.0.0.1:" + port,
         received: received,
-        close:    function () { return new Promise(function (r) { server.close(r); }); },
+        close:    function () {
+          while (pendingTimers.length > 0) clearTimeout(pendingTimers.pop());
+          return new Promise(function (r) { server.close(r); });
+        },
       });
     });
   });
@@ -202,11 +219,11 @@ async function run() {
 
   // ---- Buffer overflow drops oldest + emits onDrop ----
   var col4 = await _mockCollector({
-    responder: function (_req, res) {
+    responder: function (_req, res, deferResponse) {
       // Hang the response so the in-flight batch never completes;
-      // subsequent emits queue up, eventually overflowing.
-      // (Test calls close() to release.)
-      setTimeout(function () { res.statusCode = 200; res.end("{}"); }, 5000);
+      // subsequent emits queue up, eventually overflowing. The collector
+      // tracks this timer and clears it on close() so it doesn't linger.
+      deferResponse(function () { res.statusCode = 200; res.end("{}"); }, 5000);
     },
   });
   try {
@@ -229,8 +246,12 @@ async function run() {
     }, { timeoutMs: 5000, label: "log-stream-otlp: overflow drops fired" });
     var overflowDrops = dropEvents4.filter(function (d) { return d.reason === "overflow"; });
     check("overflow drops fired (oldest evicted)", overflowDrops.length > 0);
-    // Don't await close — the hanging response keeps it alive
-    sink4.close().catch(function () {});
+    // Close the collector first — that clears the deferred-response timer and
+    // tears down the server, so the sink's in-flight POST stops hanging and its
+    // retry/backoff settles. Then await the sink's close so no retry-backoff
+    // timer lingers past run().
+    await col4.close();
+    await sink4.close().catch(function () {});
   } finally {
     await col4.close();
   }

package/lib/vendor/blamejs/test/layer-0-primitives/mail-server-imap.test.js

@@ -696,30 +696,49 @@ async function testSelectQresyncImplicitlyEngagesCondstore() {
   } finally { await srv.close({ timeoutMs: 1000 }); }                                                   // allow:raw-time-literal — test-only short drain
 }
 
+// Each test connects a raw client socket to a live IMAP TLS server and
+// destroys both at the end; socket.destroy() and the server-side teardown
+// finalize their handles asynchronously — past the forked worker's post-run
+// grace window. Poll until every TCP handle has actually closed so the last
+// test's client/server don't outlive run() and hold the event loop open on
+// a slow runner.
+async function _drainTcpHandles() {
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "mail-server-imap: TCP handle drain after run" });
+}
+
 async function run() {
-  testSurface();
-  testRequiresTlsContext();
-  testRequiresMailStore();
-  testBadBoundsRefused();
-  await testCapabilityAdvertisesCondstore();
-  await testEnableCondstore();
-  await testFetchChangedSinceParses();
-  await testStoreUnchangedSinceConflict();
-  await testFetchChangedSinceImpliesCondstore();
-  await testStoreSilentEmitsModseqUnderCondstore();
-  // v0.11.28 — NOTIFY / METADATA / CATENATE
-  await testCapabilityAdvertisesNewExtensions();
-  await testNotifyNoneAndSet();
-  await testNotifyBackendMissing();
-  await testGetSetMetadata();
-  await testMetadataBackendMissing();
-  await testCatenateBackendMissing();
-  await testCatenatePartOrderingAndValidation();
-  // v0.11.33 — QRESYNC (RFC 7162 §3.2)
-  await testCapabilityAdvertisesQresync();
-  await testEnableQresyncImpliesCondstore();
-  await testSelectQresyncEmitsVanishedEarlier();
-  await testSelectQresyncImplicitlyEngagesCondstore();
+  try {
+    testSurface();
+    testRequiresTlsContext();
+    testRequiresMailStore();
+    testBadBoundsRefused();
+    await testCapabilityAdvertisesCondstore();
+    await testEnableCondstore();
+    await testFetchChangedSinceParses();
+    await testStoreUnchangedSinceConflict();
+    await testFetchChangedSinceImpliesCondstore();
+    await testStoreSilentEmitsModseqUnderCondstore();
+    // v0.11.28 — NOTIFY / METADATA / CATENATE
+    await testCapabilityAdvertisesNewExtensions();
+    await testNotifyNoneAndSet();
+    await testNotifyBackendMissing();
+    await testGetSetMetadata();
+    await testMetadataBackendMissing();
+    await testCatenateBackendMissing();
+    await testCatenatePartOrderingAndValidation();
+    // v0.11.33 — QRESYNC (RFC 7162 §3.2)
+    await testCapabilityAdvertisesQresync();
+    await testEnableQresyncImpliesCondstore();
+    await testSelectQresyncEmitsVanishedEarlier();
+    await testSelectQresyncImplicitlyEngagesCondstore();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/network-byte-quota.test.js

@@ -118,7 +118,7 @@ async function testRefusalEmitsAudit() {
   check("refusal emits network.byte_quota.exceeded", hit);
 }
 
-(async function run() {
+async function run() {
   await testCheckBelowQuotaPasses();
   await testCheckOverQuotaRefuses();
   await testCheckIsPureNonMutating();
@@ -130,4 +130,7 @@ async function testRefusalEmitsAudit() {
   await testCheckRejectsBadKey();
   await testRefusalEmitsAudit();
   console.log("OK — network-byte-quota tests");
-})().catch(function (e) { console.error(e); process.exit(1); });
+}
+
+module.exports = { run: run };
+if (require.main === module) run().catch(function (e) { console.error(e); process.exit(1); });

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

@@ -205,7 +205,27 @@ function _startTlsResponder(replyBytes, keyPem, certPem) {
   });
 }
 
+// The DNS primitive's system-resolver TCP query (and DoT pool sockets)
+// open client sockets; _resetForTest() destroys them, but socket.destroy()
+// finalizes the underlying handle asynchronously — past the forked worker's
+// post-run grace window. Reset, then poll until the TCP client handle has
+// actually closed so it doesn't outlive run() and hold the event loop open.
+async function _drainTcpHandles() {
+  _resetAll();
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "network-dns: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
+  try { await _runTests(); }
+  finally { await _drainTcpHandles(); }
+}
+
+async function _runTests() {
   _resetAll();
 
   // ============================================================

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

@@ -115,8 +115,27 @@ function testHandshakeByteCapFailsClosed() {
   });
 }
 
+// The handshake test destroys its NTS-KE client socket on the byte-cap
+// path and calls server.close(), but socket.destroy() / the server-side
+// accepted-socket teardown finalize their handles asynchronously — past
+// the forked worker's post-run grace window. Poll until every TCP handle
+// has actually closed so neither outlives run() and holds the event loop
+// open on a slow runner.
+async function _drainTcpHandles() {
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "network-nts-handshake-byte-cap: TCP handle drain after handshake" });
+}
+
 async function run() {
-  await testHandshakeByteCapFailsClosed();
+  try {
+    await testHandshakeByteCapFailsClosed();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/nis2-report.test.js

@@ -3,7 +3,7 @@ var helpers = require("../helpers");
 var b = helpers.b;
 var check = helpers.check;
 
-(async function run() {
+async function run() {
   var n = b.nis2.report.create({
     audit: false,
     entityId: "acme-1", entityType: "essential", sectorAnnex: "I.6",
@@ -18,4 +18,7 @@ var check = helpers.check;
   check("nis2 refuses bad entityType", threwBadType);
 
   console.log("OK — nis2.report tests");
-})().catch(function (e) { console.error(e); process.exit(1); });
+}
+
+module.exports = { run: run };
+if (require.main === module) run().catch(function (e) { console.error(e); process.exit(1); });

package/lib/vendor/blamejs/test/layer-0-primitives/oauth-callback.test.js

@@ -105,7 +105,7 @@ async function _pkceDowngradeCase(methods, expectRefusal, label) {
   } finally { server.close(); }
 }
 
-async function run() {
+async function _runTests() {
   var oauth = b.auth.oauth.create({
     issuer:        "https://idp.example",
     clientId:      "rp-1",
@@ -460,6 +460,27 @@ async function run() {
   await _testBackchannelLogoutOversized();
 }
 
+// b.auth.oauth discovery / PAR fetches go through the shared b.httpClient
+// keep-alive agent, whose cached client sockets (and the mock servers they
+// keep open) would otherwise outlive run() and hold the forked worker's
+// event loop open. Tear the pool down and poll until the TCP handles have
+// actually closed — agent.destroy() schedules the teardown asynchronously,
+// so polling drives the event-loop turns needed to complete it inside run().
+async function _drainTcpHandles() {
+  b.httpClient._resetForTest();
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "oauth-callback: TCP handle drain after _resetForTest" });
+}
+
+async function run() {
+  try { await _runTests(); }
+  finally { await _drainTcpHandles(); }
+}
+
 // PAR carrying a signed request object: the form body MUST hold `request=`
 // + client auth ONLY, and the authorization parameters travel as request-
 // object claims, NOT as bare form params. The pushed JWT is verified

package/lib/vendor/blamejs/test/layer-0-primitives/observability-tracing.test.js

@@ -647,7 +647,7 @@ function testTracerToJSONIsImmutable() {
 
 // ---- Run all ----
 
-(async function run() {
+async function run() {
   testTracestateParse();
   testTracestateBuild();
   testBaggageParse();
@@ -677,4 +677,10 @@ function testTracerToJSONIsImmutable() {
   testTracerToJSONIsImmutable();
   testTraceLogCorrelationRejectsAuditOpt();
   testTracerRejectsAuditOpt();
-})().catch(function (e) { console.error(e); process.exit(1); });
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().catch(function (e) { console.error(e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/parser-verify-hardening.test.js

@@ -116,23 +116,28 @@ function testBodyParserRawWildcardMatchesRealType() {
   req.headers = { "content-type": "application/json", "content-length": "2" };
   req.socket = { remoteAddress: "127.0.0.1" };
   var res = _bodyRes();
-  return new Promise(function (resolve) {
-    var settled = false;
-    bp(req, res, function () {
-      if (settled) return; settled = true;
-      check("bodyParser.raw() */* accepts application/json → next() runs", true);
-      check("bodyParser.raw() exposes the raw body as a Buffer", Buffer.isBuffer(req.body));
-      resolve();
+  // The parser settles by calling next() or by ending the response. Wrap in
+  // withTestTimeout so a parser that hangs becomes a hard "test timed out"
+  // reject (1500ms budget) instead of stalling the suite — its guard timer
+  // clears on settle, so no Timeout handle lingers past run().
+  return helpers.withTestTimeout("parser-verify: bodyParser.raw() settles", function () {
+    return new Promise(function (resolve) {
+      var settled = false;
+      bp(req, res, function () {
+        if (settled) return; settled = true;
+        check("bodyParser.raw() */* accepts application/json → next() runs", true);
+        check("bodyParser.raw() exposes the raw body as a Buffer", Buffer.isBuffer(req.body));
+        resolve();
+      });
+      res.on("finish", function () {
+        if (settled) return; settled = true;
+        check("bodyParser.raw() */* did NOT 415 a real Content-Type (status=" + res._endedStatus + ")",
+          res._endedStatus !== 415);
+        resolve();
+      });
+      setImmediate(function () { req.emit("data", Buffer.from("{}")); req.emit("end"); });
     });
-    res.on("finish", function () {
-      if (settled) return; settled = true;
-      check("bodyParser.raw() */* did NOT 415 a real Content-Type (status=" + res._endedStatus + ")",
-        res._endedStatus !== 415);
-      resolve();
-    });
-    setImmediate(function () { req.emit("data", Buffer.from("{}")); req.emit("end"); });
-    setTimeout(function () { if (!settled) { settled = true; check("bodyParser.raw() settled", false); resolve(); } }, 1500);
-  });
+  }, { timeoutMs: 1500 });                                                        // allow:raw-byte-literal — parser-settle budget ms
 }
 
 async function testPromiseToStreamWrapsPromise() {

package/lib/vendor/blamejs/test/layer-0-primitives/parsers-standalone.test.js

@@ -281,7 +281,7 @@ async function testMultipartRepeatedFieldShapeUnchanged() {
   check("multipart: single field stays scalar", result.fields.title === "solo");
 }
 
-(async function run() {
+async function run() {
   await testJsonParsesValidObject();
   await testJsonRefusesOverMaxBytes();
   await testJsonRefusesPrototypePollution();
@@ -296,4 +296,7 @@ async function testMultipartRepeatedFieldShapeUnchanged() {
   await testMultipartRefusesPoisonedFieldName();
   await testMultipartRepeatedFieldShapeUnchanged();
   console.log("OK — parsers-standalone tests");
-})().catch(function (e) { console.error(e); process.exit(1); });
+}
+
+module.exports = { run: run };
+if (require.main === module) run().catch(function (e) { console.error(e); process.exit(1); });

package/lib/vendor/blamejs/test/layer-0-primitives/queue-sqs.test.js

@@ -324,18 +324,38 @@ async function testNumericConfigValidation() {
   shouldPass("accepts waitTimeSec=0 (short-poll sentinel)", { waitTimeSec: 0 });
 }
 
+// sqs.create issues its signed requests through the shared b.httpClient
+// keep-alive agent, whose cached client sockets (and the mock servers they
+// keep open) would otherwise outlive run() and hold the forked worker's
+// event loop open. Tear the pool down and poll until the TCP handles have
+// actually closed — agent.destroy() schedules the teardown asynchronously,
+// so polling drives the event-loop turns needed to complete it inside run().
+async function _drainTcpHandles() {
+  b.httpClient._resetForTest();
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "queue-sqs: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  await testFactoryValidation();
-  await testNumericConfigValidation();
-  await testEnqueueWireShape();
-  await testDelaySecondsClampedAt900();
-  await testLeaseRoundTrip();
-  await testCompleteDeletes();
-  await testExtendLease();
-  await testFailMakesVisible();
-  await testSizeAndPurge();
-  await testCustomQueueUrlResolver();
-  await testSessionTokenHeader();
+  try {
+    await testFactoryValidation();
+    await testNumericConfigValidation();
+    await testEnqueueWireShape();
+    await testDelaySecondsClampedAt900();
+    await testLeaseRoundTrip();
+    await testCompleteDeletes();
+    await testExtendLease();
+    await testFailMakesVisible();
+    await testSizeAndPurge();
+    await testCustomQueueUrlResolver();
+    await testSessionTokenHeader();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/request-id-async-context.test.js

@@ -103,11 +103,28 @@ async function testConcurrentRequestsIsolated() {
   check("concurrent: every response header matches its request", hdrsMatch);
 }
 
+// Each fixture http.Server is .close()'d, but the listening handle finalizes on
+// a later event-loop turn — past the forked worker's post-run grace window.
+// Poll process.getActiveResourcesInfo until no TCP handle remains; polling
+// drives the real event-loop turns that complete the close inside run().
+async function _drainTcpHandles() {
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "request-id-async-context: TCP handle drain" });
+}
+
 async function run() {
-  testSurface();
-  await testAsyncContextBindsAls();
-  await testDefaultModeDoesNotBindAls();
-  await testConcurrentRequestsIsolated();
+  try {
+    testSurface();
+    await testAsyncContextBindsAls();
+    await testDefaultModeDoesNotBindAls();
+    await testConcurrentRequestsIsolated();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };