@blamejs/blamejs-shop 0.5.5 → 0.5.6

package/lib/vendor/blamejs/test/layer-0-primitives/http-client-throttle-transform.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.httpClient — download/upload transform correctness outside stream mode.

package/lib/vendor/blamejs/test/layer-0-primitives/http-message-signature.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.crypto.httpSig — RFC 9421 HTTP Message Signatures.
@@ -105,7 +107,7 @@ function testContentDigestTamper() {
     keyid:      "k1",
     alg:        "ed25519",
     privateKey: keys.privateKey,
-    covered:    ["@method", "content-digest"],
+    covered:    ["@method", "@target-uri", "content-digest"],
   });
   var tamperedMsg = Object.assign({}, msg, {
     body:    "tampered-body",
@@ -137,7 +139,7 @@ function testContentDigestMemberAnchored() {
     keyid:      "k1",
     alg:        "ed25519",
     privateKey: keys.privateKey,
-    covered:    ["@method", "content-digest"],
+    covered:    ["@method", "@target-uri", "content-digest"],
   });
   check("#178 a valid sha3-512 content-digest member parses + matches",
         /^sha3-512=:/.test(signed.headers["Content-Digest"]));
@@ -177,6 +179,30 @@ function testExpired() {
         verified.valid === false && verified.reason === "expired");
 }
 
+function testNonFiniteToleranceDoesNotDisableFreshness() {
+  // A non-finite toleranceMs (Infinity / NaN) must not disable the freshness
+  // window: `ageMs > Infinity` is always false, so a stale (replayed) signature
+  // would verify. A malformed tolerance falls back to the default instead. RED
+  // before the guard: the hour-old signature verifies.
+  var keys = _genEd25519();
+  var msg = { method: "GET", url: "https://api.example.com/x", headers: { host: "api.example.com" } };
+  var oldTs = Math.floor(Date.now() / 1000) - 60 * 60;     // 1 hour ago
+  var signed = b.crypto.httpSig.sign(msg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey,
+    covered: ["@method", "@target-uri"], created: oldTs,
+  });
+  var vmsg = Object.assign({}, msg, { headers: Object.assign({}, msg.headers, signed.headers) });
+  var bad = [Infinity, NaN, -1];
+  for (var i = 0; i < bad.length; i++) {
+    var v = b.crypto.httpSig.verify(vmsg, {
+      keyResolver: function () { return keys.publicKey; },
+      toleranceMs: bad[i],
+    });
+    check("httpSig: non-finite/negative toleranceMs (" + String(bad[i]) + ") falls back, stale signature still 'expired'",
+          v.valid === false && v.reason === "expired");
+  }
+}
+
 function testUnknownKeyid() {
   var keys = _genEd25519();
   var msg = {
@@ -232,12 +258,291 @@ function testQueryParam() {
   });
   var verified = b.crypto.httpSig.verify(
     Object.assign({}, msg, { headers: Object.assign({}, msg.headers, signed.headers) }),
-    { keyResolver: function () { return keys.publicKey; } }
+    { keyResolver: function () { return keys.publicKey; }, requiredComponents: [] }
   );
   check("query-param coverage round-trips",
         verified.valid === true);
 }
 
+// Helper: pull the raw base64 signature out of a `label=:base64:` Signature header.
+function _sigBytes(sigHeader) {
+  var m = /:([A-Za-z0-9+/=]+):/.exec(sigHeader);
+  return Buffer.from(m[1], "base64");
+}
+
+// RFC 9421 §2.2.8 — a @query-param name/value is canonicalized by decoding
+// (application/x-www-form-urlencoded parse: "+"->space, %XX->byte) then
+// re-encoding, so a "+"-encoded space on the wire becomes %20 in the signature
+// base (the RFC's own worked example: bar=with+plus+whitespace ->
+// with%20plus%20whitespace). The framework must SIGN that canonical value, or
+// its signatures do not interoperate with a conformant peer. We rebuild the
+// canonical base from the framework's OWN emitted Signature-Input terminator
+// (so param order / label are exact) and assert the emitted signature verifies
+// over it. Pre-fix the framework signed the raw value "with+plus+whitespace",
+// so this canonical base fails to verify (RED).
+function testQueryParamValueCanonicalizedToPercent20() {
+  var keys = _genEd25519();
+  var created = Math.floor(Date.now() / 1000);
+  var msg = {
+    method:  "GET",
+    url:     "https://api.example.com/p?bar=with+plus+whitespace",
+    headers: { host: "api.example.com" },
+  };
+  var signed = b.crypto.httpSig.sign(msg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey,
+    covered: ["@method", "@query-param;name=\"bar\""], created: created,
+  });
+  // Terminator = the Signature-Input value after the label (RFC 9421 §2.5).
+  var sigInput = signed.headers["Signature-Input"];
+  var afterLabel = sigInput.slice(sigInput.indexOf("=") + 1);
+  var canonicalBase =
+    "\"@method\": GET\n" +
+    "\"@query-param\";name=\"bar\": with%20plus%20whitespace\n" +
+    "\"@signature-params\": " + afterLabel;
+  var ok = nodeCrypto.verify(null, Buffer.from(canonicalBase, "utf8"),
+    keys.publicKey, _sigBytes(signed.headers["Signature"]));
+  check("sign covers the %20-canonical @query-param value (not the raw + form)", ok === true);
+
+  // And the self-round-trip still verifies (sign + verify share the resolver).
+  var verified = b.crypto.httpSig.verify(
+    Object.assign({}, msg, { headers: Object.assign({}, msg.headers, signed.headers) }),
+    { keyResolver: function () { return keys.publicKey; }, requiredComponents: [] });
+  check("the +-encoded @query-param message round-trips", verified.valid === true);
+}
+
+// The emitted component identifier name must be the canonical percent-encoded
+// form (RFC 9421 §2.2.8), so it is deterministic across peers and never carries
+// a literal space. An operator passing the decoded name "my key" must yield
+// ;name="my%20key" in Signature-Input. Pre-fix it emitted ;name="my key"
+// (a literal space the verifier then could not parse).
+function testQueryParamEmittedNameCanonicalized() {
+  var keys = _genEd25519();
+  var msg = {
+    method:  "GET",
+    url:     "https://api.example.com/p?my%20key=value",
+    headers: { host: "api.example.com" },
+  };
+  var signed = b.crypto.httpSig.sign(msg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey,
+    covered: ["@method", "@query-param;name=\"my key\""],
+  });
+  check("emitted Signature-Input carries the canonical ;name=\"my%20key\"",
+        /;name="my%20key"/.test(signed.headers["Signature-Input"]) &&
+        !/;name="my key"/.test(signed.headers["Signature-Input"]));
+  var verified = b.crypto.httpSig.verify(
+    Object.assign({}, msg, { headers: Object.assign({}, msg.headers, signed.headers) }),
+    { keyResolver: function () { return keys.publicKey; }, requiredComponents: [] });
+  check("a whitespace query-param name round-trips after canonicalization",
+        verified.valid === true);
+}
+
+// A conformant external peer signs the RFC-canonical base; the framework's
+// verify must rebuild the identical base and accept it. This is the true
+// interop check (a self-round-trip cannot catch a shared sign/verify bug).
+// Covers hex-case normalization (%2f -> %2F) and an encoded "&" surviving.
+function testQueryParamVerifiesConformantPeer() {
+  var keys = _genEd25519();
+  var created = Math.floor(Date.now() / 1000);
+  var msg = {
+    method:  "POST",
+    url:     "https://api.example.com/p?path=a%2fb&amp=x%26y",
+    headers: { host: "api.example.com" },
+  };
+  var params = ";created=" + created + ";alg=\"ed25519\";keyid=\"k1\"";
+  var covered = "(\"@query-param\";name=\"path\" \"@query-param\";name=\"amp\")";
+  var canonicalBase =
+    "\"@query-param\";name=\"path\": a%2Fb\n" +              // %2f -> %2F
+    "\"@query-param\";name=\"amp\": x%26y\n" +               // encoded & survives
+    "\"@signature-params\": " + covered + params;
+  var sig = nodeCrypto.sign(null, Buffer.from(canonicalBase, "utf8"), keys.privateKey);
+  var full = Object.assign({}, msg, { headers: Object.assign({}, msg.headers, {
+    "Signature-Input": "sig1=" + covered + params,
+    "Signature":       "sig1=:" + sig.toString("base64") + ":",
+  }) });
+  var verified = b.crypto.httpSig.verify(full, { keyResolver: function () { return keys.publicKey; }, requiredComponents: [] });
+  check("verify accepts a conformant peer's canonical @query-param base (hex-case + encoded &)",
+        verified.valid === true);
+}
+
+// The RFC 9421 §2.2.8 published worked example (request 2) — the authoritative
+// interop vectors. The framework's signature base for these three @query-param
+// components must equal the RFC's "resulting values" byte-for-byte: a
+// "+"-encoded space -> %20, multi-space/newline values stay %-encoded, and a
+// name with UTF-8 + reserved chars round-trips through its percent-encoded form.
+function testQueryParamRfc9421PublishedVectors() {
+  var keys = _genEd25519();
+  var created = Math.floor(Date.now() / 1000);
+  var msg = {
+    method: "GET",
+    url: "https://example.com/parameters?var=this%20is%20a%20big%0Amultiline%20value" +
+         "&bar=with+plus+whitespace&fa%C3%A7ade%22%3A%20=something",
+    headers: { host: "example.com" },
+  };
+  var covered = [
+    "@query-param;name=\"var\"",
+    "@query-param;name=\"bar\"",
+    "@query-param;name=\"fa%C3%A7ade%22%3A%20\"",
+  ];
+  var signed = b.crypto.httpSig.sign(msg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey, covered: covered, created: created,
+  });
+  var sigInput = signed.headers["Signature-Input"];
+  var afterLabel = sigInput.slice(sigInput.indexOf("=") + 1);
+  var canonicalBase =
+    "\"@query-param\";name=\"var\": this%20is%20a%20big%0Amultiline%20value\n" +
+    "\"@query-param\";name=\"bar\": with%20plus%20whitespace\n" +
+    "\"@query-param\";name=\"fa%C3%A7ade%22%3A%20\": something\n" +
+    "\"@signature-params\": " + afterLabel;
+  var ok = nodeCrypto.verify(null, Buffer.from(canonicalBase, "utf8"),
+    keys.publicKey, _sigBytes(signed.headers["Signature"]));
+  check("sign matches the RFC 9421 §2.2.8 published @query-param base vectors", ok === true);
+}
+
+// A decoded @query-param name containing a literal form delimiter ('&' or a
+// '+') must canonicalize to its percent-encoded form, NOT be split by the
+// form parser. With a colliding bare 'a' parameter present, mis-splitting
+// "a&b" to "a" would sign the WRONG parameter's value. The canonical name for
+// a param on the wire as a%26b is name="a%26b".
+function testQueryParamDecodedNameWithDelimiter() {
+  var keys = _genEd25519();
+  var msg = {
+    method:  "GET",
+    url:     "https://api.example.com/p?a%26b=right&a=wrong",
+    headers: { host: "api.example.com" },
+  };
+  var signed = b.crypto.httpSig.sign(msg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey,
+    covered: ["@method", "@query-param;name=\"a&b\""],   // decoded name with a literal &
+  });
+  check("decoded name with '&' canonicalizes to %26 (not split to \"a\")",
+        /;name="a%26b"/.test(signed.headers["Signature-Input"]) &&
+        !/;name="a"/.test(signed.headers["Signature-Input"]));
+  var verified = b.crypto.httpSig.verify(
+    Object.assign({}, msg, { headers: Object.assign({}, msg.headers, signed.headers) }),
+    { keyResolver: function () { return keys.publicKey; }, requiredComponents: [] });
+  check("decoded-name-with-& message round-trips (covers a%26b, not a)",
+        verified.valid === true);
+}
+
+// RFC 9421 §3.2 — the verifier MUST refuse a signature that does not cover the
+// components the application requires. Pre-fix, verify() built the signature
+// base solely from the attacker-supplied Signature-Input covered set and never
+// checked coverage, so an @authority-only signature was accepted after the
+// method / target-uri / body were changed (the verifier acts on a request whose
+// security-relevant parts were never signed). This pins both the explicit
+// requiredComponents refusal AND the body-aware secure default.
+function testRequiredComponentsCoverage() {
+  var keys = _genEd25519();
+
+  // (a) Under-covered signature: covers ONLY @authority.
+  var underMsg = {
+    method:  "GET",
+    url:     "https://api.example.com/x?ref=abc",
+    headers: { host: "api.example.com" },
+  };
+  var underSigned = b.crypto.httpSig.sign(underMsg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey,
+    covered: ["@authority"],
+  });
+  var underHeaders = Object.assign({}, underMsg.headers, underSigned.headers);
+
+  // Explicit requiredComponents → REFUSED (the signature is cryptographically
+  // valid, but @method / @target-uri are not covered). RED on the pre-fix tree:
+  // requiredComponents was ignored, so this returned { valid: true }.
+  var refusedExplicit = b.crypto.httpSig.verify(
+    Object.assign({}, underMsg, { headers: underHeaders }),
+    { keyResolver: function () { return keys.publicKey; },
+      requiredComponents: ["@method", "@target-uri"] });
+  check("under-covered signature refused when requiredComponents demands @method/@target-uri",
+        refusedExplicit.valid === false && refusedExplicit.reason === "missing-required-component");
+
+  // The secure DEFAULT (no requiredComponents passed) also refuses it —
+  // coverage enforcement is on by default, not opt-in.
+  var refusedDefault = b.crypto.httpSig.verify(
+    Object.assign({}, underMsg, { headers: underHeaders }),
+    { keyResolver: function () { return keys.publicKey; } });
+  check("under-covered signature refused by the secure default (@method/@target-uri required)",
+        refusedDefault.valid === false && refusedDefault.reason === "missing-required-component");
+
+  // The captured @authority-only signature replayed across a DIFFERENT method +
+  // path is refused (the concrete attack the finding pins).
+  var replay = b.crypto.httpSig.verify(
+    { method: "DELETE", url: "https://api.example.com/admin/delete-all",
+      headers: Object.assign({ host: "api.example.com" }, underSigned.headers) },
+    { keyResolver: function () { return keys.publicKey; } });
+  check("replay of @authority-only signature across method+path is refused",
+        replay.valid === false && replay.reason === "missing-required-component");
+
+  // (b) Positive control — a fully-covered signature still verifies, both under
+  // the explicit required set and under the secure default (no over-tightening).
+  var fullMsg = {
+    method:  "POST",
+    url:     "https://api.example.com/orders",
+    headers: { host: "api.example.com" },
+    body:    '{"amount":1}',
+  };
+  var fullSigned = b.crypto.httpSig.sign(fullMsg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey,
+    covered: ["@method", "@target-uri", "@authority", "content-digest"],
+  });
+  var fullHeaders = Object.assign({}, fullMsg.headers, fullSigned.headers);
+  var okExplicit = b.crypto.httpSig.verify(
+    Object.assign({}, fullMsg, { headers: fullHeaders }),
+    { keyResolver: function () { return keys.publicKey; },
+      requiredComponents: ["@method", "@target-uri"] });
+  check("fully-covered signature verifies under explicit requiredComponents", okExplicit.valid === true);
+  var okDefault = b.crypto.httpSig.verify(
+    Object.assign({}, fullMsg, { headers: fullHeaders }),
+    { keyResolver: function () { return keys.publicKey; } });
+  check("fully-covered bodied signature verifies under the secure default (incl. content-digest)",
+        okDefault.valid === true);
+
+  // (c) Body-aware rule: a bodied request whose signer omitted content-digest is
+  // refused by the default; requiredComponents:[] waives the floor (audited
+  // escape hatch — the signature itself is still verified).
+  var noDigest = b.crypto.httpSig.sign(fullMsg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey,
+    covered: ["@method", "@target-uri", "@authority"],   // content-digest omitted
+  });
+  var noDigestHeaders = Object.assign({}, fullMsg.headers, noDigest.headers);
+  var refusedNoDigest = b.crypto.httpSig.verify(
+    Object.assign({}, fullMsg, { headers: noDigestHeaders }),
+    { keyResolver: function () { return keys.publicKey; } });
+  check("bodied request without content-digest coverage refused by default",
+        refusedNoDigest.valid === false && refusedNoDigest.reason === "missing-required-component");
+  var waived = b.crypto.httpSig.verify(
+    Object.assign({}, fullMsg, { headers: noDigestHeaders }),
+    { keyResolver: function () { return keys.publicKey; }, requiredComponents: [] });
+  check("requiredComponents:[] waives the coverage floor (signature itself still verifies)",
+        waived.valid === true);
+
+  // (d) Parameterized components match WITH their parameters: a required
+  // @query-param;name="tenant" is NOT satisfied by a covered ;name="other"
+  // (the required-coverage check must not truncate the parameter suffix).
+  var paramMsg = {
+    method:  "GET",
+    url:     "https://api.example.com/x?tenant=acme&other=z",
+    headers: { host: "api.example.com" },
+  };
+  var paramSigned = b.crypto.httpSig.sign(paramMsg, {
+    keyid: "k1", alg: "ed25519", privateKey: keys.privateKey,
+    covered: ["@method", "@target-uri", "@query-param;name=\"other\""],
+  });
+  var paramHeaders = Object.assign({}, paramMsg.headers, paramSigned.headers);
+  var wrongParam = b.crypto.httpSig.verify(
+    Object.assign({}, paramMsg, { headers: paramHeaders }),
+    { keyResolver: function () { return keys.publicKey; },
+      requiredComponents: ["@method", "@target-uri", "@query-param;name=\"tenant\""] });
+  check("a required @query-param;name=\"tenant\" is NOT satisfied by a covered ;name=\"other\"",
+        wrongParam.valid === false && wrongParam.reason === "missing-required-component");
+  var rightParam = b.crypto.httpSig.verify(
+    Object.assign({}, paramMsg, { headers: paramHeaders }),
+    { keyResolver: function () { return keys.publicKey; },
+      requiredComponents: ["@method", "@target-uri", "@query-param;name=\"other\""] });
+  check("a required @query-param is satisfied when the covered param matches exactly",
+        rightParam.valid === true);
+}
+
 async function run() {
   testSurface();
   testRoundTripEd25519();
@@ -245,9 +550,16 @@ async function run() {
   testContentDigestTamper();
   testContentDigestMemberAnchored();
   testExpired();
+  testNonFiniteToleranceDoesNotDisableFreshness();
   testUnknownKeyid();
   testValidation();
   testQueryParam();
+  testQueryParamValueCanonicalizedToPercent20();
+  testQueryParamEmittedNameCanonicalized();
+  testQueryParamVerifiesConformantPeer();
+  testQueryParamRfc9421PublishedVectors();
+  testQueryParamDecodedNameWithDelimiter();
+  testRequiredComponentsCoverage();
 }
 
 module.exports = { run: run };

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.i18n.messageFormat — ICU MessageFormat parser + evaluator tests.
@@ -176,6 +178,29 @@ async function testT_integration() {
         i.t("simple", { name: "World" }) === "Hello World");
 }
 
+async function testDepthCap() {
+  // The recursive-descent parser and the renderer both recurse once per
+  // nested case body. A template nested thousands deep would overflow the
+  // V8 stack with an uncaught RangeError; both now throw a typed
+  // BAD_TEMPLATE well short of native overflow, while legitimate nesting
+  // still parses and renders.
+  function deepSelect(n) {
+    var s = "";
+    for (var i = 0; i < n; i++) { s += "{g,select,x{"; }
+    s += "deep";
+    for (var j = 0; j < n; j++) { s += "}other{x}}"; }
+    return s;
+  }
+  var threw = null;
+  try { mf.parse(deepSelect(4000)); } catch (e) { threw = e; }
+  check("parse rejects pathologically deep nesting with typed BAD_TEMPLATE (not RangeError)",
+        threw && /BAD_TEMPLATE/.test(threw.code || ""));
+  // A legitimately nested template (a select inside a plural) still renders.
+  check("legit nested template still renders",
+        mf.format("{count, plural, =0 {no {gender, select, female {girls} other {people}}} other {# items}}",
+          { count: 0, gender: "female" }, "en") === "no girls");
+}
+
 async function run() {
   await testSurface();
   await testLiteral();
@@ -191,6 +216,7 @@ async function run() {
   await testFormatRejections();
   await testLooksLikeMessageFormat();
   await testT_integration();
+  await testDepthCap();
 }
 
 module.exports = { run: run };

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.i18n — translation + locale negotiation primitive.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.iabMspa — IAB MSPA / GPP universal opt-out signal codec.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.iabTcf — TCF v2.3 consent string + disclosedVendors validator.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.middleware.idempotencyKey — draft-ietf-httpapi-idempotency-key.
@@ -114,6 +116,43 @@ function testBodyFingerprintHook() {
   check("bodyFingerprint: next() NOT called on mismatch", calledNext2 === false);
 }
 
+function testCrossActorIsolation() {
+  var store = b.middleware.idempotencyKey.memoryStore();
+  var mw = b.middleware.idempotencyKey({
+    store: store,
+    bodyFingerprint: function (req) { return req.body ? JSON.stringify(req.body) : null; },
+  });
+
+  // Principal A caches a private response under Idempotency-Key "shared".
+  var reqA = _mockReq("POST", "/account/export", "shared", { op: "export" });
+  reqA.user = { id: "alice" };
+  var resA = _mockRes();
+  mw(reqA, resA, function () { resA.statusCode = 200; resA.end("ALICE-PRIVATE"); });
+
+  // Principal B sends the SAME Idempotency-Key + same request shape. The
+  // slot must be scoped to the authenticated principal — B must NOT be
+  // served A's cached response (cross-actor disclosure), and B's own
+  // handler must run.
+  var reqB = _mockReq("POST", "/account/export", "shared", { op: "export" });
+  reqB.user = { id: "bob" };
+  var resB = _mockRes();
+  var handlerRanForB = false;
+  mw(reqB, resB, function () { handlerRanForB = true; resB.statusCode = 200; resB.end("BOB-OWN"); });
+  check("idempotency: principal B not served principal A's cached response",
+    resB._getBody() !== "ALICE-PRIVATE");
+  check("idempotency: principal B's own handler runs (no cross-actor replay)",
+    handlerRanForB === true);
+
+  // Same principal + same key → legitimate replay (no over-isolation).
+  var reqA2 = _mockReq("POST", "/account/export", "shared", { op: "export" });
+  reqA2.user = { id: "alice" };
+  var resA2 = _mockRes();
+  var handlerRanForA2 = false;
+  mw(reqA2, resA2, function () { handlerRanForA2 = true; resA2.end("ALICE-SECOND"); });
+  check("idempotency: same principal + key still replays (no over-isolation)",
+    resA2._getBody() === "ALICE-PRIVATE" && handlerRanForA2 === false);
+}
+
 function testMethodSkipsGet() {
   var store = b.middleware.idempotencyKey.memoryStore();
   var mw = b.middleware.idempotencyKey({ store: store });
@@ -589,6 +628,7 @@ async function run() {
   testBadKeyShape();
   testMissThenReplay();
   testFingerprintMismatch();
+  testCrossActorIsolation();
   testBodyFingerprintHook();
   testSkip5xx();
   testMemoryStoreFIFO();

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 // b.importmapIntegrity — WICG Import Maps + SRI integrity map.
 

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.inbox — transactional dedupe-on-receive (companion to b.outbox).

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 var helpers = require("../helpers");
 var b = helpers.b;

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * lib/ip-utils — internal IP-address textual helpers shared across the

package/lib/vendor/blamejs/test/layer-0-primitives/jose-jwe-experimental.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.jose.jwe.experimental — ML-KEM-1024 + XChaCha20-Poly1305 JWE.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 // b.jsonApi — JSON:API v1.1 response builders + query parser.
 

package/lib/vendor/blamejs/test/layer-0-primitives/json-merge-patch.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Layer 0 — b.jsonMergePatch (RFC 7396 JSON Merge Patch).

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Layer 0 — b.jsonPointer (RFC 6901) + b.jsonPatch (RFC 6902).

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Layer 0 — b.jsonPath (RFC 9535 JSONPath query).

package/lib/vendor/blamejs/test/layer-0-primitives/json-round-trip-helper.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Test the test-helper itself: assertJsonRoundTrip catches the bug

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Layer 0 — b.jsonSchema (JSON Schema 2020-12).
@@ -119,6 +121,29 @@ function testFormat() {
   check("uri accepts absolute", b.jsonSchema.isValid({ format: "uri" }, "https://example.com/x", { assertFormat: true }));
 }
 
+function testDepthCap() {
+  // validate(schema, instance) recurses one level per nested subschema
+  // application. A recursive schema (items:{$ref:"#"}) against a deeply
+  // nested instance — both attacker-controlled when validating a request
+  // body — would overflow the V8 stack with an uncaught RangeError before
+  // the depth guard fired (its cap was set above native overflow). The cap
+  // is now well under overflow so the typed json-schema/ref-loop error
+  // surfaces instead of a crash, while legitimate nesting (deep or wide)
+  // still validates.
+  var recursive = { $schema: b.jsonSchema.DIALECT, type: "array", items: { $ref: "#" } };
+  function deepArr(n) { var a = [], c = a; for (var i = 0; i < n; i++) { var n2 = []; c.push(n2); c = n2; } return a; }
+  check("validate: deeply nested instance throws typed ref-loop (not RangeError)",
+    code(function () { b.jsonSchema.validate(recursive, deepArr(1500)); }) === "json-schema/ref-loop");
+  // Legit shallow nesting validates clean.
+  check("validate: shallow nesting still validates", b.jsonSchema.validate(recursive, deepArr(40)).valid === true);
+  // Breadth must not trip the nesting cap (sibling properties do not
+  // accumulate depth).
+  var wide = { type: "object", properties: {} }; var obj = {};
+  for (var k = 0; k < 400; k++) { wide.properties["p" + k] = { type: "integer" }; obj["p" + k] = k; }
+  check("validate: wide-but-shallow object does not trip the depth cap",
+    b.jsonSchema.validate(wide, obj).valid === true);
+}
+
 async function run() {
   testSurface();
   testAssertions();
@@ -129,6 +154,7 @@ async function run() {
   testRefs();
   testErrorsShape();
   testFormat();
+  testDepthCap();
 }
 module.exports = { run: run };
 if (require.main === module) { run().then(function () { console.log("[json-schema] OK — " + helpers.getChecks() + " checks passed"); }, function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }); }

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Layer 0 — b.jtd (RFC 8927 JSON Type Definition).

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Layer 0 — b.jwk (RFC 7638 thumbprint).

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.auth.jwt.verifyExternal — classical-alg JWT verifier — and