@blamejs/core 0.6.58 → 0.6.59

package/CHANGELOG.md

@@ -8,6 +8,8 @@ upgrading across more than a few patches at a time.
 
 ## v0.6.x
 
+- **0.6.59** (2026-05-03) — HTTP/2 session teardown deduplication + http-client sweep. v0.6.58's inline `session.close() + session.destroy()` block in `lib/log-stream-otlp-grpc.js` was the right fix for the OTLP-gRPC sink hang, but the same bug class lives in `lib/http-client.js` — the h2 transport pool had 5 call sites running the bare `session.close()` (`_resetTransports`, the ALPN-fallback path, the h2 connect-error path, the h2c connect-error path, the idle-timeout handler, and `_resetForTest`) all of which leak the underlying TCP socket on idle / error / fallback paths in exactly the same way. New `lib/http2-teardown.js` exports `tearDownH2Session(session)` which performs the close()-then-destroy() routine; `lib/http-client.js` and `lib/log-stream-otlp-grpc.js` both import it. The OTLP-gRPC v0.6.58 inline block is removed in favour of the shared helper. **Tests** — verified in a node:24-alpine docker container: smoke 7204 checks in 85.3 seconds. Wiki e2e 178 / eslint clean / shellcheck clean.
+
 - **0.6.58** (2026-05-03) — `b.logStream` OTLP-gRPC sink hang fix that has been silently breaking the npm-publish gate since v0.6.38. The sink's `close()` was calling `session.close()` (HTTP/2 *graceful* close — waits for in-flight streams before freeing the socket) but never `session.destroy()`. The graceful close completed but the underlying TCP socket stayed connected, blocking the test fixture's `server.close()` indefinitely on Linux CI runners. Same bug also added ~120 seconds of lingering latency to every local smoke run on Windows (smoke 196s → 76s after fix). The fix calls `session.close()` then `session.destroy()`; by the time we reach close(), all buffered records have been flushed via the awaited `inflightPromise` + final `_doExport`, so destroy() is structurally safe. **Operator impact** — the npm registry has been stuck at v0.6.37 since 2026-05-02; every tag from v0.6.38 → v0.6.57 timed out at the publish workflow's smoke step. With this fix the publish should reach `npm publish`. No layer-0 or integration test changes — the existing `log-stream-otlp-grpc.test.js` round-trip was passing locally because tests use small batches and the lingering socket happens to terminate before the test driver's overall timeout, but it was leaving the process unable to exit cleanly until the OS-level TCP timeout fired. Smoke 7204 / wiki e2e 178 / integration 16 files / eslint clean / shellcheck clean.
 
 - **0.6.57** (2026-05-03) — `b.safeBuffer.boundedChunkCollector` strict `maxBytes` validation. Pre-fix the validator was `typeof opts.maxBytes === "number" && opts.maxBytes > 0` which silently accepted `Infinity` (defeating the OOM-cap purpose entirely — a hostile 10-GB upstream would accumulate fully) and non-integer floats like `3.5` (which set a fractional cap that confused downstream `total + chunk.length > maxBytes` arithmetic). Now requires positive finite integer; everything else throws `buffer/bad-arg` at boot with the offending value in the message. Real-world consumers (`b.httpClient` request cap, `b.atomicFile.read`, `b.parsers.*`, multipart body parser) are unaffected because they pass real positive integers via `C.BYTES.*` helpers; the fix catches operator typos / misconfigured env-var coercions where `Number(env.MAX_BYTES)` produces NaN or Infinity. **Tests** — 7 new layer-0 boot-validation assertions in `test/00-primitives.js` (smoke 7197→7204). Wiki e2e 178 / eslint clean / shellcheck clean.

package/lib/http-client.js

@@ -174,13 +174,18 @@ function configurePool(opts) {
     if (t && t.kind === "h1" && t.agent && typeof t.agent.destroy === "function") {
       try { t.agent.destroy(); } catch (_e) {}
     }
-    if (t && t.kind === "h2" && t.session && typeof t.session.close === "function") {
-      try { t.session.close(); } catch (_e) {}
+    if (t && t.kind === "h2" && t.session) {
+      _tearDownH2Session(t.session);
     }
   });
   _transports.clear();
 }
 
+// HTTP/2 session teardown — see lib/http2-teardown.js for the full
+// rationale. Centralised so any future sink / pool teardown gets the
+// same close()-then-destroy() discipline.
+var _tearDownH2Session = require("./http2-teardown").tearDownH2Session;
+
 // h2 session connect options. Same TLS posture as h1 Agent.
 var DEFAULT_H2_TLS_OPTS = {
   ALPNProtocols:    ["h2", "http/1.1"],
@@ -254,11 +259,11 @@ function _connectHttpsWithAlpn(u, ips) {
         return;
       }
       // Server picked http/1.1 — close the h2 session, return h1 transport.
-      try { session.close(); } catch (_e) {}
+      _tearDownH2Session(session);
       _done(_makeH1Transport(u, ips));
     });
     session.once("error", function (err) {
-      try { session.close(); } catch (_e) {}
+      _tearDownH2Session(session);
       _fail(err);
     });
   });
@@ -277,7 +282,7 @@ function _connectH2c(u, ips) {
       resolve({ kind: "h2", session: session });
     });
     session.once("error", function (err) {
-      try { session.close(); } catch (_e) {}
+      _tearDownH2Session(session);
       reject(err);
     });
   });
@@ -286,7 +291,7 @@ function _connectH2c(u, ips) {
 // Common h2 session wiring — idle close + cache eviction on error/close.
 function _wireH2Session(session, key) {
   session.setTimeout(H2_SESSION_IDLE_TIMEOUT_MS, function () {
-    try { session.close(); } catch (_e) {}
+    _tearDownH2Session(session);
   });
   session.once("close", function () { _transports.delete(key); });
   session.once("error", function () { _transports.delete(key); });
@@ -1132,7 +1137,7 @@ function _resetForTest() {
       try { t.agent.destroy(); } catch (_e) {}
     }
     if (t && t.kind === "h2" && t.session) {
-      try { t.session.close(); } catch (_e) {}
+      _tearDownH2Session(t.session);
     }
   });
   _transports.clear();

package/lib/http2-teardown.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * HTTP/2 session teardown — graceful close *then* force-destroy.
+ *
+ * `Http2Session.close()` is the *graceful* close: it returns synchronously
+ * while letting in-flight streams complete on their own, but it does NOT
+ * free the underlying TCP socket until those streams complete (or the
+ * peer disconnects). On idle / error / fallback paths — where we
+ * explicitly DON'T want the session anymore — that means the socket
+ * lingers until the OS-level TCP timeout fires. In a test process the
+ * mock-server's `server.close()` then waits for that lingering socket
+ * to release, which on Linux can be tens of minutes. v0.6.58 hit
+ * exactly this in the OTLP-gRPC sink and timed out the npm-publish
+ * workflow on every tag from v0.6.38 → v0.6.57.
+ *
+ * The fix is structural: every call site that wants the session GONE
+ * routes through this helper, which calls close() (best-effort drain)
+ * then destroy() (force socket teardown). Used by `lib/http-client.js`
+ * (h2 transport pool — fallback, error, idle-timeout, reset) and by
+ * `lib/log-stream-otlp-grpc.js` (sink shutdown after final flush).
+ *
+ * No-op on a null / undefined session. Wraps each call in try/catch so
+ * a partially-torn-down session can't throw and cancel the second call.
+ */
+
+function tearDownH2Session(session) {
+  if (!session) return;
+  try { if (typeof session.close === "function") session.close(); }
+  catch (_e1) { /* best-effort graceful */ }
+  try { if (typeof session.destroy === "function") session.destroy(); }
+  catch (_e2) { /* best-effort socket teardown */ }
+}
+
+module.exports = { tearDownH2Session: tearDownH2Session };

package/lib/log-stream-otlp-grpc.js

@@ -29,6 +29,7 @@ var http2 = require("node:http2");
 var C = require("./constants");
 var pb = require("./protobuf-encoder");
 var safeUrl = require("./safe-url");
+var { tearDownH2Session } = require("./http2-teardown");
 var { LogStreamError } = require("./framework-error");
 
 var _err = LogStreamError.factory;
@@ -372,22 +373,12 @@ function create(config) {
         _emitDrop("send-failed", pending, e);
       }
     }
-    // Tear down the HTTP/2 session. `session.close()` is the *graceful*
-    // close — it waits for in-flight streams to complete on their own
-    // and won't free the underlying socket while any stream is still
-    // open. By this point we've already awaited `inflightPromise` and
-    // run a final `_doExport` for any buffered records, so there's
-    // nothing left to drain; `session.destroy()` is the structurally
-    // correct call. (Calling only close() left the test fixture's
-    // server.close() hanging indefinitely on Linux CI runners — the
-    // close() was returning while the underlying TCP socket stayed
-    // connected, blocking the server-side close from completing.)
-    try {
-      if (session) {
-        try { session.close(); } catch (_e1) { /* best-effort graceful */ }
-        try { session.destroy(); } catch (_e2) { /* socket teardown */ }
-      }
-    } catch (_e) {}
+    // Tear down the HTTP/2 session via the shared close+destroy helper.
+    // By this point we've already awaited inflightPromise and run a
+    // final _doExport for any buffered records, so there's nothing left
+    // to drain. See lib/http2-teardown.js for the rationale on why
+    // close() alone leaves the underlying socket connected on Linux.
+    tearDownH2Session(session);
     session = null;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.6.58",
+  "version": "0.6.59",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cyclonedx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:246b27c1-6c5e-4ffc-9840-0275a3ed556a",
+  "serialNumber": "urn:uuid:f1dea294-4db6-4cb4-9820-6958e7939dac",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-05-03T13:19:55.918Z",
+    "timestamp": "2026-05-03T13:30:21.472Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.6.58",
+      "bom-ref": "@blamejs/core@0.6.59",
       "type": "library",
       "name": "blamejs",
-      "version": "0.6.58",
+      "version": "0.6.59",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.6.58",
+      "purl": "pkg:npm/%40blamejs/core@0.6.59",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.6.58",
+      "ref": "@blamejs/core@0.6.59",
       "dependsOn": []
     }
   ]