@blamejs/blamejs-shop 0.4.30 → 0.4.32

package/lib/vendor/blamejs/test/layer-0-primitives/federation-vc-suite.test.js

@@ -146,10 +146,14 @@ function testFederationParseAndPolicy() {
   check("federation: parse returns header.typ",       parsed.header.typ === "entity-statement+jwt");
   check("federation: parse returns claims.iss",       parsed.claims.iss === "https://leaf.example");
 
-  // metadata_policy operators — value/default/one_of/subset_of/superset_of
+  // metadata_policy operators — value/default/one_of/subset_of/superset_of.
+  // Per OIDF §6.2 the policy comes from the SUPERIOR-SIGNED subordinate
+  // statement about the entity (`chain[i].subordinate.metadata_policy`),
+  // NOT the entity's own self-config — so each chain node carries the
+  // policy under `.subordinate`.
   var meta = { application_type: "web", redirect_uris: ["https://leaf/cb"] };
   var chain = [
-    { claims: { metadata_policy: { openid_relying_party: {
+    { subordinate: { metadata_policy: { openid_relying_party: {
       application_type: { one_of: ["web", "native"] },
       grant_types: { default: ["authorization_code"] },
     } } } },
@@ -162,7 +166,7 @@ function testFederationParseAndPolicy() {
   var threw = false;
   try {
     b.auth.openidFederation.applyMetadataPolicy({ application_type: "bad" }, [
-      { claims: { metadata_policy: { openid_relying_party: { application_type: { one_of: ["web", "native"] } } } } },
+      { subordinate: { metadata_policy: { openid_relying_party: { application_type: { one_of: ["web", "native"] } } } } },
     ], "openid_relying_party");
   } catch (e) { threw = /not in/.test(e.message); }
   check("federation: one_of rejects out-of-set value", threw);
@@ -171,10 +175,230 @@ function testFederationParseAndPolicy() {
   threw = false;
   try {
     b.auth.openidFederation.applyMetadataPolicy({ x: 1 }, [
-      { claims: { metadata_policy: { openid_relying_party: { x: { bogus: 1 } } } } },
+      { subordinate: { metadata_policy: { openid_relying_party: { x: { bogus: 1 } } } } },
     ], "openid_relying_party");
   } catch (e) { threw = /unknown operator/.test(e.message); }
   check("federation: unknown policy op refused",      threw);
+
+  // M2: a leaf's OWN self-config metadata_policy is IGNORED — only the
+  // superior-signed subordinate statement constrains the entity. A leaf
+  // that self-declares a widening policy can't drop the anchor's rules.
+  var ignored = b.auth.openidFederation.applyMetadataPolicy(
+    { application_type: "web" },
+    [{ claims: { metadata_policy: { openid_relying_party: {
+        application_type: { value: "native" } } } } }],
+    "openid_relying_party");
+  check("federation M2: leaf self-config metadata_policy ignored",
+        ignored.application_type === "web");
+}
+
+// ---- OpenID Federation trust-chain (multi-element, real signatures) ---
+
+// Mint an EC P-256 entity: keypair + a single-key JWKS carrying `kid`.
+function _fedEntity(kid) {
+  var kp = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
+  var jwk = kp.publicKey.export({ format: "jwk" });
+  jwk.kid = kid;
+  jwk.use = "sig";
+  jwk.alg = "ES256";
+  return { kp: kp, kid: kid, jwks: { keys: [jwk] } };
+}
+
+// Sign an entity-statement+jwt (ES256) with the given signing entity.
+function _signEntityStatement(signer, claims) {
+  var header = { typ: "entity-statement+jwt", alg: "ES256", kid: signer.kid };
+  var iat = Math.floor(Date.now() / 1000);
+  var full = Object.assign({ iat: iat, exp: iat + 3600 }, claims);
+  var input = _b64url(JSON.stringify(header)) + "." + _b64url(JSON.stringify(full));
+  var sig = nodeCrypto.sign("sha256", Buffer.from(input, "ascii"),
+    { key: signer.kp.privateKey, dsaEncoding: "ieee-p1363" });
+  return input + "." + _b64url(sig);
+}
+
+async function testFederationTrustChainMultiElement() {
+  var ANCHOR = "https://anchor.example";
+  var INT    = "https://intermediate.example";
+  var LEAF   = "https://leaf.example";
+
+  var anchor = _fedEntity("anchor-1");
+  var inter  = _fedEntity("inter-1");
+  var leaf   = _fedEntity("leaf-1");
+
+  // Self-configs (each self-signed over its own jwks).
+  var anchorCfg = _signEntityStatement(anchor, { iss: ANCHOR, sub: ANCHOR, jwks: anchor.jwks });
+  var interCfg  = _signEntityStatement(inter,  { iss: INT,  sub: INT,  jwks: inter.jwks, authority_hints: [ANCHOR] });
+  // Leaf self-declares a wide scope ("openid profile email") + a single
+  // redirect_uri; the superior policy will force the scope down and
+  // confirm the redirect_uri is within the allowed subset.
+  var leafMeta  = { openid_relying_party: { redirect_uris: ["https://leaf.example/cb"],
+                                            scope: "openid profile email" } };
+  var leafCfg   = _signEntityStatement(leaf, { iss: LEAF, sub: LEAF, jwks: leaf.jwks,
+                                               authority_hints: [INT], metadata: leafMeta });
+
+  // Superior-signed subordinate statements.
+  //   anchor → about intermediate  (pins intermediate's real jwks)
+  var subAboutInter = _signEntityStatement(anchor, { iss: ANCHOR, sub: INT, jwks: inter.jwks });
+  //   intermediate → about leaf  (pins leaf's jwks + constrains the leaf
+  //   via metadata_policy: subset_of on redirect_uris + value on scope)
+  var leafPolicy = { openid_relying_party: {
+    redirect_uris: { subset_of: ["https://leaf.example/cb", "https://leaf.example/cb2"] },
+    scope:         { value: "openid" },
+  } };
+  var subAboutLeaf = _signEntityStatement(inter, { iss: INT, sub: LEAF, jwks: leaf.jwks,
+                                                   metadata_policy: leafPolicy });
+
+  function _fetcher(url) {
+    if (url === ANCHOR + "/.well-known/openid-federation") return Promise.resolve(anchorCfg);
+    if (url === INT + "/.well-known/openid-federation")    return Promise.resolve(interCfg);
+    if (url === LEAF + "/.well-known/openid-federation")   return Promise.resolve(leafCfg);
+    return Promise.reject(new Error("404 " + url));
+  }
+  function _fetchSubordinate(authority, sub) {
+    if (authority === ANCHOR && sub === INT)  return Promise.resolve(subAboutInter);
+    if (authority === INT    && sub === LEAF) return Promise.resolve(subAboutLeaf);
+    return Promise.reject(new Error("no subordinate " + authority + "→" + sub));
+  }
+
+  var opts = {
+    leafEntityId: LEAF,
+    trustAnchors: { "https://anchor.example": anchor.jwks },
+    fetcher: _fetcher,
+    fetchSubordinate: _fetchSubordinate,
+  };
+
+  // Success path: chain builds leaf→anchor, roles assigned, attested
+  // jwks flowed down from the pinned anchor.
+  var chain = await b.auth.openidFederation.buildTrustChain(opts);
+  check("federation chain: leaf-first, anchor-last",
+        chain.length === 3 && chain[0].role === "leaf" &&
+        chain[1].role === "intermediate" && chain[2].role === "trust_anchor");
+  check("federation chain: leaf carries superior-signed subordinate statement",
+        chain[0].subordinate && chain[0].subordinate.iss === INT && chain[0].subordinate.sub === LEAF);
+
+  // M2: the SUPERIOR-SIGNED metadata_policy is enforced (anchor→leaf,
+  // narrow-only). `value` forces scope down to "openid"; subset_of
+  // confirms the leaf's lone redirect_uri is within the allowed set.
+  var resolved = await b.auth.openidFederation.resolveLeaf(Object.assign({ kind: "openid_relying_party" }, opts));
+  check("federation M2: superior-signed value narrows leaf scope",
+        resolved.effectiveMetadata.scope === "openid");
+  check("federation M2: leaf redirect_uri within superior subset_of accepted",
+        Array.isArray(resolved.effectiveMetadata.redirect_uris) &&
+        resolved.effectiveMetadata.redirect_uris.length === 1 &&
+        resolved.effectiveMetadata.redirect_uris[0] === "https://leaf.example/cb");
+}
+
+async function testFederationSubsetOfRefusesWidening() {
+  // M2 refutation: a leaf that declares a redirect_uri OUTSIDE the
+  // superior-signed subset_of must be REFUSED — the leaf cannot widen
+  // past the anchor/intermediate constraint by self-declaration.
+  var threw = null;
+  try {
+    b.auth.openidFederation.applyMetadataPolicy(
+      { redirect_uris: ["https://leaf.example/cb", "https://leaf.example/evil"] },
+      [{ subordinate: { metadata_policy: { openid_relying_party: {
+          redirect_uris: { subset_of: ["https://leaf.example/cb"] } } } } }],
+      "openid_relying_party");
+  } catch (e) { threw = e; }
+  check("federation M2: leaf redirect_uri outside superior subset_of refused",
+        threw && threw.code === "auth-openid-federation/policy-subset-of-failed");
+
+  // And the leaf's OWN self-config can't relax that subset — self-config
+  // policy is never read, so a self-declared wide subset is ignored while
+  // the superior subset still binds.
+  var eff = b.auth.openidFederation.applyMetadataPolicy(
+    { scope: "openid" },
+    [{ claims:      { metadata_policy: { openid_relying_party: { scope: { value: "admin" } } } },
+      subordinate: { metadata_policy: { openid_relying_party: { scope: { value: "openid" } } } } }],
+    "openid_relying_party");
+  check("federation M2: superior value wins over leaf self-config",
+        eff.scope === "openid");
+}
+
+async function testFederationSubordinateVerifiedAgainstAttestedKeys() {
+  // M5: the intermediate's SELF-PUBLISHED config jwks differ from the
+  // jwks the anchor ATTESTS for it. An attacker controlling the
+  // intermediate endpoint serves attacker keys in the self-config AND
+  // signs the leaf's subordinate statement with those attacker keys.
+  // The verifier MUST verify the leaf statement against the
+  // anchor-attested (genuine) intermediate keys, so the attacker-signed
+  // statement is rejected.
+  var ANCHOR = "https://anchor.example";
+  var INT    = "https://intermediate.example";
+  var LEAF   = "https://leaf.example";
+
+  var anchor    = _fedEntity("anchor-1");
+  var interReal = _fedEntity("inter-1");        // anchor attests THESE keys
+  // The attacker self-publishes a DIFFERENT keypair under the SAME kid so
+  // the kid lookup matches the attested key slot — the only thing that
+  // can stop it is verifying against the attested key bytes (signature
+  // mismatch), which is exactly what the fix does.
+  var interEvil = _fedEntity("inter-1");        // same kid, different key
+  var leaf      = _fedEntity("leaf-1");
+
+  var anchorCfg = _signEntityStatement(anchor, { iss: ANCHOR, sub: ANCHOR, jwks: anchor.jwks });
+  // Intermediate self-config: ATTACKER keys (TOCTOU — served at the
+  // self-config fetch). Self-signed with the attacker key so the
+  // self-statement integrity check passes.
+  var interCfg  = _signEntityStatement(interEvil, { iss: INT, sub: INT, jwks: interEvil.jwks, authority_hints: [ANCHOR] });
+  var leafCfg   = _signEntityStatement(leaf, { iss: LEAF, sub: LEAF, jwks: leaf.jwks, authority_hints: [INT] });
+
+  // Anchor attests the REAL intermediate keys.
+  var subAboutInter = _signEntityStatement(anchor, { iss: ANCHOR, sub: INT, jwks: interReal.jwks });
+  // The leaf's subordinate statement is signed with the ATTACKER key
+  // (interEvil) — it verifies against interEvil's self-published jwks
+  // (the pre-fix path) but NOT against the anchor-attested interReal keys.
+  var subAboutLeaf = _signEntityStatement(interEvil, { iss: INT, sub: LEAF, jwks: leaf.jwks });
+
+  function _fetcher(url) {
+    if (url === ANCHOR + "/.well-known/openid-federation") return Promise.resolve(anchorCfg);
+    if (url === INT + "/.well-known/openid-federation")    return Promise.resolve(interCfg);
+    if (url === LEAF + "/.well-known/openid-federation")   return Promise.resolve(leafCfg);
+    return Promise.reject(new Error("404 " + url));
+  }
+  function _fetchSubordinate(authority, sub) {
+    if (authority === ANCHOR && sub === INT)  return Promise.resolve(subAboutInter);
+    if (authority === INT    && sub === LEAF) return Promise.resolve(subAboutLeaf);
+    return Promise.reject(new Error("no subordinate " + authority + "→" + sub));
+  }
+
+  var threw = null;
+  try {
+    await b.auth.openidFederation.buildTrustChain({
+      leafEntityId: LEAF,
+      trustAnchors: { "https://anchor.example": anchor.jwks },
+      fetcher: _fetcher,
+      fetchSubordinate: _fetchSubordinate,
+    });
+  } catch (e) { threw = e; }
+  // A cryptographic refusal proves the attested-key gate held: the
+  // attacker-signed statement fails against the anchor-attested key bytes.
+  check("federation M5: leaf statement signed by attacker self-jwks is refused",
+        threw && (threw.code === "auth-openid-federation/bad-signature" ||
+                  threw.code === "auth-openid-federation/no-matching-kid"));
+
+  // Positive control: when the leaf statement is signed by the REAL
+  // (anchor-attested) intermediate key, the chain builds.
+  var subAboutLeafGood = _signEntityStatement(interReal, { iss: INT, sub: LEAF, jwks: leaf.jwks });
+  function _fetchSubordinateGood(authority, sub) {
+    if (authority === ANCHOR && sub === INT)  return Promise.resolve(subAboutInter);
+    if (authority === INT    && sub === LEAF) return Promise.resolve(subAboutLeafGood);
+    return Promise.reject(new Error("no subordinate " + authority + "→" + sub));
+  }
+  var built = await b.auth.openidFederation.buildTrustChain({
+    leafEntityId: LEAF,
+    trustAnchors: { "https://anchor.example": anchor.jwks },
+    fetcher: _fetcher,
+    fetchSubordinate: _fetchSubordinateGood,
+  });
+  check("federation M5: leaf statement signed by anchor-attested key builds",
+        built.length === 3 && built[2].role === "trust_anchor");
+  // The attested intermediate key bytes (interReal), not the self-
+  // published attacker key bytes (interEvil), are reflected on the
+  // intermediate node — same kid, so compare the EC x-coordinate.
+  check("federation M5: intermediate node carries anchor-attested key bytes",
+        built[1].claims.jwks &&
+        built[1].claims.jwks.keys[0].x === interReal.jwks.keys[0].x &&
+        built[1].claims.jwks.keys[0].x !== interEvil.jwks.keys[0].x);
 }
 
 // ---- OID4VP DCQL ------------------------------------------------------
@@ -559,7 +783,12 @@ async function testOid4vciX5cProof() {
   await _refusedX5c([""], "empty string entry");
   await _refusedX5c(["@@@not-base64@@@"], "non-base64 entry");
   // base64url chars (- / _) are invalid for x5c (standard base64 only).
-  await _refusedX5c([leafB64.replace(/[+/]/, "-")], "base64url-charset entry");
+  // Inject them unconditionally: leafB64's '+' / '/' population varies per
+  // generated cert, so replacing only the first such char is a no-op on the
+  // ~0.4% of certs that carry neither — which would leave a still-valid cert
+  // that is correctly accepted, making this refusal assertion flake. Prepend
+  // the base64url-only chars so the malformed entry is guaranteed every run.
+  await _refusedX5c(["-_" + leafB64.slice(2)], "base64url-charset entry");
   // valid base64 but not a parseable DER certificate.
   await _refusedX5c([Buffer.from("not a certificate").toString("base64")], "non-DER-cert entry");
 
@@ -790,6 +1019,9 @@ async function run() {
   testSamlSpAuthnRequest();
   testSamlSpRefusesUnsigned();
   testFederationParseAndPolicy();
+  await testFederationTrustChainMultiElement();
+  await testFederationSubsetOfRefusesWidening();
+  await testFederationSubordinateVerifiedAgainstAttestedKeys();
   testDcqlMatch();
   testOid4vciIssuerConfig();
   await testOid4vciKidResolver();

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

@@ -8,9 +8,9 @@
  *   - default behavior unchanged when the new opts are unset;
  *   - deniedDest refuses a "webidentity" (FedCM) Sec-Fetch-Dest on a
  *     non-identity route, regardless of Sec-Fetch-Site;
- *   - allowStorageAccess:false refuses the cross-site
- *     Sec-Fetch-Storage-Access: active|inactive escalation, and "none"
- *     passes through;
+ *   - the cross-site Sec-Fetch-Storage-Access: active|inactive escalation
+ *     is REFUSED BY DEFAULT (v0.15.0), "none" passes through, and
+ *     allowStorageAccess:true opts back in for Storage-Access-flow routes;
  *   - strictDest throws at config time on an unknown destination value;
  *   - membership tests are exact (no substring / prototype-pollution
  *     bypass).
@@ -92,9 +92,9 @@ async function testDeniedDestWebIdentity() {
         allowed.next === true);
 }
 
-// Storage Access API escalation: active|inactive refused when
-// allowStorageAccess:false; none passes through; default (unset) lets it
-// through.
+// Storage Access API escalation: active|inactive REFUSED BY DEFAULT
+// (v0.15.0); none passes through; allowStorageAccess:true opts back in for
+// Storage-Access-flow routes.
 async function testStorageAccessGate() {
   var strict = b.middleware.fetchMetadata({ allowStorageAccess: false });
 
@@ -117,12 +117,23 @@ async function testStorageAccessGate() {
   check("storage-access none on same-origin passes through",
         none.next === true);
 
-  // Default (opt unset) does not refuse the escalation.
+  // Default (opt unset) REFUSES the escalation (v0.15.0) — checked before
+  // the allowCrossSite shortcut, so even a cross-site-permitting mount
+  // refuses the storage-access escalation by default.
   var dflt = b.middleware.fetchMetadata({ allowCrossSite: true });
-  var permitted = await _run(dflt, _post({
+  var refusedByDefault = await _run(dflt, _post({
     "sec-fetch-site": "cross-site", "sec-fetch-storage-access": "active",
   }), _bodyRes());
-  check("storage-access escalation permitted by default",
+  check("storage-access escalation refused by default (opt unset)",
+        refusedByDefault.next === false && refusedByDefault.status === 403);
+
+  // Documented opt-in: allowStorageAccess:true lets the Storage-Access-flow
+  // route through.
+  var optedIn = b.middleware.fetchMetadata({ allowCrossSite: true, allowStorageAccess: true });
+  var permitted = await _run(optedIn, _post({
+    "sec-fetch-site": "cross-site", "sec-fetch-storage-access": "active",
+  }), _bodyRes());
+  check("allowStorageAccess:true opts back in (escalation permitted)",
         permitted.next === true);
 }
 

package/lib/vendor/blamejs/test/layer-0-primitives/file-upload-content-safety-skip-audit.test.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * file-upload — content-safety SKIP is audited.
+ *
+ * When the byte-level content-safety scan does not run for a finalized
+ * upload, an operator reviewing the audit log must be able to tell the
+ * upload bypassed scanning, and WHY. Each skip path emits exactly one
+ * `fileUpload.content_safety_skipped` audit naming the reason:
+ *
+ *   - content-safety-disabled        (contentSafety: null opt-out)
+ *   - no-gate-for-extension          (no gate registered for the ext)
+ *   - streamed-over-reassembly-cap   (upload streamed past the cap)
+ *
+ * The audit is observability-only: a throwing audit sink must NOT crash
+ * the upload (the finalize still returns its result).
+ */
+var nodeOs = require("node:os");
+var nodePath = require("node:path");
+var nodeFs = require("node:fs");
+var nodeCrypto = require("node:crypto");
+var helpers = require("../helpers");
+var check = helpers.check;
+var b = helpers.b;
+
+function _tmpDir(suffix) {
+  var dir = nodePath.join(nodeOs.tmpdir(), "fileupload-skipaudit-" + suffix + "-" +
+    nodeCrypto.randomBytes(6).toString("hex"));
+  nodeFs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return dir;
+}
+function _chunkSha3(buf) { return require("../../lib/crypto").sha3Hash(buf); }
+function _fullSha3(pieces) {
+  var h = nodeCrypto.createHash("sha3-512");
+  for (var i = 0; i < pieces.length; i++) h.update(pieces[i]);
+  return h.digest("hex");
+}
+function _skipEvents(emitted) {
+  return emitted.filter(function (e) {
+    return e.action === "fileUpload.content_safety_skipped";
+  });
+}
+
+// Drive one small (in-memory) upload end-to-end through finalize.
+async function _uploadAndFinalize(u, uploadId, pieces, extra) {
+  await u.init({ uploadId: uploadId, actor: { id: uploadId },
+                 metadata: (extra && extra.metadata) || {} });
+  var total = 0;
+  for (var i = 0; i < pieces.length; i++) {
+    await u.acceptChunk({ uploadId: uploadId, index: i, body: pieces[i],
+                          sha3: _chunkSha3(pieces[i]), actor: { id: uploadId } });
+    total += pieces[i].length;
+  }
+  var manifest = {
+    totalBytes: total,
+    sha3:       _fullSha3(pieces),
+    chunks:     pieces.map(function (p, idx) { return { index: idx, sha3: _chunkSha3(p) }; }),
+  };
+  return u.finalize({ uploadId: uploadId, manifest: manifest, actor: { id: uploadId } });
+}
+
+async function run() {
+  // ---- Skip reason: content-safety-disabled (contentSafety: null) ----
+  {
+    var emitted = [];
+    var fakeAudit = { safeEmit: function (e) { emitted.push(e); } };
+    var u = b.fileUpload.create({
+      stagingDir:    _tmpDir("disabled"),
+      contentSafety: null,
+      filenameSafety: null,
+      audit:         fakeAudit,
+    });
+    emitted.length = 0;  // drop the create-time disable audits
+    var c0 = Buffer.from("plain text body", "utf8");
+    await _uploadAndFinalize(u, "u-disabled", [c0],
+                             { metadata: { filename: "doc.txt" } });
+    var skips = _skipEvents(emitted);
+    check("skip[disabled]: exactly one skip audit", skips.length === 1);
+    check("skip[disabled]: reason names the disable",
+          skips.length === 1 && skips[0].reason === "content-safety-disabled" &&
+          skips[0].metadata && skips[0].metadata.reason === "content-safety-disabled");
+    check("skip[disabled]: outcome is an accepted audit outcome",
+          skips.length === 1 && skips[0].outcome === "success");
+    check("skip[disabled]: metadata carries size",
+          skips.length === 1 && skips[0].metadata.size === c0.length);
+  }
+
+  // ---- Skip reason: no-gate-for-extension ----
+  // contentSafety wired with a gate ONLY for ".csv"; upload a ".txt" so
+  // no gate matches the extension.
+  {
+    var emitted2 = [];
+    var fakeAudit2 = { safeEmit: function (e) { emitted2.push(e); } };
+    var csvGateChecked = false;
+    var u2 = b.fileUpload.create({
+      stagingDir:     _tmpDir("nogate"),
+      filenameSafety: null,
+      contentSafety:  {
+        ".csv": { check: function () { csvGateChecked = true; return { ok: true, action: "serve" }; } },
+      },
+      audit: fakeAudit2,
+    });
+    emitted2.length = 0;
+    var t0 = Buffer.from("not a csv", "utf8");
+    await _uploadAndFinalize(u2, "u-nogate", [t0],
+                             { metadata: { filename: "notes.txt" } });
+    var skips2 = _skipEvents(emitted2);
+    check("skip[no-gate]: the .csv gate was NOT invoked for a .txt", csvGateChecked === false);
+    check("skip[no-gate]: exactly one skip audit", skips2.length === 1);
+    check("skip[no-gate]: reason names the missing gate",
+          skips2.length === 1 && skips2[0].reason === "no-gate-for-extension");
+    check("skip[no-gate]: metadata carries ext",
+          skips2.length === 1 && skips2[0].metadata.ext === ".txt");
+  }
+
+  // ---- A gate that DOES match must NOT emit a skip audit ----
+  {
+    var emitted3 = [];
+    var fakeAudit3 = { safeEmit: function (e) { emitted3.push(e); } };
+    var u3 = b.fileUpload.create({
+      stagingDir:     _tmpDir("matched"),
+      filenameSafety: null,
+      contentSafety:  {
+        ".txt": { check: function () { return { ok: true, action: "serve" }; } },
+      },
+      audit: fakeAudit3,
+    });
+    emitted3.length = 0;
+    var m0 = Buffer.from("scanned body", "utf8");
+    await _uploadAndFinalize(u3, "u-matched", [m0],
+                             { metadata: { filename: "scan.txt" } });
+    check("scan[matched]: gate ran → NO skip audit emitted",
+          _skipEvents(emitted3).length === 0);
+  }
+
+  // ---- Skip reason: streamed-over-reassembly-cap ----
+  // Force the streaming path by setting maxStreamReassemblyBytes below the
+  // upload size, while a gate IS registered for the extension.
+  {
+    var emitted4 = [];
+    var fakeAudit4 = { safeEmit: function (e) { emitted4.push(e); } };
+    var streamGateChecked = false;
+    var u4 = b.fileUpload.create({
+      stagingDir:               _tmpDir("streamed"),
+      filenameSafety:           null,
+      maxStreamReassemblyBytes: 4,   // tiny — anything bigger streams
+      contentSafety:  {
+        ".bin": { check: function () { streamGateChecked = true; return { ok: true, action: "serve" }; } },
+      },
+      audit: fakeAudit4,
+      onFinalize: async function (info) {
+        // Drain the stream so the readable doesn't leak open.
+        if (info.stream) { for await (var _c of info.stream) { void _c; } }
+        return { ok: true, sha3: info.sha3, size: info.size };
+      },
+    });
+    emitted4.length = 0;
+    var big0 = Buffer.from("0123456789", "utf8");   // 10 bytes > 4-byte cap
+    await _uploadAndFinalize(u4, "u-streamed", [big0],
+                             { metadata: { filename: "blob.bin" } });
+    var skips4 = _skipEvents(emitted4);
+    check("skip[streamed]: gate could not run on a streamed body", streamGateChecked === false);
+    check("skip[streamed]: exactly one skip audit", skips4.length === 1);
+    check("skip[streamed]: reason names the reassembly cap",
+          skips4.length === 1 && skips4[0].reason === "streamed-over-reassembly-cap");
+  }
+
+  // ---- A throwing audit sink must NOT crash the upload ----
+  {
+    var u5 = b.fileUpload.create({
+      stagingDir:    _tmpDir("throwing"),
+      contentSafety: null,
+      filenameSafety: null,
+      audit:         { safeEmit: function () { throw new Error("audit sink down"); } },
+    });
+    var s0 = Buffer.from("survives a broken audit sink", "utf8");
+    var rv = null, threw = false;
+    try {
+      rv = await _uploadAndFinalize(u5, "u-throwing", [s0],
+                                    { metadata: { filename: "ok.txt" } });
+    } catch (_e) { threw = true; }
+    check("skip[throwing-sink]: upload finalized despite throwing audit sink",
+          threw === false && rv && rv.ok === true && rv.size === s0.length);
+  }
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e.stack || e); process.exit(1); }
+  );
+}

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

@@ -630,6 +630,94 @@ async function testGuardCsvGateAuditEmission() {
         /\.serve$/.test(emitted[0].action));
 }
 
+async function testGateContractDefineGuard() {
+  // defineGuard assembles a full content-guard module from a spec: error
+  // class, registry exports, buildProfile / compliancePosture /
+  // loadRulePack wiring, the default gate, and the extras pass-through.
+  var GuardDemoError = b.gateContract.GateContractError;
+  var PROFILES = {
+    strict:     { reject: true },
+    balanced:   { reject: false },
+    permissive: { reject: false },
+  };
+  var POSTURES = b.gateContract.ALL_STRICT_POSTURES;
+  var mod = b.gateContract.defineGuard({
+    name:     "demo",
+    kind:     "content",
+    errorClass: GuardDemoError,
+    profiles: PROFILES,
+    defaults: PROFILES.strict,
+    postures: POSTURES,
+    mimeTypes:  ["application/x-demo"],
+    extensions: [".demo"],
+    validate: function (text) {
+      if (text.indexOf("BAD") !== -1) {
+        return { ok: false, issues: [{ kind: "demo.bad", severity: "high", snippet: "BAD token" }] };
+      }
+      return { ok: true, issues: [] };
+    },
+    extra: { TOKENS: ["BAD"] },
+  });
+  check("defineGuard: NAME / KIND set",                 mod.NAME === "demo" && mod.KIND === "content");
+  check("defineGuard: MIME_TYPES / EXTENSIONS frozen",
+        Object.isFrozen(mod.MIME_TYPES) && mod.MIME_TYPES[0] === "application/x-demo" &&
+        mod.EXTENSIONS[0] === ".demo");
+  check("defineGuard: registry triplet assembled",
+        typeof mod.buildProfile === "function" &&
+        typeof mod.compliancePosture === "function" &&
+        typeof mod.loadRulePack === "function" &&
+        typeof mod.gate === "function" && typeof mod.validate === "function");
+  check("defineGuard: extras passed through",           Array.isArray(mod.TOKENS) && mod.TOKENS[0] === "BAD");
+  check("defineGuard: compliancePosture clones overlay",
+        mod.compliancePosture("hipaa") === "strict" || typeof mod.compliancePosture("hipaa") === "object");
+  // Default gate runs the standard serve / refuse chain on ctx.bytes.
+  var g = mod.gate({ profile: "strict" });
+  var serve  = await g.check({ bytes: Buffer.from("ok bytes") });
+  var refuse = await g.check({ bytes: Buffer.from("a BAD value") });
+  check("defineGuard: default gate serves clean bytes",  serve.action === "serve");
+  check("defineGuard: default gate refuses on high issue", !refuse.ok && refuse.action === "refuse");
+  // Prototype-safe extras copy — __proto__ in spec.extra is dropped.
+  var poisoned = b.gateContract.defineGuard({
+    name: "demo2", kind: "filename", errorClass: GuardDemoError,
+    profiles: PROFILES, postures: POSTURES,
+    validate: function () { return { ok: true, issues: [] }; },
+    extra: JSON.parse('{"__proto__":{"polluted":true},"safe":1}'),
+  });
+  check("defineGuard: prototype-pollution key dropped from extras",
+        poisoned.safe === 1 && !({}).polluted);
+}
+
+async function testGateContractDefineParser() {
+  // defineParser assembles the minimal command / safe-* parser shape:
+  // the entry point, PROFILES, COMPLIANCE_POSTURES, a profile-name
+  // compliancePosture, and extras — no gate / buildProfile / loadRulePack.
+  var PROFILES = { strict: { cap: 1 }, balanced: { cap: 2 }, permissive: { cap: 3 } };
+  var mod = b.gateContract.defineParser({
+    name:    "demo-command",
+    entry:   function (line) { return { verb: String(line).toUpperCase() }; },
+    errorClass: b.gateContract.GateContractError,
+    profiles: PROFILES,
+    postures: b.gateContract.ALL_STRICT_POSTURES,
+    extra:   { KNOWN: { NOOP: true } },
+  });
+  check("defineParser: entry exported as validate",      typeof mod.validate === "function");
+  check("defineParser: entry runs",                      mod.validate("noop").verb === "NOOP");
+  check("defineParser: PROFILES / COMPLIANCE_POSTURES exported",
+        mod.PROFILES.strict.cap === 1 && mod.COMPLIANCE_POSTURES.hipaa === "strict");
+  check("defineParser: compliancePosture returns profile name",
+        mod.compliancePosture("hipaa") === "strict");
+  check("defineParser: compliancePosture('nope') → null", mod.compliancePosture("nope") === null);
+  check("defineParser: no gate / buildProfile / loadRulePack",
+        mod.gate === undefined && mod.buildProfile === undefined && mod.loadRulePack === undefined);
+  check("defineParser: extras passed through",           mod.KNOWN.NOOP === true);
+  // Custom entryName.
+  var parserMod = b.gateContract.defineParser({
+    name: "demo-doc", entry: function () { return { ast: true }; }, entryName: "parse",
+    errorClass: b.gateContract.GateContractError, profiles: PROFILES,
+  });
+  check("defineParser: entryName overrides export key",  typeof parserMod.parse === "function" && parserMod.validate === undefined);
+}
+
 async function run() {
   // gateContract foundation
   testGateContractSurface();
@@ -647,6 +735,8 @@ async function run() {
   await testGateContractContentTypeMux();
   await testGateContractBuildProfile();
   await testGateContractBuildProfileCycleDetection();
+  await testGateContractDefineGuard();
+  await testGateContractDefineParser();
 
   // guardCsv surface + behavior
   testGuardCsvSurface();