@blamejs/core 0.15.27 → 0.15.28

package/CHANGELOG.md

@@ -8,6 +8,8 @@ upgrading across more than a few patches at a time.
 
 ## v0.15.x
 
+- v0.15.28 (2026-06-25) — **`b.network.dns` and `b.network.tls` errors now carry a usable terminal-vs-transient signal on `err.permanent`, so a caller's retry loop re-attempts only the failures a retry can fix.** DnsError was declared always-transient and NetworkTlsError always-permanent, so a consumer driving its own retry loop got the wrong signal in both directions: it would retry a permanent DNS failure (a bad host, bad options, an unsupported query, an NXDOMAIN-style no-result, or a caller-shape/config error such as an unconfigured transport or an invalid resolver list) forever, and it would refuse to retry a transient TLS-over-network failure (an ECH connection failure, a handshake timeout, DNS momentarily unavailable). err.permanent now reflects each error's actual transience, derived from its code and failing closed (an unknown code is permanent, so a hopeless target is not retried indefinitely): for DnsError only a failed network round-trip (a lookup timeout, a resolve/reverse query that failed on the wire, a failed DoH/DoT exchange, a DDR discovery that found nothing) is transient — config, input, and environment errors raised before any network work are permanent; for NetworkTlsError only the network-layer ECH failures are transient. TlsTrustError remains always-permanent by design — a trust-verification failure (bad CA, fingerprint mismatch, OCSP not-good, CT violation, an unreachable OCSP responder) must never be silently retried past the trust decision. **Fixed:** *DnsError / NetworkTlsError expose a correct terminal/transient signal; TlsTrustError stays terminal* — b.network.dns's DnsError was always-transient and b.network.tls's NetworkTlsError always-permanent, so err.permanent misled a consumer's retry loop in both directions — retrying a permanent DNS error (bad host / options / unsupported type / no-result) indefinitely, and never retrying a transient TLS network error (ECH connect failure, handshake timeout, DNS unavailable). err.permanent now reflects each error's actual transience by code and fails closed (unknown codes are permanent): DnsError is transient only for a failed network round-trip (dns/lookup-timeout, dns/resolve-failed, dns/reverse-failed, dns/doh-failed, dns/dot-failed, dns/dot-handshake-failed, dns/ddr-not-discovered, dns/system-failed), and permanent otherwise — including the caller-shape / environment errors raised before any network work (dns/transport-unavailable for an unconfigured transport, dns/dnr-no-resolvers for an empty/invalid resolver list, dns/setservers-failed for an invalid address, dns/no-system-resolvers when none are configured). NetworkTlsError is transient only for the network-layer ECH failures (tls/ech-connect-failed, tls/ech-timeout, tls/ech-dns-unavailable), permanent otherwise. TlsTrustError remains always-permanent so a trust-verification failure is never silently retried.
+
 - v0.15.27 (2026-06-25) — **Internal test-harness reliability only — the published library is byte-for-byte identical to 0.15.26.** The legacy single-layer smoke files used fixed-duration setTimeout sleeps to wait for asynchronous conditions (a job processed, a lease TTL lapsing, an audit flush completing). On a contended CI runner a fixed sleep is both flake-prone (too short under load) and slow (it always burns the full budget). Those condition-waits are converted to the harness's polling helpers — waitUntil for observable predicates, passiveObserve for deliberate real-time elapses, withTestTimeout for hang guards — which exit early on fast platforms and give contended platforms the full budget. No shipped framework code changed; this release is byte-for-byte identical to 0.15.26 for operators. **Fixed:** *Smoke layer files poll for conditions instead of fixed setTimeout sleeps* — The single-layer smoke files waited on asynchronous conditions with fixed-duration setTimeout sleeps, which flake under SMOKE_PARALLEL load and always burn their full budget. The condition-waits are converted to the polling helpers (waitUntil / passiveObserve / withTestTimeout) so they exit early on fast platforms and stay robust on contended ones; non-wait timers (abort triggers, child/socket watchdogs, simulated-latency mocks) are unchanged. This is test-harness reliability only — no shipped framework behavior changed.
 
 - v0.15.26 (2026-06-25) — **Internal test-harness correctness only — the published library is byte-for-byte identical to 0.15.25.** 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. **Fixed:** *Detached-IIFE tests now run their full assertion set under the smoke runner* — 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/network-dns.js

@@ -16,7 +16,34 @@ var validateOpts = require("./validate-opts");
 var { defineClass } = require("./framework-error");
 var { boundedMap } = require("./bounded-map");
 
-var DnsError = defineClass("DnsError", { alwaysPermanent: false });
+// DnsError carries a terminal-vs-transient signal on err.permanent so a caller
+// driving a retry loop knows which failures are worth re-attempting. Fail
+// CLOSED: only a failure of an actual network round-trip that a retry can
+// plausibly fix is transient (a lookup timeout, a resolve/reverse query that
+// failed on the wire, a DoH/DoT exchange that failed, a DDR discovery query that
+// found nothing). Everything else is permanent — bad config / options, an
+// unsupported query, a malformed or empty/NXDOMAIN-style reply, AND the
+// caller-shape / environment errors raised BEFORE any network work: requesting a
+// transport that was never configured (dns/transport-unavailable), an
+// empty/invalid designated-resolver list (dns/dnr-no-resolvers), an invalid
+// setServers address (dns/setservers-failed), or no system resolvers configured
+// (dns/no-system-resolvers). A retry cannot make invalid input or absent
+// configuration valid.
+var DNS_TRANSIENT_CODES = {
+  "dns/lookup-timeout":       true,
+  "dns/system-failed":        true,
+  "dns/resolve-failed":       true,
+  "dns/reverse-failed":       true,
+  "dns/doh-http":             true,
+  "dns/doh-failed":           true,
+  "dns/dot-handshake-failed": true,
+  "dns/dot-failed":           true,
+  "dns/ddr-not-discovered":   true,
+};
+function _dnsErrorIsPermanent(code) {
+  return !Object.prototype.hasOwnProperty.call(DNS_TRANSIENT_CODES, code);
+}
+var DnsError = defineClass("DnsError", { permanentClassifier: _dnsErrorIsPermanent });
 
 // Protocol-fixed byte counts and radixes — passthrough through C.BYTES
 // keeps every numeric literal routed through one helper.

package/lib/network-tls.js

@@ -16,8 +16,28 @@ var lazyRequire = require("./lazy-require");
 var safeAsync = require("./safe-async");
 var { defineClass } = require("./framework-error");
 
+// TlsTrustError is a TRUST-verification failure (bad CA/PEM, fingerprint
+// mismatch, OCSP not-good / revoked, CT violation, hostname/PKIX failure, an
+// unreachable OCSP responder). These are ALWAYS permanent: a caller must never
+// silently retry past a trust decision — a transient-looking OCSP-fetch failure
+// is the operator's soft-fail policy to make explicitly, not something a retry
+// loop should paper over. Fail closed.
 var TlsTrustError = defineClass("TlsTrustError", { alwaysPermanent: true });
-var NetworkTlsError = defineClass("NetworkTlsError", { alwaysPermanent: true });
+
+// NetworkTlsError carries a terminal-vs-transient signal on err.permanent. Fail
+// CLOSED: only the network-layer ECH failures a retry can plausibly fix (a
+// connect failure, a timeout, DNS being momentarily unavailable) are transient;
+// bad options, a malformed ECH config, and PKIX hostname/SAN validation failures
+// are permanent (config / validation errors a retry cannot fix).
+var TLS_TRANSIENT_CODES = {
+  "tls/ech-connect-failed": true,
+  "tls/ech-timeout":        true,
+  "tls/ech-dns-unavailable": true,
+};
+function _networkTlsErrorIsPermanent(code) {
+  return !Object.prototype.hasOwnProperty.call(TLS_TRANSIENT_CODES, code);
+}
+var NetworkTlsError = defineClass("NetworkTlsError", { permanentClassifier: _networkTlsErrorIsPermanent });
 
 var observability = lazyRequire(function () { return require("./observability"); });
 var audit = lazyRequire(function () { return require("./audit"); });

package/package.json

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

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:2b373536-53d6-476a-9d21-69b153ba2a17",
+  "serialNumber": "urn:uuid:1bbafc03-fa7f-407c-b852-9caa724d07c2",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-06-26T02:24:20.400Z",
+    "timestamp": "2026-06-26T06:34:07.791Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.15.27",
+      "bom-ref": "@blamejs/core@0.15.28",
       "type": "application",
       "name": "blamejs",
-      "version": "0.15.27",
+      "version": "0.15.28",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.15.27",
+      "purl": "pkg:npm/%40blamejs/core@0.15.28",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.15.27",
+      "ref": "@blamejs/core@0.15.28",
       "dependsOn": []
     }
   ]