@blamejs/blamejs-shop 0.5.12 → 0.5.13

package/lib/vendor/blamejs/test/00-primitives.js

@@ -1966,6 +1966,223 @@ async function testAuthDpopPqcMlDsa() {
   check("ML-DSA-87 jwk.alg=ML-DSA-87",          rv.header.jwk.alg === "ML-DSA-87");
 }
 
+// DPoP verify/buildProof adversarial + error-branch coverage. These drive
+// the public b.auth.dpop surface an operator calls (buildProof / verify /
+// thumbprint) through every documented failure mode: malformed / oversize /
+// omitted-required-opt input, header-level refusals (typ / alg / jwk / crit),
+// signature tampering, payload-claim omissions, nonce binding, replay-store
+// shape, buildProof input validation, and thumbprint kty gating.
+
+function _dpopB64url(x) {
+  return Buffer.from(x).toString("base64")
+    .replace(/=+$/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+
+// Craft a proof segment triple with a caller-supplied header/payload and a
+// throwaway signature — for the verify branches that run BEFORE the signature
+// is checked (typ / alg / jwk / crit / structural malformation).
+function _dpopCraft(header, payload, sig) {
+  return _dpopB64url(JSON.stringify(header)) + "." +
+         _dpopB64url(JSON.stringify(payload)) + "." + (sig || "AA");
+}
+
+// Sign a caller-supplied header+payload with a real P-256 key (ES256,
+// ieee-p1363 like the framework emits) — for the payload-claim branches that
+// run AFTER signature verification, so they must reach a genuinely valid sig.
+function _dpopSignES256(privateKey, header, payload) {
+  var nodeCrypto = require("crypto");
+  var si = _dpopB64url(JSON.stringify(header)) + "." + _dpopB64url(JSON.stringify(payload));
+  var sig = nodeCrypto.sign("sha256", Buffer.from(si, "ascii"),
+    { key: privateKey, dsaEncoding: "ieee-p1363" });
+  return si + "." + _dpopB64url(sig);
+}
+
+async function testAuthDpopVerifyMalformedInputs() {
+  var d = b.auth.dpop;
+  var o = { htm: "GET", htu: "https://x/y" };
+  async function code(proof, opts) {
+    try { await d.verify(proof, opts); return null; }
+    catch (e) { return e && e.code; }
+  }
+
+  check("dpop.verify: empty proof → auth-dpop/no-proof",
+        (await code("", o)) === "auth-dpop/no-proof");
+  check("dpop.verify: non-string proof → auth-dpop/no-proof",
+        (await code(null, o)) === "auth-dpop/no-proof");
+  check("dpop.verify: oversize proof → auth-dpop/proof-too-large",
+        (await code("x".repeat(96 * 1024 + 1), o)) === "auth-dpop/proof-too-large");
+  check("dpop.verify: omitted opts.htm → auth-dpop/bad-htm",
+        (await code("a.b.c", { htu: "https://x/y" })) === "auth-dpop/bad-htm");
+  check("dpop.verify: omitted opts.htu → auth-dpop/bad-htu",
+        (await code("a.b.c", { htm: "GET" })) === "auth-dpop/bad-htu");
+  check("dpop.verify: iatWindowSec<=0 → auth-dpop/bad-iat-window",
+        (await code("a.b.c", { htm: "GET", htu: "https://x/y", iatWindowSec: 0 })) === "auth-dpop/bad-iat-window");
+  check("dpop.verify: non-finite iatWindowSec → auth-dpop/bad-iat-window",
+        (await code("a.b.c", { htm: "GET", htu: "https://x/y", iatWindowSec: Infinity })) === "auth-dpop/bad-iat-window");
+  check("dpop.verify: wrong dot-part count → auth-dpop/malformed",
+        (await code("a.b", o)) === "auth-dpop/malformed");
+  check("dpop.verify: header not base64url-JSON → auth-dpop/malformed",
+        (await code(_dpopB64url("not json") + "." + _dpopB64url("{}") + ".AA", o)) === "auth-dpop/malformed");
+  check("dpop.verify: payload not base64url-JSON → auth-dpop/malformed",
+        (await code(_dpopB64url(JSON.stringify({ typ: "dpop+jwt", alg: "ES256", jwk: {} })) + "." +
+                    _dpopB64url("nope}") + ".AA", o)) === "auth-dpop/malformed");
+  check("dpop.verify: header is JSON null (not object) → auth-dpop/malformed",
+        (await code(_dpopB64url("null") + "." + _dpopB64url("{}") + ".AA", o)) === "auth-dpop/malformed");
+  check("dpop.verify: payload is JSON null (not object) → auth-dpop/malformed",
+        (await code(_dpopB64url(JSON.stringify({ typ: "dpop+jwt", alg: "ES256", jwk: {} })) + "." +
+                    _dpopB64url("null") + ".AA", o)) === "auth-dpop/malformed");
+}
+
+async function testAuthDpopVerifyHeaderChecks() {
+  var d = b.auth.dpop;
+  var nodeCrypto = require("crypto");
+  var ec = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+  var pubJwk = ec.publicKey.export({ format: "jwk" });
+  var o = { htm: "GET", htu: "https://x/y" };
+  var payload = { jti: "j", htm: "GET", htu: "https://x/y", iat: Math.floor(Date.now() / 1000) };
+  async function code(proof, opts) {
+    try { await d.verify(proof, opts || o); return null; }
+    catch (e) { return e && e.code; }
+  }
+
+  check("dpop.verify: header.typ != dpop+jwt → auth-dpop/bad-typ",
+        (await code(_dpopCraft({ typ: "JWT", alg: "ES256", jwk: pubJwk }, payload))) === "auth-dpop/bad-typ");
+  check("dpop.verify: non-string header.alg → auth-dpop/malformed",
+        (await code(_dpopCraft({ typ: "dpop+jwt", alg: 123, jwk: pubJwk }, payload))) === "auth-dpop/malformed");
+  check("dpop.verify: token alg absent from allowlist → auth-dpop/alg-not-allowed",
+        (await code(_dpopCraft({ typ: "dpop+jwt", alg: "ES384", jwk: pubJwk }, payload),
+                    { htm: "GET", htu: "https://x/y", algorithms: ["ES256"] })) === "auth-dpop/alg-not-allowed");
+  check("dpop.verify: unsupported alg in opts.algorithms → auth-dpop/unsupported-alg",
+        (await code("a.b.c", { htm: "GET", htu: "https://x/y", algorithms: ["FOO"] })) === "auth-dpop/unsupported-alg");
+  check("dpop.verify: missing header.jwk → auth-dpop/missing-jwk",
+        (await code(_dpopCraft({ typ: "dpop+jwt", alg: "ES256" }, payload))) === "auth-dpop/missing-jwk");
+  check("dpop.verify: non-object header.jwk → auth-dpop/missing-jwk",
+        (await code(_dpopCraft({ typ: "dpop+jwt", alg: "ES256", jwk: "nope" }, payload))) === "auth-dpop/missing-jwk");
+  check("dpop.verify: 'crit' header declared → auth-dpop/unknown-crit",
+        (await code(_dpopCraft({ typ: "dpop+jwt", alg: "ES256", jwk: pubJwk, crit: ["b64"] }, payload))) === "auth-dpop/unknown-crit");
+}
+
+async function testAuthDpopVerifyBadSignature() {
+  var d = b.auth.dpop;
+  var nodeCrypto = require("crypto");
+  var ec = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+  var proof = await d.buildProof({ htm: "GET", htu: "https://x/y", privateKey: ec.privateKey });
+  var parts = proof.split(".");
+  // Flip a byte of the (validly base64url) signature → decodes fine, verifies
+  // false → invalid-signature (NOT a base64url-decode malformed error).
+  var sigBuf = Buffer.from(parts[2].replace(/-/g, "+").replace(/_/g, "/"), "base64");
+  sigBuf[0] = sigBuf[0] ^ 0xff;
+  parts[2] = sigBuf.toString("base64").replace(/=+$/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  var threw = null;
+  try { await d.verify(parts.join("."), { htm: "GET", htu: "https://x/y" }); }
+  catch (e) { threw = e; }
+  check("dpop.verify: tampered signature → auth-dpop/invalid-signature",
+        threw && threw.code === "auth-dpop/invalid-signature");
+}
+
+async function testAuthDpopVerifyPayloadChecks() {
+  var d = b.auth.dpop;
+  var nodeCrypto = require("crypto");
+  var ec = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+  var hdr = { typ: "dpop+jwt", alg: "ES256", jwk: ec.publicKey.export({ format: "jwk" }) };
+  var now = Math.floor(Date.now() / 1000);
+  var o = { htm: "GET", htu: "https://x/y" };
+  async function code(payload, opts) {
+    try { await d.verify(_dpopSignES256(ec.privateKey, hdr, payload), opts || o); return null; }
+    catch (e) { return e && e.code; }
+  }
+
+  check("dpop.verify: missing payload.jti → auth-dpop/missing-jti",
+        (await code({ htm: "GET", htu: "https://x/y", iat: now })) === "auth-dpop/missing-jti");
+  check("dpop.verify: missing payload.htm → auth-dpop/bad-htm",
+        (await code({ jti: "j", htu: "https://x/y", iat: now })) === "auth-dpop/bad-htm");
+  check("dpop.verify: missing payload.htu → auth-dpop/bad-htu",
+        (await code({ jti: "j", htm: "GET", iat: now })) === "auth-dpop/bad-htu");
+  check("dpop.verify: non-number payload.iat → auth-dpop/bad-iat",
+        (await code({ jti: "j", htm: "GET", htu: "https://x/y", iat: "soon" })) === "auth-dpop/bad-iat");
+}
+
+async function testAuthDpopNonceBinding() {
+  var d = b.auth.dpop;
+  var nodeCrypto = require("crypto");
+  var ec = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+
+  var withNonce = await d.buildProof({
+    htm: "GET", htu: "https://x/y", privateKey: ec.privateKey, nonce: "srv-nonce-1",
+  });
+  var ok = await d.verify(withNonce, { htm: "GET", htu: "https://x/y", nonce: "srv-nonce-1" });
+  check("dpop.verify: matching nonce accepted", ok.payload.nonce === "srv-nonce-1");
+
+  var threwMis = null;
+  try { await d.verify(withNonce, { htm: "GET", htu: "https://x/y", nonce: "srv-nonce-2" }); }
+  catch (e) { threwMis = e; }
+  check("dpop.verify: nonce mismatch → auth-dpop/nonce-mismatch",
+        threwMis && threwMis.code === "auth-dpop/nonce-mismatch");
+
+  var noNonce = await d.buildProof({ htm: "GET", htu: "https://x/y", privateKey: ec.privateKey });
+  var threwMissing = null;
+  try { await d.verify(noNonce, { htm: "GET", htu: "https://x/y", nonce: "srv-nonce-1" }); }
+  catch (e) { threwMissing = e; }
+  check("dpop.verify: expected nonce absent from proof → auth-dpop/missing-nonce",
+        threwMissing && threwMissing.code === "auth-dpop/missing-nonce");
+}
+
+async function testAuthDpopVerifyBadReplayStore() {
+  var d = b.auth.dpop;
+  var nodeCrypto = require("crypto");
+  var ec = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+  var proof = await d.buildProof({ htm: "GET", htu: "https://x/y", privateKey: ec.privateKey });
+  var threw = null;
+  // An object lacking checkAndInsert must be refused at the opts tier, not
+  // silently skip replay defense.
+  try { await d.verify(proof, { htm: "GET", htu: "https://x/y", replayStore: {} }); }
+  catch (e) { threw = e; }
+  check("dpop.verify: replayStore without checkAndInsert → auth-dpop/bad-replay-store",
+        threw && threw.code === "auth-dpop/bad-replay-store");
+}
+
+async function testAuthDpopBuildProofValidation() {
+  var d = b.auth.dpop;
+  var nodeCrypto = require("crypto");
+  var ec = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+  async function code(opts) {
+    try { await d.buildProof(opts); return null; }
+    catch (e) { return e && e.code; }
+  }
+
+  check("dpop.buildProof: omitted htm → auth-dpop/bad-htm",
+        (await code({ htu: "https://x/y", privateKey: ec.privateKey })) === "auth-dpop/bad-htm");
+  check("dpop.buildProof: omitted htu → auth-dpop/bad-htu",
+        (await code({ htm: "GET", privateKey: ec.privateKey })) === "auth-dpop/bad-htu");
+  check("dpop.buildProof: omitted privateKey → auth-dpop/missing-private-key",
+        (await code({ htm: "GET", htu: "https://x/y" })) === "auth-dpop/missing-private-key");
+  check("dpop.buildProof: unparseable PEM → auth-dpop/bad-private-key",
+        (await code({ htm: "GET", htu: "https://x/y",
+                      privateKey: "-----BEGIN PRIVATE KEY-----\nnope\n-----END PRIVATE KEY-----" })) === "auth-dpop/bad-private-key");
+  check("dpop.buildProof: wrong-type privateKey → auth-dpop/bad-private-key",
+        (await code({ htm: "GET", htu: "https://x/y", privateKey: 12345 })) === "auth-dpop/bad-private-key");
+  check("dpop.buildProof: unsupported algorithm → auth-dpop/unsupported-alg",
+        (await code({ htm: "GET", htu: "https://x/y", privateKey: ec.privateKey, algorithm: "FOO" })) === "auth-dpop/unsupported-alg");
+  check("dpop.buildProof: non-http(s) htu scheme → auth-dpop/bad-htu",
+        (await code({ htm: "GET", htu: "ftp://host/path", privateKey: ec.privateKey })) === "auth-dpop/bad-htu");
+  check("dpop.buildProof: explicit jwk with refused kty → auth-dpop/refused-kty",
+        (await code({ htm: "GET", htu: "https://x/y", privateKey: ec.privateKey,
+                      jwk: { kty: "oct", k: "AAAA" } })) === "auth-dpop/refused-kty");
+}
+
+function testAuthDpopThumbprintErrors() {
+  var d = b.auth.dpop;
+  function code(jwkVal) {
+    try { d.thumbprint(jwkVal); return null; }
+    catch (e) { return e && e.code; }
+  }
+  check("dpop.thumbprint: null → auth-dpop/bad-jwk", code(null) === "auth-dpop/bad-jwk");
+  check("dpop.thumbprint: non-object → auth-dpop/bad-jwk", code("nope") === "auth-dpop/bad-jwk");
+  check("dpop.thumbprint: missing kty → auth-dpop/bad-jwk", code({ x: "y" }) === "auth-dpop/bad-jwk");
+  check("dpop.thumbprint: symmetric oct kty refused → auth-dpop/refused-kty",
+        code({ kty: "oct", k: "AAAA" }) === "auth-dpop/refused-kty");
+}
+
 // ---- AAL — NIST SP 800-63-4 authentication assurance levels ----
 
 function testAuthAalSurface() {
@@ -6061,6 +6278,34 @@ async function testBackupBundlePathTraversalRejected() {
       });
     } catch (e) { threw = e; }
     check("absolute path in relativePath rejected", threw && threw.code === "backup-bundle/bad-include");
+
+    // A Windows drive-letter prefix is absolute (path.resolve honors it) and a
+    // colon anywhere is also an NTFS alternate-data-stream marker -- both must
+    // be refused so a relativePath built from untrusted input can't read a file
+    // outside dataDir. Sibling of the manifest.validate / restore-sink checks.
+    threw = null;
+    try {
+      await b.backupBundle.create({
+        dataDir:      fx.dataDir,
+        outDir:       path.join(fx.root, "bundle3"),
+        passphrase:   Buffer.from("p"),
+        vaultKeyJson: "{}",
+        files: [{ relativePath: "C:" + "\\" + "Windows" + "\\" + "evil", kind: "raw", required: true }],
+      });
+    } catch (e) { threw = e; }
+    check("drive-letter path in relativePath rejected", threw && threw.code === "backup-bundle/bad-include");
+
+    threw = null;
+    try {
+      await b.backupBundle.create({
+        dataDir:      fx.dataDir,
+        outDir:       path.join(fx.root, "bundle4"),
+        passphrase:   Buffer.from("p"),
+        vaultKeyJson: "{}",
+        files: [{ relativePath: "db.enc:evil", kind: "raw", required: true }],
+      });
+    } catch (e) { threw = e; }
+    check("NTFS-ADS (colon) in relativePath rejected", threw && threw.code === "backup-bundle/bad-include");
   } finally { fx.cleanup(); }
 }
 
@@ -11423,6 +11668,101 @@ async function testDevDebouncesBurstOfEventsToOneRestart() {
   await d.stop();
 }
 
+async function testDevStopSettlesAfterSpawnError() {
+  // A command that cannot be spawned (ENOENT) emits 'error' + 'close' but
+  // NEVER 'exit', and kill() returns false (no live OS process). stop() must
+  // still settle so the supervisor can shut down — otherwise a ref'd
+  // keep-alive in the CLI would hang and a single Ctrl-C could not terminate.
+  function makeSpawnErrorChild() {
+    var listeners = {};
+    return {
+      pid:  undefined,
+      kill: function () { return false; },   // no live process to signal
+      on:   function (ev, cb) { (listeners[ev] = listeners[ev] || []).push(cb); return this; },
+      once: function (ev, cb) {
+        var wrap = function (a, b) {
+          listeners[ev] = (listeners[ev] || []).filter(function (x) { return x !== wrap; });
+          cb(a, b);
+        };
+        return this.on(ev, wrap);
+      },
+      _emit: function (ev, a, b) { (listeners[ev] || []).slice().forEach(function (cb) { cb(a, b); }); },
+    };
+  }
+  var errChild = makeSpawnErrorChild();
+  var d = b.dev.create({
+    command: "does-not-exist",
+    cwd:     "/repo",
+    _spawn:        function () { return errChild; },
+    _watch:        function () { return { on: function () { return this; }, close: function () {} }; },
+    _setTimeout:   function () { return { unref: function () { return this; } }; },   // never fires
+    _clearTimeout: function () {},
+  });
+  await d.start();
+  // Simulate the spawn failure: 'error' then 'close', no 'exit'.
+  errChild._emit("error", Object.assign(new Error("spawn does-not-exist ENOENT"), { code: "ENOENT" }));
+  errChild._emit("close", null, null);
+
+  var settled = false;
+  d.stop().then(function () { settled = true; }, function () { settled = true; });
+  await new Promise(function (r) { setImmediate(r); });
+  await new Promise(function (r) { setImmediate(r); });
+  check("dev.stop() settles after a spawn-error child (no 'exit' event)", settled === true);
+}
+
+async function testDevStopWaitsForLiveChildKillFailure() {
+  // A LIVE child (has a pid) whose kill() fails — the signal was not
+  // delivered, e.g. EPERM after the child changed credentials — must NOT
+  // settle stop() immediately: the process may still be running. stop()
+  // completes only when an exit/close actually arrives, never on a false
+  // kill() return alone (which would falsely report termination).
+  function makeLiveUnkillableChild() {
+    var listeners = {};
+    return {
+      pid:  4242,                             // a real, live process
+      kill: function () { return false; },    // signal not delivered (EPERM)
+      on:   function (ev, cb) { (listeners[ev] = listeners[ev] || []).push(cb); return this; },
+      once: function (ev, cb) {
+        var wrap = function (a, b) {
+          listeners[ev] = (listeners[ev] || []).filter(function (x) { return x !== wrap; });
+          cb(a, b);
+        };
+        return this.on(ev, wrap);
+      },
+      _emit: function (ev, a, b) { (listeners[ev] || []).slice().forEach(function (cb) { cb(a, b); }); },
+    };
+  }
+  var live = makeLiveUnkillableChild();
+  var d = b.dev.create({
+    command: "x",
+    cwd:     "/repo",
+    _spawn:        function () { return live; },
+    _watch:        function () { return { on: function () { return this; }, close: function () {} }; },
+    _setTimeout:   function () { return { unref: function () { return this; } }; },   // killTimer never fires
+    _clearTimeout: function () {},
+  });
+  await d.start();
+
+  var settled = false;
+  d.stop().then(function () { settled = true; }, function () { settled = true; });
+  await new Promise(function (r) { setImmediate(r); });
+  await new Promise(function (r) { setImmediate(r); });
+  check("dev.stop() does NOT settle while a live child's kill was rejected (no exit yet)", settled === false);
+
+  // A kill 'error' on a STILL-LIVE child (EPERM) must not complete shutdown
+  // either — the process is still running.
+  live._emit("error", Object.assign(new Error("kill EPERM"), { code: "EPERM" }));
+  await new Promise(function (r) { setImmediate(r); });
+  await new Promise(function (r) { setImmediate(r); });
+  check("dev.stop() does NOT settle on an 'error' from a still-live child", settled === false);
+
+  // Only a real exit completes it.
+  live._emit("exit", 0, null);
+  await new Promise(function (r) { setImmediate(r); });
+  await new Promise(function (r) { setImmediate(r); });
+  check("dev.stop() settles once the live child finally exits", settled === true);
+}
+
 async function testDevIgnoresMatchingPaths() {
   var h = _makeDevHarness();
   var d = b.dev.create({
@@ -14561,6 +14901,245 @@ function testEnvParseSecurityRejections() {
   check("env: unterminated quoted rejected",       threwUnterm);
 }
 
+function testEnvParseQuotingAndEscapes() {
+  var env = b.parsers.env;
+
+  // Double-quoted escape sequences decode individually.
+  check("env: \\t escape decodes to tab",   env.parse('K="a\\tb"').K === "a\tb");
+  check("env: \\r escape decodes to CR",    env.parse('K="a\\rb"').K === "a\rb");
+  check("env: \\\\ escape decodes to \\",   env.parse('K="a\\\\b"').K === "a\\b");
+  check("env: \\\" escape decodes to quote", env.parse('K="a\\"b"').K === 'a"b');
+
+  // \u unicode escape decodes; malformed hex is a typed refusal.
+  check("env: \\u escape decodes",          env.parse('U="\\u0041\\u0042"').U === "AB");
+  var threwBadU = false;
+  try { env.parse('K="\\uZZZZ"'); }
+  catch (e) { threwBadU = e.code === "env/bad-escape"; }
+  check("env: bad \\u escape rejected",     threwBadU);
+
+  // Unknown backslash escape is a typed refusal (not silently swallowed).
+  var threwUnknownEsc = false;
+  try { env.parse('K="\\q"'); }
+  catch (e) { threwUnknownEsc = e.code === "env/bad-escape"; }
+  check("env: unknown escape rejected",     threwUnknownEsc);
+
+  // Single-quoted values are fully literal — an unterminated one refuses.
+  var threwSingleUnterm = false;
+  try { env.parse("K='abc"); }
+  catch (e) { threwSingleUnterm = e.code === "env/unterminated-string"; }
+  check("env: unterminated single-quote rejected", threwSingleUnterm);
+
+  // A comment after a closing double-quote is ignored.
+  check("env: comment after closing quote ignored", env.parse('K="v" # trailing').K === "v");
+
+  // A '#' NOT preceded by whitespace is a literal part of the value.
+  check("env: '#' without leading space kept literal", env.parse("K=color#red").K === "color#red");
+
+  // A real tab INSIDE a quoted value is fine (only a tab starting an
+  // unquoted value is the paste-accident we reject).
+  check("env: tab inside double-quote preserved", env.parse('K="a\tb"').K === "a\tb");
+
+  // A trailing '$' with no name after it is a literal, not an expansion.
+  check("env: trailing '$' is literal", env.parse("K=abc$").K === "abc$");
+
+  // ${VAR} in a double-quoted value is refused (brace form).
+  var threwBraceDq = false;
+  try { env.parse('K="${HOME}"'); }
+  catch (e) { threwBraceDq = e.code === "env/expansion-banned"; }
+  check("env: ${VAR} in double-quote rejected", threwBraceDq);
+}
+
+function testEnvParseStructureAndKeys() {
+  var env = b.parsers.env;
+
+  // CRLF and lone-CR line endings both split into records.
+  var crlf = env.parse("A=1\r\nB=2");
+  check("env: CRLF line endings", crlf.A === "1" && crlf.B === "2");
+  var cr = env.parse("A=1\rB=2");
+  check("env: lone-CR line endings", cr.A === "1" && cr.B === "2");
+
+  // A leading BOM is stripped before parsing.
+  check("env: leading BOM stripped", env.parse("A=1").A === "1");
+
+  // Empty key ('=value' with no key) is a typed refusal.
+  var threwEmptyKey = false;
+  try { env.parse("=value"); }
+  catch (e) { threwEmptyKey = e.code === "env/empty-key"; }
+  check("env: empty key rejected", threwEmptyKey);
+
+  // keyShape override lets an operator opt into lowercase keys.
+  check("env: keyShape override accepts lowercase",
+        env.parse("lower_key=v", { keyShape: /^[a-z_]+$/ }).lower_key === "v");
+
+  // Even with a permissive keyShape, a poisoned key is refused at the
+  // dedicated guard (the pollution defense is not keyShape-dependent).
+  var threwPoisoned = false;
+  try { env.parse("__proto__=x", { keyShape: /^[a-z_]+$/ }); }
+  catch (e) { threwPoisoned = e.code === "env/poisoned-key"; }
+  check("env: poisoned key refused regardless of keyShape", threwPoisoned);
+
+  // ${VAR} expansion in an unquoted value is refused (brace form).
+  var threwBrace = false;
+  try { env.parse("K=${HOME}"); }
+  catch (e) { threwBrace = e.code === "env/expansion-banned"; }
+  check("env: ${VAR} unquoted rejected", threwBrace);
+
+  // maxKeys cap is enforced (DoS bound).
+  var threwManyKeys = false;
+  try { env.parse("A=1\nB=2\nC=3", { maxKeys: 2 }); }
+  catch (e) { threwManyKeys = e.code === "env/too-many-keys"; }
+  check("env: maxKeys enforced", threwManyKeys);
+
+  // Non-positive / non-integer / non-finite numeric opts are refused up
+  // front — they must not silently lift the DoS caps they configure.
+  var badOpts = [
+    { maxBytes: -5 }, { maxBytes: 1.5 }, { maxBytes: Infinity },
+    { maxBytes: NaN }, { maxKeys: 0 }, { maxKeys: Infinity },
+  ];
+  var allBadOptsRejected = badOpts.every(function (o) {
+    try { env.parse("A=1", o); return false; }
+    catch (e) { return e.code === "env/bad-opt"; }
+  });
+  check("env: invalid numeric opts rejected as env/bad-opt", allBadOptsRejected);
+}
+
+function testEnvReadVarEdgeCases() {
+  var env = b.parsers.env;
+
+  // Non-string / empty name is a typed refusal.
+  var threwNonStr = false;
+  try { env.readVar(123); }
+  catch (e) { threwNonStr = e.code === "env/bad-arg"; }
+  check("readVar: non-string name rejected", threwNonStr);
+  var threwEmptyName = false;
+  try { env.readVar(""); }
+  catch (e) { threwEmptyName = e.code === "env/bad-arg"; }
+  check("readVar: empty name rejected", threwEmptyName);
+
+  // Invalid maxBytes opt refused before any read.
+  var threwBadOpt = false;
+  try { env.readVar("BLAMEJS_TEST_EV1", { maxBytes: 0 }); }
+  catch (e) { threwBadOpt = e.code === "env/bad-opt"; }
+  check("readVar: invalid maxBytes rejected", threwBadOpt);
+
+  var KEYS = ["BLAMEJS_TEST_EV1", "BLAMEJS_TEST_EV2", "BLAMEJS_TEST_EV3", "BLAMEJS_TEST_EV4"];
+  var saved = {};
+  for (var i = 0; i < KEYS.length; i++) { saved[KEYS[i]] = process.env[KEYS[i]]; delete process.env[KEYS[i]]; }
+
+  try {
+    // type:json coerces a valid JSON value.
+    process.env.BLAMEJS_TEST_EV1 = '{"a":1,"b":true}';
+    var parsed = env.readVar("BLAMEJS_TEST_EV1", { type: "json" });
+    check("readVar: json coercion", parsed && parsed.a === 1 && parsed.b === true);
+
+    // type:json on garbage is a typed refusal (not an uncaught crash).
+    process.env.BLAMEJS_TEST_EV2 = "not json";
+    var threwBadJson = false;
+    try { env.readVar("BLAMEJS_TEST_EV2", { type: "json" }); }
+    catch (e) { threwBadJson = e.code === "env/bad-type"; }
+    check("readVar: invalid json rejected", threwBadJson);
+
+    // Unknown schema type is a typed refusal.
+    process.env.BLAMEJS_TEST_EV3 = "v";
+    var threwUnknownType = false;
+    try { env.readVar("BLAMEJS_TEST_EV3", { type: "frobnicate" }); }
+    catch (e) { threwUnknownType = e.code === "env/bad-schema"; }
+    check("readVar: unknown type rejected", threwUnknownType);
+
+    // type:number on a non-number is a typed refusal.
+    process.env.BLAMEJS_TEST_EV4 = "notnum";
+    var threwBadNum = false;
+    try { env.readVar("BLAMEJS_TEST_EV4", { type: "number" }); }
+    catch (e) { threwBadNum = e.code === "env/bad-type"; }
+    check("readVar: non-number rejected", threwBadNum);
+  } finally {
+    for (var j = 0; j < KEYS.length; j++) {
+      if (saved[KEYS[j]] === undefined) delete process.env[KEYS[j]];
+      else process.env[KEYS[j]] = saved[KEYS[j]];
+    }
+  }
+}
+
+function testEnvLoad() {
+  var env = b.parsers.env;
+
+  // Non-string path is a typed refusal.
+  var threwBadArg = false;
+  try { env.load(123); }
+  catch (e) { threwBadArg = e.code === "env/bad-arg"; }
+  check("env.load: non-string path rejected", threwBadArg);
+
+  var dir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-env-load-"));
+  try {
+    // Happy path: schema-driven coercion + defaults + unregistered
+    // passthrough. audit:false keeps the load pure (no audit chain).
+    var f1 = path.join(dir, "a.env");
+    fs.writeFileSync(f1, "PORT=8080\nDEBUG=true\nCONF={\"x\":1}\nEMPTYNUM=\nEXTRA=raw\n");
+    var r1 = env.load(f1, {
+      audit: false,
+      expected: {
+        PORT:        { type: "number" },
+        DEBUG:       { type: "boolean" },
+        CONF:        { type: "json" },
+        EMPTYNUM:    { type: "number" },
+        MISSING_DEF: { type: "string", default: "fallback" },
+      },
+    });
+    check("env.load: number coercion",   r1.values.PORT === 8080);
+    check("env.load: boolean coercion",  r1.values.DEBUG === true);
+    check("env.load: json coercion",     r1.values.CONF && r1.values.CONF.x === 1);
+    check("env.load: empty number → null", r1.values.EMPTYNUM === null);
+    check("env.load: absent key uses default", r1.values.MISSING_DEF === "fallback");
+    check("env.load: unregistered key passed through raw", r1.values.EXTRA === "raw");
+
+    // Missing required key is a typed refusal.
+    var f2 = path.join(dir, "b.env");
+    fs.writeFileSync(f2, "PORT=1\n");
+    var threwMissing = false;
+    try { env.load(f2, { audit: false, expected: { NEEDED: { type: "string", required: true } } }); }
+    catch (e) { threwMissing = e.code === "env/missing-required"; }
+    check("env.load: missing required rejected", threwMissing);
+
+    // A sensitivity:'breaking' change against the snapshot refuses unless
+    // acknowledged via { allow: [...] }.
+    var f3 = path.join(dir, "c.env");
+    fs.writeFileSync(f3, "APP_MODE=new\n");
+    var snap = path.join(dir, "snap.json");
+    fs.writeFileSync(snap, JSON.stringify({ APP_MODE: "old" }));
+    var threwBreaking = false;
+    try {
+      env.load(f3, { audit: false, snapshotPath: snap,
+        expected: { APP_MODE: { sensitivity: "breaking" } } });
+    } catch (e) { threwBreaking = e.code === "env/breaking-change"; }
+    check("env.load: unacknowledged breaking change rejected", threwBreaking);
+
+    fs.writeFileSync(snap, JSON.stringify({ APP_MODE: "old" }));
+    var r3 = env.load(f3, { audit: false, snapshotPath: snap, allow: ["APP_MODE"],
+      expected: { APP_MODE: { sensitivity: "breaking" } } });
+    check("env.load: acknowledged breaking change accepted", r3.values.APP_MODE === "new");
+    check("env.load: breaking change surfaced in diff",
+          r3.diff.changed.length === 1 && r3.diff.changed[0].key === "APP_MODE");
+
+    // rejectUnknown refuses when an unregistered key is present.
+    var f4 = path.join(dir, "d.env");
+    fs.writeFileSync(f4, "KNOWN=1\nUNKNOWN_KEY=2\n");
+    var threwUnknownKeys = false;
+    try { env.load(f4, { audit: false, rejectUnknown: true, expected: { KNOWN: { type: "number" } } }); }
+    catch (e) { threwUnknownKeys = e.code === "env/unknown-keys"; }
+    check("env.load: rejectUnknown refuses unregistered key", threwUnknownKeys);
+
+    // A near-miss key surfaces as a suspicious typo suggestion.
+    var f5 = path.join(dir, "e.env");
+    fs.writeFileSync(f5, "DATABASE_UR=x\n");
+    var r5 = env.load(f5, { audit: false, expected: { DATABASE_URL: { type: "string" } } });
+    check("env.load: typo surfaced as suspicious",
+          r5.diff.suspicious.length === 1 &&
+          r5.diff.suspicious[0].suggestion === "DATABASE_URL");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
 function testBufferSafeNormalizeText() {
   var bs = b.safeBuffer;
   check("safeBuffer.normalizeText is a function", typeof bs.normalizeText === "function");
@@ -18827,6 +19406,8 @@ async function run() {
   await testDevRestartCoalescesQueuedRestart();
   await testDevStopKillsAndDisarms();
   await testDevUnexpectedExitDoesNotRespawn();
+  await testDevStopSettlesAfterSpawnError();
+  await testDevStopWaitsForLiveChildKillFailure();
   // cli — `blamejs <cmd>` dispatch + migrate subcommand
   testCliSurface();
   testCliArgParser();
@@ -18950,6 +19531,14 @@ async function run() {
   await testAuthDpopJwkPrivateLeakRefused();
   await testAuthDpopThumbprint();
   await testAuthDpopPqcMlDsa();
+  await testAuthDpopVerifyMalformedInputs();
+  await testAuthDpopVerifyHeaderChecks();
+  await testAuthDpopVerifyBadSignature();
+  await testAuthDpopVerifyPayloadChecks();
+  await testAuthDpopNonceBinding();
+  await testAuthDpopVerifyBadReplayStore();
+  await testAuthDpopBuildProofValidation();
+  testAuthDpopThumbprintErrors();
   testAuthAalSurface();
   testAuthAalFromMethods();
   testAuthAalMeets();
@@ -19099,7 +19688,11 @@ async function run() {
   testYamlSecurityRejections();
   testEnvParseBasic();
   testEnvParseSecurityRejections();
+  testEnvParseQuotingAndEscapes();
+  testEnvParseStructureAndKeys();
   testEnvReadVar();
+  testEnvReadVarEdgeCases();
+  testEnvLoad();
   // redact primitive
   testRedact();
   testAuditSafeEmitRedacts();
@@ -19213,6 +19806,14 @@ module.exports = {
   testAuthDpopJwkPrivateLeakRefused:         testAuthDpopJwkPrivateLeakRefused,
   testAuthDpopThumbprint:                    testAuthDpopThumbprint,
   testAuthDpopPqcMlDsa:                      testAuthDpopPqcMlDsa,
+  testAuthDpopVerifyMalformedInputs:         testAuthDpopVerifyMalformedInputs,
+  testAuthDpopVerifyHeaderChecks:            testAuthDpopVerifyHeaderChecks,
+  testAuthDpopVerifyBadSignature:            testAuthDpopVerifyBadSignature,
+  testAuthDpopVerifyPayloadChecks:           testAuthDpopVerifyPayloadChecks,
+  testAuthDpopNonceBinding:                  testAuthDpopNonceBinding,
+  testAuthDpopVerifyBadReplayStore:          testAuthDpopVerifyBadReplayStore,
+  testAuthDpopBuildProofValidation:          testAuthDpopBuildProofValidation,
+  testAuthDpopThumbprintErrors:              testAuthDpopThumbprintErrors,
   testAuthAalSurface:                        testAuthAalSurface,
   testAuthAalFromMethods:                    testAuthAalFromMethods,
   testAuthAalMeets:                          testAuthAalMeets,
@@ -19691,7 +20292,11 @@ module.exports = {
   testYamlSecurityRejections:                testYamlSecurityRejections,
   testEnvParseBasic:                         testEnvParseBasic,
   testEnvParseSecurityRejections:            testEnvParseSecurityRejections,
+  testEnvParseQuotingAndEscapes:             testEnvParseQuotingAndEscapes,
+  testEnvParseStructureAndKeys:              testEnvParseStructureAndKeys,
   testEnvReadVar:                            testEnvReadVar,
+  testEnvReadVarEdgeCases:                   testEnvReadVarEdgeCases,
+  testEnvLoad:                               testEnvLoad,
   testRedact:                                testRedact,
   testAuditSafeEmitRedacts:                  testAuditSafeEmitRedacts,