@blamejs/blamejs-shop 0.4.101 → 0.4.102

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

@@ -240,9 +240,44 @@ async function testByteCapMultibyte() {
     t2 && t2.code === "sandbox/oversized-result");
 }
 
+async function testWorkerHandleReleased() {
+  // b.sandbox.run spawns a worker thread and calls worker.terminate() — which
+  // is asynchronous — on the result/timeout paths. It must await that
+  // termination before settling the caller's promise, otherwise the worker's
+  // MessagePort stays alive past the resolve and a long-lived process running
+  // sandboxed code repeatedly accumulates leaked MessagePort handles. The
+  // timeout path is the widest leak window (the worker is spinning and
+  // forcibly terminated, so terminate() takes longest); drive it repeatedly
+  // and assert no MessagePort is left active. RED before the fix (the reject
+  // raced ahead of the async terminate, leaving the busy worker's port alive).
+  function _ports() {
+    return process.getActiveResourcesInfo().filter(function (r) { return r === "MessagePort"; }).length;
+  }
+  var before = _ports();
+  // Drive several spinning workers CONCURRENTLY so that, if terminate() is not
+  // awaited, all their MessagePorts are mid-close at the instant Promise.all
+  // settles — amplifying the leak from one racy handle into N simultaneously
+  // open ones, which the synchronous count below catches deterministically.
+  var N = 8;
+  var runs = [];
+  for (var i = 0; i < N; i += 1) {
+    runs.push(b.sandbox.run({ source: "while (true) {}", timeoutMs: 150 }).then(
+      function () { return "resolved"; },
+      function (e) { return e && e.code; }));
+  }
+  var outcomes = await Promise.all(runs);
+  check("all spinning sandbox.run calls time out",
+    outcomes.length === N && outcomes.every(function (o) { return o === "sandbox/timeout"; }));
+  // The fix awaits worker.terminate() before settling, so every port is closed
+  // by the time its promise resolves; with the bug, N ports linger here.
+  check("sandbox.run releases the worker MessagePort after timeout-terminate (no handle leak)",
+    _ports() <= before);
+}
+
 async function run() {
   await testByteCapMultibyte();
   testErrorClassExposed();
+  await testWorkerHandleReleased();
   await testHappyPath();
   await testAllowedBuiltins();
   await testBadAllowedRejected();

package/lib/vendor/blamejs/test/layer-0-primitives/sd-jwt-vc.test.js

@@ -813,7 +813,7 @@ function testExports() {
 
 // ---- Run all ----
 
-(async function run() {
+async function run() {
   testDisclosureEncodeDecode();
   testDisclosureValueComplexShape();
   testDisclosureBadInput();
@@ -847,4 +847,7 @@ function testExports() {
   await testHolderAlgFromKeyType();
   await testKbAlgKtyCrossCheck();
   testExports();
-})().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/self-update-poll-asset-digest.test.js

@@ -75,9 +75,28 @@ async function testPollDigestNullWhenAbsent() {
   } finally { server.close(); }
 }
 
+// selfUpdate.poll dials the releases 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 (client sockets + the fixture server's
+// accept socket) has actually drained so none outlives 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: "self-update-poll-asset-digest: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  await testPollExposesAssetDigest();
-  await testPollDigestNullWhenAbsent();
+  try {
+    await testPollExposesAssetDigest();
+    await testPollDigestNullWhenAbsent();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

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

@@ -280,17 +280,36 @@ async function testRollbackMissingBackupRefused() {
   try { fs.rmdirSync(dir); } catch (_e) { /* best-effort */ }
 }
 
+// selfUpdate.poll dials the releases 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 (client sockets + any fixture-server accept
+// socket) has actually drained so none outlives 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: "self-update: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  testSurface();
-  testCompareTags();
-  await testPollRejectsBadOpts();
-  await testPollAvailableAndUpToDate();
-  await testPollArrayShape();
-  await testPollNon2xxRefused();
-  await testVerifyPassFail();
-  await testSwapAndRollback();
-  await testSwapMissingFromRefused();
-  await testRollbackMissingBackupRefused();
+  try {
+    testSurface();
+    testCompareTags();
+    await testPollRejectsBadOpts();
+    await testPollAvailableAndUpToDate();
+    await testPollArrayShape();
+    await testPollNon2xxRefused();
+    await testVerifyPassFail();
+    await testSwapAndRollback();
+    await testSwapMissingFromRefused();
+    await testRollbackMissingBackupRefused();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

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

@@ -1017,40 +1017,58 @@ function testCanonicalPathSingleEncodeForS3() {
         sigv4.awsUriEncode("photo-\u{1F600}.jpg", true) === "photo-%F0%9F%98%80.jpg");
 }
 
+// bucketOps dispatches every request 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 none outlives 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: "sigv4-bucket-ops: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  testSurface();
-  testCanonicalPathSingleEncodeForS3();
-  testFactoryValidation();
-  testBucketNameValidation();
-  testLifecycleXml();
-  testCorsXml();
-  await testCreateBucketUsEast1NoBody();
-  await testCreateBucketOtherRegionSendsLocationConstraint();
-  await testCreateBucketAlreadyOwnedMaps();
-  await testCreateBucketTakenMaps();
-  await testDeleteBucketHappyAndMissing();
-  await testDeleteBucketNotEmptyMaps();
-  await testListBuckets();
-  await testSetLifecycleSendsXml();
-  await testSetCorsRulesSendsXml();
-  // v0.6.47 — Object Lock
-  await testCreateBucketObjectLockEnabled();
-  await testSetObjectLockConfiguration();
-  await testSetObjectLockConfigurationValidation();
-  await testGetObjectLockConfiguration();
-  await testSetObjectRetention();
-  await testSetObjectRetentionBypassGovernance();
-  await testSetObjectRetentionValidation();
-  await testGetObjectRetention();
-  await testLegalHold();
-  // v0.6.51 — not-configured response paths return clean defaults
-  await testGetObjectLockConfigurationNotConfigured();
-  await testGetObjectRetentionNotConfigured();
-  await testGetObjectLegalHoldNotConfigured();
-  // v0.6.53 — audit + observability emissions
-  await testAuditObservabilityWiring();
-  await testAuditSuccessFalseDisablesSuccessAudit();
-  await testPerCallActorOverrideHonored();
+  try {
+    testSurface();
+    testCanonicalPathSingleEncodeForS3();
+    testFactoryValidation();
+    testBucketNameValidation();
+    testLifecycleXml();
+    testCorsXml();
+    await testCreateBucketUsEast1NoBody();
+    await testCreateBucketOtherRegionSendsLocationConstraint();
+    await testCreateBucketAlreadyOwnedMaps();
+    await testCreateBucketTakenMaps();
+    await testDeleteBucketHappyAndMissing();
+    await testDeleteBucketNotEmptyMaps();
+    await testListBuckets();
+    await testSetLifecycleSendsXml();
+    await testSetCorsRulesSendsXml();
+    // v0.6.47 — Object Lock
+    await testCreateBucketObjectLockEnabled();
+    await testSetObjectLockConfiguration();
+    await testSetObjectLockConfigurationValidation();
+    await testGetObjectLockConfiguration();
+    await testSetObjectRetention();
+    await testSetObjectRetentionBypassGovernance();
+    await testSetObjectRetentionValidation();
+    await testGetObjectRetention();
+    await testLegalHold();
+    // v0.6.51 — not-configured response paths return clean defaults
+    await testGetObjectLockConfigurationNotConfigured();
+    await testGetObjectRetentionNotConfigured();
+    await testGetObjectLegalHoldNotConfigured();
+    // v0.6.53 — audit + observability emissions
+    await testAuditObservabilityWiring();
+    await testAuditSuccessFalseDisablesSuccessAudit();
+    await testPerCallActorOverrideHonored();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

package/lib/vendor/blamejs/test/layer-0-primitives/sigv4-multipart-sse.test.js

@@ -24,7 +24,6 @@ var sigv4              = require("../../lib/object-store/sigv4");
 var b                  = helpers.b;
 var check              = helpers.check;
 var listenOnRandomPort = helpers.listenOnRandomPort;
-void b;
 
 function _baseConfig(port, overrides) {
   var cfg = {
@@ -416,19 +415,38 @@ async function testMultipartFalseRejectsStreams() {
   }
 }
 
+// The sigv4 store dispatches every part / initiate / complete request through
+// the shared httpClient keep-alive transport pool; cached client sockets
+// finalize their 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 none outlives 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: "sigv4-multipart-sse: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
-  await testSinglePutRemainsBufferAtThreshold();
-  await testMultipartAutoDetectAboveThreshold();
-  await testMultipartFromReadableStream();
-  await testMultipartAbortsOnPartFailure();
-  await testMultipartCompleteErrorBodyFails();
-  await testSseAES256Forwarded();
-  await testSseKmsForwardedWithKeyId();
-  await testSseForwardedOnEveryMultipartRequest();
-  await testSseResponseVerificationFailsOnDroppedHeader();
-  await testSseValidationRejectsBadValues();
-  testConfigValidation();
-  await testMultipartFalseRejectsStreams();
+  try {
+    await testSinglePutRemainsBufferAtThreshold();
+    await testMultipartAutoDetectAboveThreshold();
+    await testMultipartFromReadableStream();
+    await testMultipartAbortsOnPartFailure();
+    await testMultipartCompleteErrorBodyFails();
+    await testSseAES256Forwarded();
+    await testSseKmsForwardedWithKeyId();
+    await testSseForwardedOnEveryMultipartRequest();
+    await testSseResponseVerificationFailsOnDroppedHeader();
+    await testSseValidationRejectsBadValues();
+    testConfigValidation();
+    await testMultipartFalseRejectsStreams();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

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

@@ -524,28 +524,48 @@ async function testConditionalEntityTagPrecedence() {
   }
 }
 
+// The _get helper drives each fixture server with a default-agent http.request
+// (keep-alive), and srv.close() runs fire-and-forget. The kept-alive client
+// sockets, the servers' accept sockets, and any in-flight static-file read
+// (FSReqCallback) finalize their teardown on a later event-loop turn — past the
+// forked worker's grace window. Destroy the global-agent socket pool, then poll
+// until every TCP/fs handle has drained so none outlives run().
+async function _drainTcpHandles() {
+  http.globalAgent.destroy();
+  if (typeof process.getActiveResourcesInfo !== "function") return;
+  await helpers.waitUntil(function () {
+    return process.getActiveResourcesInfo().filter(function (t) {
+      return t === "TCPSocketWrap" || t === "TCPServerWrap" || t === "FSReqCallback";
+    }).length === 0;
+  }, { timeoutMs: 5000, label: "static: TCP/fs handle drain after globalAgent.destroy" });
+}
+
 async function run() {
-  await testConditionalEntityTagPrecedence();
-  await testForceAttachmentDefaultOff();
-  await testForceAttachmentOnHtml();
-  await testForceAttachmentOnJs();
-  await testForceAttachmentTextStillInline();
-  await testForceAttachmentRasterStillInline();
-  await testForceAttachmentSvgWithoutSanitizer();
-  await testForceAttachmentSvgWithSanitizerInlineAllowed();
-  await testForceAttachmentPdfDefaultDownload();
-  await testForceAttachmentPdfOptInInline();
-  await testMountTypeUserContentForcesDownloadByDefault();
-  await testMountTypeCuratedKeepsInline();
-  await testMountTypeExplicitOverrideWins();
-  testMountTypeBadValueThrows();
-  testRejectsUnknownOpts();
-  await testOnErrorFiresOnRefusal();
-  await testOnErrorThrowDoesNotCorruptResponse();
-  testOnErrorRejectsNonFunction();
-  await testPathTraversalRefused();
-  await testNestedFileServed();
-  await testDirectoryIndexServed();
+  try {
+    await testConditionalEntityTagPrecedence();
+    await testForceAttachmentDefaultOff();
+    await testForceAttachmentOnHtml();
+    await testForceAttachmentOnJs();
+    await testForceAttachmentTextStillInline();
+    await testForceAttachmentRasterStillInline();
+    await testForceAttachmentSvgWithoutSanitizer();
+    await testForceAttachmentSvgWithSanitizerInlineAllowed();
+    await testForceAttachmentPdfDefaultDownload();
+    await testForceAttachmentPdfOptInInline();
+    await testMountTypeUserContentForcesDownloadByDefault();
+    await testMountTypeCuratedKeepsInline();
+    await testMountTypeExplicitOverrideWins();
+    testMountTypeBadValueThrows();
+    testRejectsUnknownOpts();
+    await testOnErrorFiresOnRefusal();
+    await testOnErrorThrowDoesNotCorruptResponse();
+    testOnErrorRejectsNonFunction();
+    await testPathTraversalRefused();
+    await testNestedFileServed();
+    await testDirectoryIndexServed();
+  } finally {
+    await _drainTcpHandles();
+  }
 }
 
 module.exports = { run: run };

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

@@ -3,11 +3,36 @@
  * b.testing.request — supertest-style chainable HTTP test helper.
  */
 
+var http  = require("node:http");
 var helpers = require("../helpers");
 var b     = helpers.b;
 var check = helpers.check;
 
+// b.testing.request drives the harness server with a default-agent http.request
+// (keep-alive) and closes the fixture server fire-and-forget. The kept-alive
+// client socket and the server's accept socket finalize their destroy on a
+// later event-loop turn, past the forked worker's grace window. Destroy the
+// global-agent socket pool, then poll until every TCP handle has drained so
+// none outlives run().
+async function _drainTcpHandles() {
+  http.globalAgent.destroy();
+  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: "testing-request: TCP handle drain after globalAgent.destroy" });
+}
+
 async function run() {
+  try {
+    await _runTests();
+  } finally {
+    await _drainTcpHandles();
+  }
+}
+
+async function _runTests() {
   // ---- Surface ----
   check("b.testing.request is fn",  typeof b.testing.request === "function");
 

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

@@ -112,9 +112,11 @@ function testLiveHandshake() {
           } catch (e) {
             client.destroy(); server.close(); reject(e); return;
           }
-          client.end();
-          server.close();
-          resolve();
+          // Hand the live handles back so run()'s drain can destroy them and
+          // poll until their TCP handles release — a fire-and-forget end()/close()
+          // here leaves the client/server sockets finalizing past the worker's
+          // post-run grace window.
+          resolve({ server: server, client: client });
         }
 
         var server = nodeTls.createServer({
@@ -154,10 +156,32 @@ function testLiveHandshake() {
   });
 }
 
+// Destroy the live TLS client + server handed back by the handshake, then poll
+// until their TCP handles release. Polling drives the real event-loop turns
+// that complete the async socket teardown inside run(), instead of leaving it
+// to finalize in the worker's post-run grace window.
+async function _drainTcpHandles(handles) {
+  if (handles) {
+    if (handles.client) { try { handles.client.destroy(); } catch (_e) { /* already torn down */ } }
+    if (handles.server) { try { handles.server.close(); } catch (_e) { /* already closed */ } }
+  }
+  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: "tls-exporter: TCP handle drain after socket destroy" });
+}
+
 async function run() {
-  testSurface();
-  testValidationPaths();
-  await testLiveHandshake();
+  var handles = null;
+  try {
+    testSurface();
+    testValidationPaths();
+    handles = await testLiveHandshake();
+  } finally {
+    await _drainTcpHandles(handles);
+  }
 }
 
 module.exports = { run: run };

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

@@ -736,7 +736,29 @@ async function testStripeNonceStoreConcurrentAtomic() {
   if (ns.close) await ns.close();
 }
 
+// signer.send dispatches 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 none outlives 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: "webhook: TCP handle drain after _resetForTest" });
+}
+
 async function run() {
+  try {
+    await _runTests();
+  } finally {
+    await _drainTcpHandles();
+  }
+}
+
+async function _runTests() {
   testWebhookSurface();
   await testHmacRoundtrip();
   await testHmacBufferBody();

package/lib/vendor/blamejs/test/layer-0-primitives/worker-pool-recycle-race.test.js

@@ -42,11 +42,12 @@ async function run() {
       .catch(function (e) { bError = e; });
 
     // Bound the wait so a hung B fails the test rather than hanging the suite.
-    await Promise.race([
-      Promise.all([aPromise, bPromise]),
-      helpers.waitUntil(function () { return bResult !== null || bError !== null; },
-        { timeoutMs: 8000, label: "#127: queued task settles after the slot recycles" }),
-    ]);
+    // withTestTimeout clears its guard timer on settle (a raced waitUntil would
+    // keep polling — and leave its in-flight poll timer — once Promise.all won).
+    await helpers.withTestTimeout(
+      "#127: queued task settles after the slot recycles",
+      function () { return Promise.all([aPromise, bPromise]); },
+      { timeoutMs: 8000 });
 
     check("#127 the timing-out task A is reaped (timeout, as expected)",
           aErr && aErr.code === "workerpool/timeout");
@@ -55,7 +56,10 @@ async function run() {
     check("#127 the queued task runs on the replacement worker and returns its result",
           bResult && bResult.v === 42);
   } finally {
-    pool.terminate();
+    // Await termination so the worker threads fully exit before run()
+    // returns — an un-awaited terminate() leaves the worker's MessagePort
+    // and reap timer alive past the assertions.
+    await pool.terminate();
   }
 }