@blamejs/blamejs-shop 0.5.12 → 0.5.13

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

@@ -46,6 +46,77 @@ function _rsaPair() {
   });
 }
 
+// ---- shared fixtures for the branch/error coverage below ----
+
+// One RSA keypair reused across the RS256 mint/verify branch tests — RSA
+// generation is the slow step and none of the branches under test depend
+// on key uniqueness.
+var _sharedRsaKp = null;
+function _rsaKp() {
+  if (!_sharedRsaKp) {
+    _sharedRsaKp = nodeCrypto.generateKeyPairSync("rsa", { modulusLength: 2048 });  // allow:raw-byte-literal — RSA modulus bits
+  }
+  return _sharedRsaKp;
+}
+
+// Public JWK for the shared RSA key, optionally tagged with a kid.
+function _rsaPubJwk(kid) {
+  var jwk = _rsaKp().publicKey.export({ format: "jwk" });
+  if (kid) jwk.kid = kid;
+  return jwk;
+}
+
+// Public EC JWK on a named curve, optionally tagged with a kid.
+function _ecJwk(curve, kid) {
+  var kp = nodeCrypto.generateKeyPairSync("ec", { namedCurve: curve });
+  var jwk = kp.publicKey.export({ format: "jwk" });
+  if (kid) jwk.kid = kid;
+  return jwk;
+}
+
+// Mint a valid RS256 JWS over `claims` with the shared RSA key via the real
+// signer (b.auth.jws.sign derives RS256 from the RSA key type).
+function _mintRs256(claims, kid) {
+  var opts = { privateKey: _rsaKp().privateKey };
+  if (kid) opts.kid = kid;
+  return b.auth.jws.sign(claims, opts);
+}
+
+// An unsigned 3-part token — the signature segment is a placeholder for
+// branches that fail BEFORE signature verification (alg / kid / kty / decode
+// gates), so the signature bytes are never inspected.
+function _unsigned(header, payload) {
+  return _b64url(JSON.stringify(header)) + "." +
+         _b64url(JSON.stringify(payload)) + "." + _b64url("sig");
+}
+
+// Wrap a fixed value in a keyResolver (keeps the closure out of a loop body).
+function _constResolver(v) { return function () { return v; }; }
+
+// Seconds-since-epoch anchor for building exp / nbf / iat claims.
+var _nowSec = Math.floor(Date.now() / 1000);                                     // allow:raw-byte-literal — seconds-per-ms
+
+// Assert verifyExternal rejects `token` under `opts` with a code matching `re`.
+async function _expectCode(label, token, opts, re) {
+  var threw = null;
+  try { await b.auth.jwt.verifyExternal(token, opts); }
+  catch (e) { threw = e; }
+  check(label, threw && re.test(threw.code || ""));
+}
+
+// Assert jws.sign rejects `claims`/`opts` with a code matching `re`.
+function _expectSignCode(label, claims, opts, re) {
+  var threw = null;
+  try { b.auth.jws.sign(claims, opts); }
+  catch (e) { threw = e; }
+  check(label, threw && re.test(threw.code || ""));
+}
+
+// Read the protected-header `alg` from a compact JWS.
+function _hdrAlg(jws) {
+  return JSON.parse(Buffer.from(jws.split(".")[0], "base64url").toString("utf8")).alg;
+}
+
 function testSurface() {
   check("auth.jwt.verifyExternal exposed",
         typeof b.auth.jwt.verifyExternal === "function");
@@ -239,6 +310,203 @@ async function testJwsSignB64CritRefused() {
         e3 && /sign-unsupported-header/.test(e3.code || ""));
 }
 
+// ---- verifyExternal: token pre-flight rejections ----
+// Everything refused before key resolution: bad token type/size, an
+// operator alg outside the supported set, a JWE on the JWS verifier, a
+// non-3-segment token, an undecodable header, a header missing alg, a crit
+// header, and a token alg absent from the operator's allowed list.
+async function testTokenPreflight() {
+  var jwk = _rsaPubJwk("k1");
+  await _expectCode("empty token → no-token",
+    "", { algorithms: ["RS256"], jwks: [jwk] }, /no-token/);
+  var threw = null;
+  try { await b.auth.jwt.verifyExternal(12345, { algorithms: ["RS256"], jwks: [jwk] }); }
+  catch (e) { threw = e; }
+  check("non-string token → no-token", threw && /no-token/.test(threw.code || ""));
+  await _expectCode("oversized token → token-too-large",
+    "a".repeat(17000), { algorithms: ["RS256"], jwks: [jwk] }, /token-too-large/);          // allow:raw-byte-literal — exceeds 16 KiB token cap
+  await _expectCode("operator lists an unsupported alg → unsupported-alg",
+    "a.b.c", { algorithms: ["RS999"], jwks: [jwk] }, /unsupported-alg/);
+  await _expectCode("5-segment JWE token → jwe-refused",
+    "a.b.c.d.e", { algorithms: ["RS256"], jwks: [jwk] }, /jwe-refused/);
+  await _expectCode("2-segment token → malformed-jwt",
+    "a.b", { algorithms: ["RS256"], jwks: [jwk] }, /malformed-jwt/);
+  await _expectCode("header decodes to non-JSON → malformed-jwt",
+    _b64url("not json") + "." + _b64url("{}") + "." + _b64url("sig"),
+    { algorithms: ["RS256"], jwks: [jwk] }, /malformed-jwt/);
+  await _expectCode("header missing alg → malformed-jwt",
+    _unsigned({ typ: "JWT" }, { exp: _nowSec + 300 }),                                       // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [jwk] }, /malformed-jwt/);
+  await _expectCode("crit header → unknown-crit",
+    _unsigned({ alg: "RS256", kid: "k1", crit: ["exp"] }, { exp: _nowSec + 300 }),           // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [jwk] }, /unknown-crit/);
+  await _expectCode("token alg supported but not in allowed list → alg-not-allowed",
+    _unsigned({ alg: "RS384", kid: "k1" }, { exp: _nowSec + 300 }),                          // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [jwk] }, /alg-not-allowed/);
+}
+
+// ---- verifyExternal: JWKS kid resolution ----
+// Empty JWKS, no-matching-kid, and the kid-less refusal (default) vs the
+// allowKidlessJwks opt-in that accepts a lone-key JWKS.
+async function testKidResolution() {
+  var jwkK1 = _rsaPubJwk("k1");
+  await _expectCode("empty JWKS array → no-jwks-keys",
+    _unsigned({ alg: "RS256", kid: "k1" }, { exp: _nowSec + 300 }),                          // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [] }, /no-jwks-keys/);
+  await _expectCode("kid with no matching JWKS key → no-matching-kid",
+    _unsigned({ alg: "RS256", kid: "absent" }, { exp: _nowSec + 300 }),                      // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [jwkK1] }, /no-matching-kid/);
+  await _expectCode("kid-less token, multi-key JWKS → kid-required",
+    _unsigned({ alg: "RS256" }, { exp: _nowSec + 300 }),                                     // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [jwkK1, _rsaPubJwk("k2")] }, /kid-required/);
+  await _expectCode("kid-less token, single-key JWKS, no opt-in → kid-required",
+    _unsigned({ alg: "RS256" }, { exp: _nowSec + 300 }),                                     // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [_rsaPubJwk()] }, /kid-required/);
+  var rv = await b.auth.jwt.verifyExternal(
+    _mintRs256({ sub: "u1", exp: _nowSec + 300 }),                                           // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [_rsaPubJwk()], allowKidlessJwks: true });
+  check("kid-less single-key JWKS + allowKidlessJwks → verifies", rv.claims.sub === "u1");
+}
+
+// ---- verifyExternal: CVE-2026-22817 alg↔kty/crv cross-check ----
+// The resolved JWK's key type must match the header alg BEFORE it is handed
+// to node:crypto: a missing kty, an RSA alg over an EC key, and an ES256 alg
+// over a P-384 key are each refused.
+async function testAlgKtyCrossCheck() {
+  await _expectCode("resolved JWK without kty → bad-jwk",
+    _unsigned({ alg: "RS256", kid: "k1" }, { exp: _nowSec + 300 }),                          // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [{ kid: "k1" }] }, /bad-jwk/);
+  await _expectCode("alg RS256 over an EC JWK → alg-kty-mismatch",
+    _unsigned({ alg: "RS256", kid: "k1" }, { exp: _nowSec + 300 }),                          // allow:raw-byte-literal — 5min
+    { algorithms: ["RS256"], jwks: [_ecJwk("P-256", "k1")] }, /alg-kty-mismatch/);
+  await _expectCode("alg ES256 over a P-384 JWK → alg-crv-mismatch",
+    _unsigned({ alg: "ES256", kid: "k1" }, { exp: _nowSec + 300 }),                          // allow:raw-byte-literal — 5min
+    { algorithms: ["ES256"], jwks: [_ecJwk("P-384", "k1")] }, /alg-crv-mismatch/);
+}
+
+// ---- verifyExternal: signature rejection ----
+// A byte-flipped signature over an otherwise-valid RS256 token fails
+// verification.
+async function testSignatureVerification() {
+  var token = _mintRs256({ sub: "u1", exp: _nowSec + 300 }, "k1");                           // allow:raw-byte-literal — 5min
+  var parts = token.split(".");
+  // Invert the first signature byte — a leading byte carries meaningful
+  // bits (unlike a trailing base64url char, whose low bits are padding and
+  // can round-trip unchanged), so the tamper is deterministic.
+  var sigBuf = Buffer.from(parts[2], "base64url");
+  sigBuf[0] = sigBuf[0] ^ 0xff;
+  var tampered = parts[0] + "." + parts[1] + "." + _b64url(sigBuf);
+  await _expectCode("tampered signature → invalid-signature",
+    tampered, { algorithms: ["RS256"], jwks: [_rsaPubJwk("k1")] }, /invalid-signature/);
+}
+
+// ---- verifyExternal: claim validation ----
+// exp/nbf/iat time gates, the iss cross-realm refusal (including the
+// array-iss CVE-2025-30144 shape and a missing iss), the sub-equality check,
+// and the clockSkewMs handling — a finite skew tolerates a just-expired
+// token while Infinity is refused rather than silently disabling expiry.
+async function testClaimValidation() {
+  var jwk = _rsaPubJwk("k1");
+  await _expectCode("missing exp claim → missing-exp",
+    _mintRs256({ sub: "u1" }, "k1"),
+    { algorithms: ["RS256"], jwks: [jwk] }, /missing-exp/);
+  await _expectCode("nbf in the future → nbf-future",
+    _mintRs256({ sub: "u1", exp: _nowSec + 7200, nbf: _nowSec + 3600 }, "k1"),               // allow:raw-byte-literal — 2h/1h in seconds
+    { algorithms: ["RS256"], jwks: [jwk], now: Date.now() }, /nbf-future/);
+  await _expectCode("iat in the future → iat-future",
+    _mintRs256({ sub: "u1", exp: _nowSec + 7200, iat: _nowSec + 3600 }, "k1"),               // allow:raw-byte-literal — 2h/1h in seconds
+    { algorithms: ["RS256"], jwks: [jwk] }, /iat-future/);
+  await _expectCode("issuer mismatch → iss-mismatch",
+    _mintRs256({ sub: "u1", exp: _nowSec + 3600, iss: "https://evil.example" }, "k1"),       // allow:raw-byte-literal — 1h
+    { algorithms: ["RS256"], jwks: [jwk], issuer: "https://idp.example.com" }, /iss-mismatch/);
+  await _expectCode("array-valued iss refused → iss-mismatch",
+    _mintRs256({ sub: "u1", exp: _nowSec + 3600, iss: ["https://idp.example.com", "x"] }, "k1"),  // allow:raw-byte-literal — 1h
+    { algorithms: ["RS256"], jwks: [jwk], issuer: "https://idp.example.com" }, /iss-mismatch/);
+  await _expectCode("missing iss when issuer expected → iss-mismatch",
+    _mintRs256({ sub: "u1", exp: _nowSec + 3600 }, "k1"),                                    // allow:raw-byte-literal — 1h
+    { algorithms: ["RS256"], jwks: [jwk], issuer: "https://idp.example.com" }, /iss-mismatch/);
+  await _expectCode("subject mismatch → sub-mismatch",
+    _mintRs256({ sub: "u1", exp: _nowSec + 3600 }, "k1"),                                    // allow:raw-byte-literal — 1h
+    { algorithms: ["RS256"], jwks: [jwk], subject: "someone-else" }, /sub-mismatch/);
+  var tolerated = await b.auth.jwt.verifyExternal(
+    _mintRs256({ sub: "u1", exp: _nowSec - 10 }, "k1"),                                      // allow:raw-byte-literal — 10s past
+    { algorithms: ["RS256"], jwks: [jwk], clockSkewMs: 60000 });                             // allow:raw-byte-literal — 60s skew in ms
+  check("finite clockSkewMs tolerates a just-expired token", tolerated.claims.sub === "u1");
+  await _expectCode("Infinity clockSkewMs refused (cannot disable expiry) → bad-clock-skew",
+    _mintRs256({ sub: "u1", exp: _nowSec - 3600 }, "k1"),                                    // allow:raw-byte-literal — 1h past
+    { algorithms: ["RS256"], jwks: [jwk], clockSkewMs: Infinity }, /bad-clock-skew/);
+}
+
+// ---- verifyExternal: keyResolver value shapes ----
+// A keyResolver may return a KeyObject, a public JWK, a PEM string, or a PEM
+// Buffer — each imports and verifies. (PEM / KeyObject / Buffer carry no kty
+// surface so the alg↔kty cross-check applies to the JWK shape only.)
+async function testKeyResolverShapes() {
+  var kp = _rsaKp();
+  var pubPem = kp.publicKey.export({ type: "spki", format: "pem" });
+  var token = _mintRs256({ sub: "u1", exp: _nowSec + 300 }, "k1");                           // allow:raw-byte-literal — 5min
+  var shapes = [
+    { name: "KeyObject",  val: kp.publicKey },
+    { name: "public JWK", val: kp.publicKey.export({ format: "jwk" }) },
+    { name: "PEM string", val: pubPem },
+    { name: "PEM Buffer", val: Buffer.from(pubPem) },
+  ];
+  for (var i = 0; i < shapes.length; i++) {
+    var rv = await b.auth.jwt.verifyExternal(token, {
+      algorithms:  ["RS256"],
+      keyResolver: _constResolver(shapes[i].val),
+    });
+    check("keyResolver returns " + shapes[i].name + " → verifies", rv.claims.sub === "u1");
+  }
+}
+
+// ---- verifyExternal: keyResolver rejections ----
+async function testKeyResolverRejections() {
+  var token = _unsigned({ alg: "RS256" }, { exp: _nowSec + 300 });                           // allow:raw-byte-literal — 5min
+  await _expectCode("keyResolver returns null → no-key",
+    token, { algorithms: ["RS256"], keyResolver: _constResolver(null) }, /no-key/);
+  await _expectCode("keyResolver returns a non-key value → bad-key-shape",
+    token, { algorithms: ["RS256"], keyResolver: _constResolver(42) }, /bad-key-shape/);
+  await _expectCode("keyResolver throws → key-resolver-failed",
+    token, { algorithms: ["RS256"], keyResolver: function () { throw new Error("boom"); } },
+    /key-resolver-failed/);
+  await _expectCode("keyResolver returns unparseable PEM string → bad-pem",
+    token, { algorithms: ["RS256"], keyResolver: _constResolver("not-a-pem") }, /bad-pem/);
+  await _expectCode("keyResolver returns unparseable PEM Buffer → bad-pem",
+    token, { algorithms: ["RS256"], keyResolver: _constResolver(Buffer.from("not-a-pem")) },
+    /bad-pem/);
+}
+
+// ---- jws.sign: key import + alg-derivation branches ----
+// The private-key importer (missing / unparseable / non-key / JWK) and the
+// alg resolver (default-from-key for rsa-pss, unsupported EC curve, non-JWS
+// key type, an explicit non-classical alg, and an explicit compatible alg).
+async function testJwsSignKeyImport() {
+  _expectSignCode("jws.sign: missing privateKey → sign-no-key",
+    { sub: "u" }, {}, /sign-no-key/);
+  _expectSignCode("jws.sign: unparseable PEM key → sign-bad-key",
+    { sub: "u" }, { privateKey: "not-a-pem" }, /sign-bad-key/);
+  _expectSignCode("jws.sign: non-key value → sign-bad-key",
+    { sub: "u" }, { privateKey: 12345 }, /sign-bad-key/);
+  var ec = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
+  check("jws.sign: private JWK accepted, derives ES256",
+    _hdrAlg(b.auth.jws.sign({ sub: "u" }, { privateKey: ec.privateKey.export({ format: "jwk" }) })) === "ES256");
+  _expectSignCode("jws.sign: EC secp256k1 has no JWS alg → sign-key-unsupported",
+    { sub: "u" },
+    { privateKey: nodeCrypto.generateKeyPairSync("ec", { namedCurve: "secp256k1" }).privateKey },
+    /sign-key-unsupported/);
+  var pss = nodeCrypto.generateKeyPairSync("rsa-pss", { modulusLength: 2048 });              // allow:raw-byte-literal — RSA modulus bits
+  check("jws.sign: rsa-pss key defaults to PS256",
+    _hdrAlg(b.auth.jws.sign({ sub: "u" }, { privateKey: pss.privateKey })) === "PS256");
+  _expectSignCode("jws.sign: x25519 (non-signing) key → sign-key-unsupported",
+    { sub: "u" }, { privateKey: nodeCrypto.generateKeyPairSync("x25519").privateKey },
+    /sign-key-unsupported/);
+  _expectSignCode("jws.sign: explicit non-classical alg → sign-alg-unsupported",
+    { sub: "u" }, { privateKey: _rsaKp().privateKey, alg: "ML-DSA-65" }, /sign-alg-unsupported/);
+  check("jws.sign: explicit compatible alg RS512 honored",
+    _hdrAlg(b.auth.jws.sign({ sub: "u" }, { privateKey: _rsaKp().privateKey, alg: "RS512" })) === "RS512");
+}
+
 async function run() {
   testSurface();
   await testAlgorithmsRequired();
@@ -253,6 +521,14 @@ async function run() {
   await testJwsSignRefusals();
   await testJwsSignHeaderCannotOverrideAlg();
   await testJwsSignB64CritRefused();
+  await testTokenPreflight();
+  await testKidResolution();
+  await testAlgKtyCrossCheck();
+  await testSignatureVerification();
+  await testClaimValidation();
+  await testKeyResolverShapes();
+  await testKeyResolverRejections();
+  await testJwsSignKeyImport();
 }
 
 module.exports = { run: run };

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

@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+/**
+ * b.logStream — dispatcher introspection (listSinks), the debug level
+ * wrapper, and env-driven boot (bootFromEnv).
+ *
+ * Run standalone: `node test/layer-0-primitives/log-stream.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b     = helpers.b;
+var check = helpers.check;
+var fs    = helpers.fs;
+var os    = helpers.os;
+var path  = helpers.path;
+
+var OTLP_URL = "https://collector.example.com:4318/v1/logs";
+
+function _resetLogStream() { b.logStream._resetForTest(); }
+function _mkTmp() { return fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-logstream-")); }
+function _rmTmp(dir) { try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) { /* best effort */ } }
+
+// ---- listSinks ----
+
+function testListSinksEmptyBeforeInit() {
+  _resetLogStream();
+  var snap = b.logStream.listSinks();
+  check("logStream.listSinks: returns [] before init (health endpoints call it unconditionally)",
+        Array.isArray(snap) && snap.length === 0);
+}
+
+async function testListSinksReportsConfiguredSinks() {
+  _resetLogStream();
+  var dir = _mkTmp();
+  try {
+    b.logStream.init({
+      minLevel: "info",
+      sinks: {
+        file:   { protocol: "local", dir: dir },
+        remote: { protocol: "otlp",  url: OTLP_URL, serviceName: "checkout" },
+      },
+    });
+    var snap = b.logStream.listSinks();
+    check("listSinks: one descriptor per configured sink", snap.length === 2);
+    var byName = {};
+    snap.forEach(function (d) { byName[d.name] = d; });
+    check("listSinks: descriptor carries name + protocol (local)",
+          byName.file && byName.file.protocol === "local");
+    check("listSinks: a sink without a stats() method reports stats: null",
+          byName.file.stats === null);
+    check("listSinks: descriptor carries name + protocol (otlp)",
+          byName.remote && byName.remote.protocol === "otlp");
+    check("listSinks: a sink exposing stats() reports through it",
+          byName.remote.stats && typeof byName.remote.stats === "object" &&
+          byName.remote.stats.url === OTLP_URL);
+  } finally {
+    await b.logStream.shutdown();
+    _resetLogStream();
+    _rmTmp(dir);
+  }
+}
+
+// ---- debug ----
+
+async function testDebugEmitsWhenMinLevelDebug() {
+  _resetLogStream();
+  var dir = _mkTmp();
+  try {
+    b.logStream.init({ minLevel: "debug", sinks: { file: { protocol: "local", dir: dir } } });
+    b.logStream.debug("cache lookup", { shard: 3, hit: false });
+    await b.logStream.shutdown();   // drains in-flight fire-and-forget emits before close
+    var body = fs.readFileSync(path.join(dir, "blamejs.log"), "utf8");
+    var rows = body.trim().split("\n").filter(Boolean).map(function (l) { return JSON.parse(l); });
+    check("logStream.debug: record reaches the sink at minLevel debug", rows.length === 1);
+    check("logStream.debug: record level is 'debug'", rows[0].level === "debug");
+    check("logStream.debug: message preserved", rows[0].message === "cache lookup");
+    check("logStream.debug: non-sensitive meta preserved through redaction", rows[0].meta.shard === 3);
+  } finally {
+    _resetLogStream();
+    _rmTmp(dir);
+  }
+}
+
+async function testDebugDroppedBelowDefaultMinLevel() {
+  _resetLogStream();
+  var dir = _mkTmp();
+  try {
+    // Default minLevel is "info" — debug records drop before the sink.
+    b.logStream.init({ sinks: { file: { protocol: "local", dir: dir } } });
+    b.logStream.debug("debug-should-drop", { shard: 1 });
+    b.logStream.info("info-should-keep", { shard: 2 });
+    await b.logStream.shutdown();
+    var body = fs.readFileSync(path.join(dir, "blamejs.log"), "utf8");
+    check("logStream.debug: dropped below default minLevel (never written)",
+          body.indexOf("debug-should-drop") === -1);
+    check("logStream.debug: sibling info at/above minLevel is written",
+          body.indexOf("info-should-keep") !== -1);
+  } finally {
+    _resetLogStream();
+    _rmTmp(dir);
+  }
+}
+
+// ---- bootFromEnv ----
+
+function testBootFromEnvSkipsWhenProtocolUnset() {
+  _resetLogStream();
+  var wired = b.logStream.bootFromEnv({ env: {} });
+  check("logStream.bootFromEnv: returns false when BLAMEJS_LOG_STREAM_PROTOCOL unset", wired === false);
+  check("logStream.bootFromEnv: no sink wired on skip", b.logStream.listSinks().length === 0);
+  _resetLogStream();
+}
+
+async function testBootFromEnvWiresSinkFromProcessEnv() {
+  _resetLogStream();
+  // Exercise the default process.env branch (no opts.env). Snapshot the
+  // exact keys touched and restore them in finally so the test leaks no env.
+  var KEYS = [
+    "BLAMEJS_LOG_STREAM_PROTOCOL",
+    "BLAMEJS_LOG_STREAM_URL",
+    "BLAMEJS_LOG_STREAM_SERVICE_NAME",
+    "BLAMEJS_LOG_STREAM_MIN_LEVEL",
+  ];
+  var saved = {};
+  KEYS.forEach(function (k) { saved[k] = process.env[k]; });
+  try {
+    process.env.BLAMEJS_LOG_STREAM_PROTOCOL     = "otlp";
+    process.env.BLAMEJS_LOG_STREAM_URL          = OTLP_URL;
+    process.env.BLAMEJS_LOG_STREAM_SERVICE_NAME = "checkout";
+    process.env.BLAMEJS_LOG_STREAM_MIN_LEVEL    = "info";
+
+    var wired = b.logStream.bootFromEnv();   // reads process.env
+    check("bootFromEnv: returns true when protocol set", wired === true);
+    var snap = b.logStream.listSinks();
+    check("bootFromEnv: wires exactly one sink named 'primary'",
+          snap.length === 1 && snap[0].name === "primary");
+    check("bootFromEnv: sink protocol matches env", snap[0].protocol === "otlp");
+    check("bootFromEnv: otlp sink carries the configured URL",
+          snap[0].stats && snap[0].stats.url === OTLP_URL);
+  } finally {
+    await b.logStream.shutdown();
+    KEYS.forEach(function (k) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    });
+    _resetLogStream();
+  }
+}
+
+async function testBootFromEnvWiresLocalSinkEndToEnd() {
+  _resetLogStream();
+  var dir = _mkTmp();
+  try {
+    // The local sink is directory-based; BLAMEJS_LOG_STREAM_PATH names that
+    // directory. bootFromEnv must map it to the sink's `dir` config so the
+    // documented `local` protocol actually wires (not throw at init).
+    var wired = b.logStream.bootFromEnv({
+      env: {
+        BLAMEJS_LOG_STREAM_PROTOCOL:  "local",
+        BLAMEJS_LOG_STREAM_PATH:      dir,
+        BLAMEJS_LOG_STREAM_MIN_LEVEL: "debug",
+      },
+    });
+    check("bootFromEnv: local protocol wires a sink from BLAMEJS_LOG_STREAM_PATH", wired === true);
+    var snap = b.logStream.listSinks();
+    check("bootFromEnv: local sink registered", snap.length === 1 && snap[0].protocol === "local");
+
+    b.logStream.info("boot-from-env-local", { shard: 7 });
+    await b.logStream.shutdown();
+    var body = fs.readFileSync(path.join(dir, "blamejs.log"), "utf8");
+    check("bootFromEnv: the env-wired local sink actually wrote the record",
+          body.indexOf("boot-from-env-local") !== -1);
+  } finally {
+    _resetLogStream();
+    _rmTmp(dir);
+  }
+}
+
+function testBootFromEnvThrowsUnknownProtocol() {
+  _resetLogStream();
+  var threw = null;
+  try { b.logStream.bootFromEnv({ env: { BLAMEJS_LOG_STREAM_PROTOCOL: "kafka" } }); }
+  catch (e) { threw = e; }
+  check("bootFromEnv: unknown protocol throws a loud boot error",
+        threw && /not one of/.test(threw.message));
+  _resetLogStream();
+}
+
+// #493 — emit() must redact secrets embedded in the free-text `message`, not
+// just structured `meta`. And it must scrub an EMBEDDED token in a longer
+// string (the built-in ^…$-anchored value detectors miss those) while keeping
+// the surrounding message.
+async function testMessageRedactionScrubsEmbeddedSecrets() {
+  _resetLogStream();
+  var dir = _mkTmp();
+  try {
+    b.logStream.init({ sinks: { file: { protocol: "local", dir: dir } } });
+    // Direct coverage of the primitive (in addition to the via-emit path below).
+    check("redact.redactText scrubs an embedded AWS key, keeps surrounding text",
+      b.redact.redactText("k=AKIAIOSFODNN7EXAMPLE done").indexOf("AKIAIOSFODNN7EXAMPLE") === -1 &&
+      b.redact.redactText("k=AKIAIOSFODNN7EXAMPLE done").indexOf("done") !== -1);
+    b.logStream.error("eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJib2IifQ.c2lnbmF0dXJl"); // bare JWT
+    b.logStream.warn("checkout retry with token=AKIAIOSFODNN7EXAMPLE for order 42"); // embedded AWS key
+    b.logStream.info("db connect postgres://app:s3cr3tPASS@db.internal:5432/app"); // URL-embedded password
+    await b.logStream.shutdown();
+    var body = fs.readFileSync(path.join(dir, "blamejs.log"), "utf8");
+    check("logStream: a JWT in the message is redacted",
+      body.indexOf("eyJhbGciOiJIUzI1NiJ9") === -1);
+    check("logStream: an embedded AWS key is redacted while surrounding text is kept",
+      body.indexOf("AKIAIOSFODNN7EXAMPLE") === -1 &&
+      body.indexOf("checkout retry") !== -1 && body.indexOf("order 42") !== -1);
+    check("logStream: a URL-embedded password is redacted while the rest is kept",
+      body.indexOf("s3cr3tPASS") === -1 && body.indexOf("db connect") !== -1);
+  } finally {
+    _resetLogStream();
+    _rmTmp(dir);
+  }
+}
+
+async function run() {
+  testListSinksEmptyBeforeInit();
+  await testListSinksReportsConfiguredSinks();
+  await testDebugEmitsWhenMinLevelDebug();
+  await testDebugDroppedBelowDefaultMinLevel();
+  testBootFromEnvSkipsWhenProtocolUnset();
+  await testBootFromEnvWiresSinkFromProcessEnv();
+  await testBootFromEnvWiresLocalSinkEndToEnd();
+  testBootFromEnvThrowsUnknownProtocol();
+  await testMessageRedactionScrubsEmbeddedSecrets();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("log-stream tests passed"); process.exit(0); },
+    function (e) { console.error(e); process.exit(1); }
+  );
+}

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

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+/**
+ * b.log.makeViaOrFallback — operator-log routing closure that falls
+ * back to a per-module logger when the operator didn't pass one.
+ *
+ * Run standalone: `node test/layer-0-primitives/log.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b     = helpers.b;
+var check = helpers.check;
+
+// A recording fallback logger with the boot()-shape surface
+// (info/warn/error take a single pre-formatted line).
+function _recordingFallback() {
+  var lines = [];
+  return {
+    lines: lines,
+    info:  function (line) { lines.push(["info",  line]); },
+    warn:  function (line) { lines.push(["warn",  line]); },
+    error: function (line) { lines.push(["error", line]); },
+  };
+}
+
+function testFallbackFiresWhenOperatorLogAbsent() {
+  var fb = _recordingFallback();
+  var via = b.log.makeViaOrFallback(null, fb);
+  via("error", "build-failed", { reason: "missing entrypoint" });
+  check("makeViaOrFallback: routes to fallback.error with a formatted line",
+        fb.lines.length === 1 &&
+        fb.lines[0][0] === "error" &&
+        fb.lines[0][1] === 'build-failed {"reason":"missing entrypoint"}');
+}
+
+function testFallbackLevelMapping() {
+  var fb = _recordingFallback();
+  var via = b.log.makeViaOrFallback(null, fb);
+  via("warn", "warned");                 // → fallback.warn
+  via("info", "informed");               // → fallback.info
+  via("fatal", "fatal-line");            // fatal + error both route to fallback.error
+  check("makeViaOrFallback: warn → fallback.warn", fb.lines[0][0] === "warn" && fb.lines[0][1] === "warned");
+  check("makeViaOrFallback: info → fallback.info", fb.lines[1][0] === "info" && fb.lines[1][1] === "informed");
+  check("makeViaOrFallback: fatal maps to fallback.error", fb.lines[2][0] === "error" && fb.lines[2][1] === "fatal-line");
+}
+
+function testOperatorLogWinsWhenLevelPresent() {
+  var fb = _recordingFallback();
+  var opCalls = [];
+  var operatorLog = { error: function (message, fields) { opCalls.push([message, fields]); } };
+  var via = b.log.makeViaOrFallback(operatorLog, fb);
+  via("error", "op-msg", { a: 1 });
+  check("makeViaOrFallback: operator log receives (message, fields) verbatim",
+        opCalls.length === 1 && opCalls[0][0] === "op-msg" && opCalls[0][1].a === 1);
+  check("makeViaOrFallback: fallback NOT called when operator handles the level",
+        fb.lines.length === 0);
+}
+
+function testFallbackFiresWhenOperatorMissingLevel() {
+  var fb = _recordingFallback();
+  // Operator log exposes only info(); an error() call must fall back.
+  var operatorLog = { info: function () {} };
+  var via = b.log.makeViaOrFallback(operatorLog, fb);
+  via("error", "no-operator-error-method");
+  check("makeViaOrFallback: falls back when operator lacks the requested level",
+        fb.lines.length === 1 && fb.lines[0][0] === "error" &&
+        fb.lines[0][1] === "no-operator-error-method");
+}
+
+function testOperatorLogThrowIsSwallowed() {
+  var fb = _recordingFallback();
+  var operatorLog = { error: function () { throw new Error("operator log blew up"); } };
+  var via = b.log.makeViaOrFallback(operatorLog, fb);
+  var threw = null;
+  try { via("error", "boom"); } catch (e) { threw = e; }
+  check("makeViaOrFallback: a throwing operator log is swallowed (best-effort)", threw === null);
+  check("makeViaOrFallback: no fallback double-emit after operator log threw", fb.lines.length === 0);
+}
+
+function testMessageWithoutFieldsFormatsBareLine() {
+  var fb = _recordingFallback();
+  var via = b.log.makeViaOrFallback(null, fb);
+  via("info", "no-fields-here");   // no fields arg → line is the message verbatim
+  check("makeViaOrFallback: a fields-less call formats the bare message",
+        fb.lines.length === 1 && fb.lines[0][1] === "no-fields-here");
+}
+
+async function run() {
+  testFallbackFiresWhenOperatorLogAbsent();
+  testFallbackLevelMapping();
+  testOperatorLogWinsWhenLevelPresent();
+  testFallbackFiresWhenOperatorMissingLevel();
+  testOperatorLogThrowIsSwallowed();
+  testMessageWithoutFieldsFormatsBareLine();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("log tests passed"); process.exit(0); },
+    function (e) { console.error(e); process.exit(1); }
+  );
+}