@blamejs/blamejs-shop 0.4.101 → 0.4.102

package/lib/vendor/blamejs/release-notes/v0.15.26.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.15.26",
+  "date": "2026-06-25",
+  "headline": "Internal test-harness correctness only — the published library is byte-for-byte identical to 0.15.25",
+  "summary": "The smoke runner requires each test module and awaits its exported run(). Several tests were instead written as a top-level (async function () {...})() IIFE that runs detached at require-time, so the runner measured and reported the test's result before the IIFE's post-await assertions executed — those checks silently never ran (one parser test exercised 4 of its 26 assertions, and a failure after the first await would have gone unseen as a false pass). Those tests are converted to the exported-run form so the runner awaits their full assertion set, and a codebase-patterns detector now refuses a top-level async IIFE in a test file so the pattern cannot return. No shipped framework code changed; this release is byte-for-byte identical to 0.15.25 for operators.",
+  "sections": [
+    {
+      "heading": "Fixed",
+      "items": [
+        {
+          "title": "Detached-IIFE tests now run their full assertion set under the smoke runner",
+          "body": "A test written as a top-level (async function () {...})() IIFE runs detached when the runner requires it: the runner only awaits an exported run(), so it reported the file's result before the IIFE's awaited assertions executed, and every check after the first await silently did not count (one parsers test ran 4 of 26). Such tests are rewritten to define async function run(), export it, and invoke it under if (require.main === module), so the runner awaits the complete set; a detector refuses a re-introduced top-level async IIFE in a test file. This is test-harness correctness only — no shipped framework behavior changed."
+        }
+      ]
+    }
+  ]
+}

package/lib/vendor/blamejs/test/layer-0-primitives/ai-adverse-decision.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 captured = null;
   var hire = b.ai.adverseDecision.wrap({
     audit: false,
@@ -41,4 +41,7 @@ var check = helpers.check;
   check("ai.adverseDecision refuses missing legalBasis", threwBadLegal);
 
   console.log("OK — ai.adverseDecision 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/atomic-file-open-nofollow.test.js

@@ -12,7 +12,7 @@ var helpers = require("../helpers");
 var b     = helpers.b;
 var check = helpers.check;
 
-function run() {
+async function run() {
   check("b.atomicFile.openNoFollowSync is a function",
         typeof b.atomicFile.openNoFollowSync === "function");
 
@@ -58,12 +58,17 @@ function run() {
       }
     }
 
-    return new Promise(function (resolve) {
+    // Await the stream's end BEFORE the finally cleanup. Without the await,
+    // the try block returns its promise and the finally runs synchronously —
+    // removing the dir and leaving the stream's in-flight read (FSReqCallback)
+    // alive past run(). Awaiting drains the read before cleanup.
+    await new Promise(function (resolve, reject) {
       rs.on("end", function () {
         check("an fd from openNoFollowSync is consumable by createReadStream",
               streamed === "payload-bytes");
         resolve();
       });
+      rs.on("error", reject);
     });
   } finally {
     try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) { /* best-effort */ }

package/lib/vendor/blamejs/test/layer-0-primitives/azure-blob-bucket-ops.test.js

@@ -235,17 +235,37 @@ async function testSetLifecycleNotSupported() {
   } finally { await l.close(); }
 }
 
+// bucketOps.create issues its 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: "azure-blob-bucket-ops: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  await testSurface();
-  await testFactoryValidation();
-  await testContainerNameValidation();
-  await testCreateContainerWireShape();
-  await testCreateContainerConflict();
-  await testDeleteContainer();
-  await testListContainers();
-  await testSetCorsRulesValidation();
-  await testSetCorsRulesWireShape();
-  await testSetLifecycleNotSupported();
+  try {
+    await testSurface();
+    await testFactoryValidation();
+    await testContainerNameValidation();
+    await testCreateContainerWireShape();
+    await testCreateContainerConflict();
+    await testDeleteContainer();
+    await testListContainers();
+    await testSetCorsRulesValidation();
+    await testSetCorsRulesWireShape();
+    await testSetLifecycleNotSupported();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/azure-blob-key-encoding.test.js

@@ -49,7 +49,28 @@ function _client(port) {
   });
 }
 
+// The azure adapter issues requests through the shared b.httpClient
+// keep-alive agent, whose cached client socket (and the mock server it
+// keeps 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: "azure-blob-key-encoding: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
+  try { await _runTests(); }
+  finally { await _drainTcpHandles(); }
+}
+
+async function _runTests() {
   var srv = await listenRecording();
   try {
     var c = _client(srv.port);

package/lib/vendor/blamejs/test/layer-0-primitives/bearer-auth.test.js

@@ -16,24 +16,26 @@ var _bodyReq  = helpers._bodyReq;
 var _bodyRes  = helpers._bodyRes;
 
 function _runMiddleware(mw, req, res) {
-  return new Promise(function (resolve) {
-    var settled = false;
-    mw(req, res, function () {
-      if (settled) return;
-      settled = true;
-      resolve({ next: true, status: res._endedStatus, user: req.user });
+  // The middleware settles by calling next() or by ending the response. Wrap
+  // in withTestTimeout so a middleware 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("bearer-auth: middleware settles", function () {
+    return new Promise(function (resolve) {
+      var settled = false;
+      function _settle(value) {
+        if (settled) return;
+        settled = true;
+        resolve(value);
+      }
+      mw(req, res, function () {
+        _settle({ next: true, status: res._endedStatus, user: req.user });
+      });
+      res.on("finish", function () {
+        _settle({ next: false, status: res._endedStatus, user: req.user });
+      });
     });
-    res.on("finish", function () {
-      if (settled) return;
-      settled = true;
-      resolve({ next: false, status: res._endedStatus, user: req.user });
-    });
-    setTimeout(function () {
-      if (settled) return;
-      settled = true;
-      resolve({ next: false, status: res._endedStatus, timeout: true });
-    }, 1500);                                                                    // allow:raw-byte-literal — test safety timeout ms
-  });
+  }, { timeoutMs: 1500 });                                                        // allow:raw-byte-literal — middleware-settle budget ms
 }
 
 function testBearerSurface() {
@@ -97,6 +99,9 @@ async function run() {
   await testBearerInvalidTokenRejected();
   await testBearerVerifyThrowsRejected();
   await testBearerValidAttachesUser();
+  // The 401-reject paths emit an audit event, which schedules the audit
+  // handler's age-flush timer. Drain it so no timer lingers past run().
+  await b.audit.flush();
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/body-parser-chunked-malformed.test.js

@@ -35,25 +35,27 @@ function _runWithError(headers, parserError) {
   var bp  = b.middleware.bodyParser();
   var req = _chunkedReq(headers);
   var res = _bodyRes();
-  return new Promise(function (resolve) {
-    var settled = false;
-    bp(req, res, function () {
-      if (settled) return;
-      settled = true;
-      resolve({ next: true, status: res._endedStatus, req: req });
+  // The parser settles by calling next() or by ending the response after the
+  // emitted error. 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.
+  return helpers.withTestTimeout("body-parser: malformed-body parser settles", function () {
+    return new Promise(function (resolve) {
+      var settled = false;
+      function _settle(value) {
+        if (settled) return;
+        settled = true;
+        resolve(value);
+      }
+      bp(req, res, function () {
+        _settle({ next: true, status: res._endedStatus, req: req });
+      });
+      res.on("finish", function () {
+        _settle({ next: false, status: res._endedStatus, headers: res._headers, req: req });
+      });
+      setImmediate(function () { req.emit("error", parserError); });
     });
-    res.on("finish", function () {
-      if (settled) return;
-      settled = true;
-      resolve({ next: false, status: res._endedStatus, headers: res._headers, req: req });
-    });
-    setImmediate(function () { req.emit("error", parserError); });
-    setTimeout(function () {
-      if (settled) return;
-      settled = true;
-      resolve({ next: false, timeout: true, req: req });
-    }, 1500);
-  });
+  }, { timeoutMs: 1500 });                                                        // allow:raw-byte-literal — parser-settle budget ms
 }
 
 async function testInvalidChunkSizeRefused() {
@@ -123,6 +125,9 @@ async function run() {
   await testInvalidTransferEncodingRefused();
   await testInvalidEofStateRefused();
   await testNonChunkedErrorAlsoClosesConnection();
+  // The malformed-body rejects emit an audit event, which schedules the
+  // audit handler's age-flush timer. Drain it so no timer lingers past run().
+  await b.audit.flush();
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/breach-deadline.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 now = Date.now();
   var d = b.breach.deadline.forStates(["CA", "TX"], now);
   check("forStates returns 2", d.length === 2);
@@ -118,6 +118,11 @@ var check = helpers.check;
   check("auto-tick timer fired the passed alert", true);
   autoClock.stop();
   check("clock stops cleanly", autoClock.status().running === false);
+}
 
-  console.log("OK — breach-deadline tests");
-})().catch(function (e) { console.error(e); process.exit(1); });
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK — breach-deadline tests"); })
+       .catch(function (e) { console.error(e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/ciba-authreqid-binding.test.js

@@ -82,7 +82,29 @@ function _push(idToken, bodyAuthReqId) {
   };
 }
 
+// The CIBA client's discovery + JWKS fetches go through the shared
+// b.httpClient keep-alive agent, whose cached client socket (and the mock
+// IdP server it keeps 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: "ciba-authreqid-binding: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
+  try { await _runTests(); }
+  finally { await _drainTcpHandles(); }
+}
+
+async function _runTests() {
   await _withIdp(async function (issuer) {
     var ciba = _cibaClient(issuer);
 

package/lib/vendor/blamejs/test/layer-0-primitives/codebase-patterns.test.js

@@ -9425,6 +9425,20 @@ var KNOWN_ANTIPATTERNS = [
     allowlist: [],
     reason: "The smoke worker requires each test module and awaits its exported run(); a column-0 `run()` / `run().then(...process.exit...)` fires a second unawaited run() at require-time that races the worker's result print (and process.exit() exits before the result line, read as 'no result line' / 'fork failed' on a slow runner). Export `run` and wrap the invocation in `if (require.main === module)`. Fires on any `run(` at the start of a line; `function run()`, `module.exports = { run }`, and an indented `run()` inside the require-main guard stay silent.",
   },
+  {
+    id: "test-detached-async-iife",
+    primitive: "define `async function run() {...}`, `module.exports = { run }`, and invoke under `if (require.main === module) run().catch(...)` — never a top-level `(async function () {...})()` IIFE",
+    scanScope: "test",
+    regex: /^\(async\b/m,
+    skipCommentLines: true,
+    allowlist: [
+      // The smoke runner itself — its top-level `(async function () {...})()` is
+      // the orchestrator's process entry point (it forks the per-file workers),
+      // not a worker-awaited test body. It has no run() to export.
+      "test/smoke.js",
+    ],
+    reason: "The smoke worker requires each test module and only `await mod.run()`. A test written as a top-level `(async function run(){...})()` IIFE runs DETACHED on require: the worker measures + prints its result before the IIFE's post-await assertions execute, so every check after the first await silently never counts (parsers-standalone reported 4 of 26 checks this way) and a failing post-await assertion is never seen — a false pass. Export `run` and invoke under `if (require.main === module)`. Fires on a column-0 `(async` (function or arrow IIFE); `async function run()` (no leading paren), `module.exports = { run }`, and an indented async IIFE inside a helper stay silent. Synchronous `(function(){...})()` IIFEs complete during require, so they do not undercount and are out of scope here.",
+  },
   {
     // `Promise + setTimeout` direct sleep in tests is forbidden;
     // tests waiting on an asynchronous condition MUST use
@@ -12273,6 +12287,41 @@ function testEsbuildPinAgreesAcrossArtifacts() {
     bad);
 }
 
+// The test-detached-async-iife antipattern (scanScope: "test") covers *.test.js,
+// but the legacy single-layer entry files (test/00-primitives.js …
+// 50-integration.js) are required + run directly by smoke.js via _runLayer and
+// are NOT in _testFiles(). A top-level `(async function () {...})()` there would
+// have the same detached false-pass — the worker awaits mod.run / mod.groups,
+// never a require-time IIFE — so scan those files for the same shape here. Scoped
+// to the IIFE pattern ONLY (not the full test-discipline catalog): those files
+// carry a separate, larger setTimeout-sleep cleanup that is its own task.
+function testNoDetachedAsyncIifeInLegacyLayerFiles() {
+  var bad = [];
+  var entries;
+  try { entries = fs.readdirSync(TEST_ROOT); }
+  catch (_e) { entries = []; }
+  for (var i = 0; i < entries.length; i++) {
+    if (!/^[0-9]{2}-[\w-]+\.js$/.test(entries[i])) continue;
+    var content;
+    try { content = fs.readFileSync(path.join(TEST_ROOT, entries[i]), "utf8"); }
+    catch (_e) { continue; }
+    var lines = content.split(/\r?\n/);
+    for (var j = 0; j < lines.length; j++) {
+      if (/^\s*(\/\/|\*|\/\*)/.test(lines[j])) continue; // skip comment lines
+      if (/^\(async\b/.test(lines[j])) {
+        bad.push({ file: "test/" + entries[i], line: j + 1,
+          content: "top-level `(async` IIFE — define `async function run()` + `module.exports = { run }` " +
+                   "and invoke under `if (require.main === module)`; a detached async IIFE false-passes its " +
+                   "post-await assertions (the worker awaits mod.run / mod.groups, not a require-time IIFE)" });
+      }
+    }
+  }
+  bad = _filterMarkers(bad, "test-detached-async-iife-legacy");
+  _report("no detached top-level async IIFE in the legacy single-layer smoke entry files " +
+          "(test/NN-*.js run via smoke.js _runLayer — an IIFE there false-passes like in a *.test.js)",
+    bad);
+}
+
 // v1 — error codes are the operator-grep contract and must be
 // `namespace/kebab-case`. The first string argument to `new XError(...)`
 // and `XError.factory(...)` IS the code (defineClass constructor signature
@@ -13235,6 +13284,7 @@ async function run() {
   // step's port mapping + curl host.
   testWikiPortAgreesAcrossArtifacts();
   testEsbuildPinAgreesAcrossArtifacts();
+  testNoDetachedAsyncIifeInLegacyLayerFiles();
   testNoTrackedInternalNotes();
   testResidencyGatesWired();
   testWikiStopGraceExceedsShutdownBudget();

package/lib/vendor/blamejs/test/layer-0-primitives/compliance-sanctions.test.js

@@ -681,7 +681,7 @@ function testFetcherValidation() {
 
 // ---- Run all ----
 
-(function run() {
+function _syncTests() {
   testNormalize();
   testTokenize();
   testLevenshtein();
@@ -715,12 +715,20 @@ function testFetcherValidation() {
   testAliasEmpty();
   testAliasExtraPairs();
   testAliasIntegrationWithScreen();
-})();
+}
 
-// Fetcher tests are async; run them in their own block
-(async function fetcherTests() {
+// Fetcher tests are async; run them in their own block.
+async function _fetcherTests() {
   await testFetcherTickRefresh();
   await testFetcherFetchFailure();
   await testFetcherEmptyResult();
   testFetcherValidation();
-})().catch(function (e) { console.error(e); process.exit(1); });
+}
+
+async function run() {
+  _syncTests();
+  await _fetcherTests();
+}
+
+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/cra-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 cra = b.cra.report.create({
     audit: false,
     productId: "blamejs-1.x",
@@ -28,4 +28,7 @@ var check = helpers.check;
   check("cra refuses missing manufacturer", threwNoMfg);
 
   console.log("OK — cra.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/daily-byte-quota.test.js

@@ -47,12 +47,17 @@ function _mockRes() {
   };
 }
 
-function _drive(mw, req, res) {
-  return new Promise(function (resolve) {
-    mw(req, res, function () { resolve("next"); });
-    helpers.passiveObserve(200, "daily-byte-quota: middleware-hung detection window")
-      .then(function () { if (!res._captured.ended) resolve("hung"); });
-  });
+async function _drive(mw, req, res) {
+  // Hung-detection: the middleware is given a real-time window to either call
+  // next() or end the response; whichever happened decides the outcome. This
+  // is a verify-over-a-window observation (we let the full window elapse to
+  // see what the middleware did), so passiveObserve is the right primitive —
+  // it clears its own timer when the window completes, leaving nothing behind.
+  var nextCalled = false;
+  mw(req, res, function () { nextCalled = true; });
+  await helpers.passiveObserve(200, "daily-byte-quota: middleware-hung detection window");   // allow:raw-byte-literal — detection window ms
+  if (nextCalled) return "next";
+  return res._captured.ended ? "next" : "hung";
 }
 
 async function testQuotaBelowLimitPasses() {
@@ -142,12 +147,18 @@ function testSkipPathsBypass() {
   check("skipPaths bypass calls next", seen.length === 2);
 }
 
-(async function run() {
+async function run() {
   await testQuotaBelowLimitPasses();
   await testQuotaAboveLimitRefuses();
   await testGetKeyOverride();
   await testNullKeyBypassesQuota();
   testCreateRefusesBadQuota();
   testSkipPathsBypass();
-  console.log("OK — daily-byte-quota tests");
-})().catch(function (e) { console.error(e); process.exit(1); });
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK — daily-byte-quota tests"); })
+       .catch(function (e) { console.error(e); process.exit(1); });
+}

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

@@ -1002,7 +1002,7 @@ async function testResealValidationAndStore() {
 
 // ---- Run all ----
 
-(async function run() {
+async function run() {
   await testSubmitAccess();
   await testSubmitErasure();
   await testSubmitInvalidType();
@@ -1062,4 +1062,10 @@ async function testResealValidationAndStore() {
   // AAD_ROTATION descriptor + reseal
   testAadRotationDescriptor();
   await testResealValidationAndStore();
-})().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/fido-mds3.test.js

@@ -445,22 +445,41 @@ async function testInternalVerifyRejectsBadJws() {
 
 // ---- run ----
 
+// fido-mds3.fetch dials the MDS3 endpoint through the shared httpClient
+// keep-alive transport pool; a cached client socket finalizes its destroy on a
+// later event-loop turn, past the forked worker's grace window. Reset the pool,
+// then poll until every TCP handle has actually drained so it doesn't outlive
+// 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: "fido-mds3: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  testSurface();
-  testLookupAaguid();
-  testVerifyAuthenticatorClean();
-  testVerifyAuthenticatorRevoked();
-  testVerifyAuthenticatorDecertified();
-  testVerifyAuthenticatorPhysicalCompromise();
-  testVerifyAuthenticatorRemoteCompromise();
-  testVerifyAuthenticatorUnknownAaguid();
-  testVerifyAuthenticatorBadInputs();
-  testCertifiedLevelPlus();
-  await testFetchRoundTrip();
-  await testFetchRejectsNonHttps();
-  await testFetchRejectsEmptyUrl();
-  await testFetchRejectsBadTimeout();
-  await testInternalVerifyRejectsBadJws();
+  try {
+    testSurface();
+    testLookupAaguid();
+    testVerifyAuthenticatorClean();
+    testVerifyAuthenticatorRevoked();
+    testVerifyAuthenticatorDecertified();
+    testVerifyAuthenticatorPhysicalCompromise();
+    testVerifyAuthenticatorRemoteCompromise();
+    testVerifyAuthenticatorUnknownAaguid();
+    testVerifyAuthenticatorBadInputs();
+    testCertifiedLevelPlus();
+    await testFetchRoundTrip();
+    await testFetchRejectsNonHttps();
+    await testFetchRejectsEmptyUrl();
+    await testFetchRejectsBadTimeout();
+    await testInternalVerifyRejectsBadJws();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/gcs-bucket-ops.test.js

@@ -299,16 +299,37 @@ async function testSetCorsRulesShape() {
   } finally { await l.close(); }
 }
 
+// bucketOps.create issues its requests (storage API + token endpoint)
+// 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: "gcs-bucket-ops: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  await testSurface();
-  await testFactoryValidation();
-  await testBucketNameValidation();
-  await testCreateBucketWireShape();
-  await testCreateBucketConflict();
-  await testDeleteBucket();
-  await testListBuckets();
-  await testSetLifecycleValidationAndShape();
-  await testSetCorsRulesShape();
+  try {
+    await testSurface();
+    await testFactoryValidation();
+    await testBucketNameValidation();
+    await testCreateBucketWireShape();
+    await testCreateBucketConflict();
+    await testDeleteBucket();
+    await testListBuckets();
+    await testSetLifecycleValidationAndShape();
+    await testSetCorsRulesShape();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/guard-csv.test.js

@@ -124,18 +124,30 @@ async function testGateContractShadowMode() {
 }
 
 async function testGateContractRuntimeCap() {
+  // The slow check deliberately elapses a real-time window longer than the
+  // 50ms runtime cap so the gate refuses. passiveObserve is the right
+  // primitive for letting that window pass (it clears its own timer when the
+  // window completes). The gate aborts the check at the cap but the check's
+  // own observation keeps running, so we await its completion below before
+  // returning — that drains the in-check window so nothing lingers past run().
+  var checkDone = null;
   var g = b.gateContract.defineGate({
     name:         "test:runtime-cap",
     maxRuntimeMs: 50,
-    check: async function () {
-      await helpers.passiveObserve(200, "guard-csv: simulated slow check for runtime-cap test");
-      return { ok: true, action: "serve" };
+    check: function () {
+      checkDone = helpers.passiveObserve(120, "guard-csv: slow check elapses past the runtime cap")   // allow:raw-byte-literal — slow-check window > runtime cap
+        .then(function () { return { ok: true, action: "serve" }; });
+      return checkDone;
     },
   });
   var d = await g.check({ bytes: Buffer.from("x") });
   check("runtime cap: refuses with check-threw issue", d.action === "refuse");
   check("runtime cap: issues array carries check-threw",
         d.issues.length === 1 && d.issues[0].kind === "check-threw");
+  // Let the abandoned in-check observation finish so its window-timer self-
+  // clears rather than lingering past run() (the gate already returned at the
+  // 50ms cap; this just waits out the remaining check window).
+  await checkDone;
 }
 
 async function testGateContractBeforeCheckHook() {