@blamejs/blamejs-shop 0.5.6 → 0.5.8

package/lib/vendor/blamejs/test/layer-0-primitives/content-credentials-coverage.test.js

@@ -0,0 +1,319 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+/**
+ * b.contentCredentials — error-path + adversarial-input coverage.
+ *
+ * Complements content-credentials.test.js (happy-path + round-trips) by
+ * driving the validation refusals, malformed-input rejections, wrong-state
+ * protocol errors, and fail-closed verdicts the round-trip tests never
+ * reach: bad build opts, missing required fields, signCose timestamp-
+ * posture and reuse-signature refusals, verifyCose malformed-CBOR / bad
+ * hashAlg / wrong-key verdicts, CAWG identity-assertion shape + trust-
+ * resolution refusals, and the GB 45438-2025 CAC implicit-label gate.
+ */
+
+var helpers = require("../helpers");
+var b     = helpers.b;
+var check = helpers.check;
+var nodeCrypto = require("node:crypto");
+
+var cc = b.contentCredentials;
+
+// Capture the error a thrower raises (or null when it does not throw) —
+// one definition so the many config-time refusal checks below don't each
+// re-roll a `threw = null; try {} catch {}` block.
+function _err(fn) {
+  try { fn(); return null; } catch (e) { return e; }
+}
+
+var VALID_BUILD = {
+  provider: "Acme AI Inc.", system: "acme-image-v3",
+  systemVersion: "3.2.1", contentId: "img-001",
+};
+function _buildOpts(overrides) {
+  return Object.assign({}, VALID_BUILD, overrides);
+}
+
+async function run() {
+  var e;
+
+  // ---- build() / _validateBuildOpts adversarial input ----
+  check("build(null) rejected as bad-opts",
+    (e = _err(function () { cc.build(null); })) && e.code === "content-credentials/bad-opts");
+  check("build('str') rejected as bad-opts",
+    (e = _err(function () { cc.build("nope"); })) && e.code === "content-credentials/bad-opts");
+
+  check("build missing system rejected",
+    (e = _err(function () { cc.build({ provider: "x", systemVersion: "1.0.0", contentId: "y" }); })) &&
+    e.code === "MISSING_SYSTEM");
+  check("build missing systemVersion rejected",
+    (e = _err(function () { cc.build({ provider: "x", system: "s", contentId: "y" }); })) &&
+    e.code === "MISSING_SYSTEMVERSION");
+  check("build missing contentId rejected",
+    (e = _err(function () { cc.build({ provider: "x", system: "s", systemVersion: "1.0.0" }); })) &&
+    e.code === "MISSING_CONTENTID");
+
+  check("build provider over 256 chars rejected",
+    (e = _err(function () { cc.build(_buildOpts({ provider: "a".repeat(257) })); })) &&
+    e.code === "content-credentials/bad-provider");
+  check("build system with illegal chars rejected",
+    (e = _err(function () { cc.build(_buildOpts({ system: "has space!" })); })) &&
+    e.code === "content-credentials/bad-system");
+  check("build systemVersion over 64 chars rejected",
+    (e = _err(function () { cc.build(_buildOpts({ systemVersion: "1.0.0-" + "a".repeat(60) })); })) &&
+    e.code === "content-credentials/bad-version");
+  check("build contentId with illegal chars rejected",
+    (e = _err(function () { cc.build(_buildOpts({ contentId: "bad id!" })); })) &&
+    e.code === "content-credentials/bad-content-id");
+  check("build contentSha3 wrong length rejected",
+    (e = _err(function () { cc.build(_buildOpts({ contentSha3: "abc123" })); })) &&
+    e.code === "content-credentials/bad-content-hash");
+  check("build contentSha3 non-hex rejected",
+    (e = _err(function () { cc.build(_buildOpts({ contentSha3: "z".repeat(128) })); })) &&
+    e.code === "content-credentials/bad-content-hash");
+
+  // Valid optional fields flow through (providerContact / sha3 / visibleDisclosure).
+  var mFull = cc.build(_buildOpts({
+    providerContact: "https://acme.example/contact",
+    contentType: "image/png", contentSha3: "a".repeat(128),
+    visibleDisclosure: "AI-generated by Acme",
+  }));
+  check("build carries optional contentSha3", mFull.content.sha3_512 === "a".repeat(128));
+  check("build carries providerContact", mFull.provider.contact === "https://acme.example/contact");
+  check("build carries visibleDisclosure", mFull.visibleDisclosure === "AI-generated by Acme");
+
+  // Adversarial numeric generatedAt (NaN) must not yield a manifest whose
+  // ISO timestamp is a broken value — either a clean rejection or a valid
+  // ISO string is acceptable; an unparseable generatedAtIso is not.
+  var nanRes = null, nanErr = null;
+  try { nanRes = cc.build(_buildOpts({ generatedAt: NaN })); } catch (ne) { nanErr = ne; }
+  check("build NaN generatedAt: rejected or valid ISO (no Invalid-Date manifest)",
+    nanErr !== null || (nanRes && !isNaN(Date.parse(nanRes.generatedAtIso))));
+
+  // ---- required() ----
+  check("required(null) returns opts-required",
+    JSON.stringify(cc.required(null)) === JSON.stringify(["opts-required"]));
+  check("required('str') returns opts-required",
+    JSON.stringify(cc.required("x")) === JSON.stringify(["opts-required"]));
+  var reqNonString = cc.required({ provider: 123, system: "s", systemVersion: "1.0.0", contentId: "c" });
+  check("required treats non-string provider as missing",
+    reqNonString.length === 1 && reqNonString[0] === "missing-provider");
+
+  // ---- sign() ----
+  var pair = b.crypto.generateSigningKeyPair("ml-dsa-87");
+  var manifest = cc.build(VALID_BUILD);
+
+  check("sign(null) rejected as bad-manifest",
+    (e = _err(function () { cc.sign(null, { privateKeyPem: pair.privateKey }); })) &&
+    e.code === "content-credentials/bad-manifest");
+  check("sign missing privateKeyPem rejected",
+    (e = _err(function () { cc.sign(manifest, {}); })) && e.code === "BAD_KEY");
+  check("sign no opts rejected",
+    (e = _err(function () { cc.sign(manifest); })) && e.code === "BAD_KEY");
+
+  // ---- verify() fail-closed verdicts (never throws) ----
+  var env = cc.sign(manifest, { privateKeyPem: pair.privateKey, audit: false });
+  check("verify(null) returns envelope-shape", cc.verify(null, pair.publicKey, { audit: false }).reason === "envelope-shape");
+  check("verify({}) returns envelope-shape", cc.verify({}, pair.publicKey, { audit: false }).reason === "envelope-shape");
+  check("verify empty signature returns envelope-shape",
+    cc.verify({ manifest: manifest, signature: "" }, pair.publicKey, { audit: false }).reason === "envelope-shape");
+  check("verify non-string key returns public-key-required",
+    cc.verify(env, 123, { audit: false }).reason === "public-key-required");
+  check("verify empty key returns public-key-required",
+    cc.verify(env, "", { audit: false }).reason === "public-key-required");
+
+  // A cryptographically valid signature over a payload that is NOT a
+  // complete SB-942 manifest must still fail the required-field gate.
+  var envPartial = cc.sign({ foo: "bar" }, { privateKeyPem: pair.privateKey, audit: false });
+  var vPartial = cc.verify(envPartial, pair.publicKey, { audit: false });
+  check("verify valid-sig-but-incomplete-manifest returns missing-required",
+    vPartial.valid === false && vPartial.reason.indexOf("missing-required") === 0);
+
+  // ---- signCose() config-time refusals ----
+  check("signCose(null) rejected as bad-manifest",
+    (e = _err(function () { cc.signCose(null, { privateKeyPem: pair.privateKey }); })) &&
+    e.code === "content-credentials/bad-manifest");
+  check("signCose missing privateKeyPem rejected",
+    (e = _err(function () { cc.signCose(manifest, { alg: "ml-dsa-87", timestamp: false, timestampOptOutReason: "x" }); })) &&
+    e.code === "BAD_KEY");
+  check("signCose timestamp as string rejected",
+    (e = _err(function () { cc.signCose(manifest, { privateKeyPem: pair.privateKey, timestamp: "soon" }); })) &&
+    e.code === "content-credentials/bad-timestamp");
+  check("signCose timestamp as array rejected",
+    (e = _err(function () { cc.signCose(manifest, { privateKeyPem: pair.privateKey, timestamp: [] }); })) &&
+    e.code === "content-credentials/bad-timestamp");
+  check("signCose timestamp with unknown key rejected",
+    (e = _err(function () { cc.signCose(manifest, { privateKeyPem: pair.privateKey, timestamp: { bogus: 1 } }); })) &&
+    /unknown option/.test(e.message));
+  check("signCose timestamp.token non-Buffer rejected",
+    (e = _err(function () { cc.signCose(manifest, { privateKeyPem: pair.privateKey, timestamp: { token: "not-a-buffer" } }); })) &&
+    e.code === "content-credentials/bad-timestamp-token");
+  check("signCose timestamp.signature empty rejected",
+    (e = _err(function () { cc.signCose(manifest, { privateKeyPem: pair.privateKey, timestamp: { token: Buffer.from([1]), signature: "" } }); })) &&
+    e.code === "content-credentials/bad-reuse-signature");
+
+  // Reused (pinned) signature that does not verify against this manifest+key
+  // is refused — a stale or foreign signature can't be re-embedded.
+  check("signCose reuse-signature that does not verify is refused",
+    (e = _err(function () {
+      cc.signCose(manifest, { privateKeyPem: pair.privateKey,
+        timestamp: { token: Buffer.from([1, 2, 3]), signature: nodeCrypto.randomBytes(32).toString("base64") } });
+    })) && e.code === "content-credentials/reuse-signature-mismatch");
+
+  // certChain emission — single-cert and multi-cert branches (bytes are
+  // carried opaquely; a non-Buffer entry is rejected, not silently kept).
+  var coseSingle = cc.signCose(manifest, {
+    privateKeyPem: pair.privateKey, timestamp: false, timestampOptOutReason: "x",
+    certChain: [Buffer.from([1, 2, 3])], audit: false,
+  });
+  var coseMulti = cc.signCose(manifest, {
+    privateKeyPem: pair.privateKey, timestamp: false, timestampOptOutReason: "x",
+    certChain: [Buffer.from([1, 2, 3]), Buffer.from([4, 5, 6])], audit: false,
+  });
+  check("signCose single-cert certChain produces COSE bytes", Buffer.isBuffer(coseSingle.coseSign1));
+  check("signCose multi-cert certChain grows COSE bytes", coseMulti.coseSign1.length > coseSingle.coseSign1.length);
+  check("signCose non-Buffer certChain entry is rejected (throws)",
+    _err(function () {
+      cc.signCose(manifest, { privateKeyPem: pair.privateKey, timestamp: false,
+        timestampOptOutReason: "x", certChain: ["not a buffer"] });
+    }) !== null);
+
+  // ---- verifyCose() fail-closed verdicts (never throws) ----
+  var optout = cc.signCose(manifest, {
+    privateKeyPem: pair.privateKey, alg: "ml-dsa-87",
+    timestamp: false, timestampOptOutReason: "no TSA in test", audit: false,
+  });
+  check("verifyCose bad timestampHashAlg returns bad-tst-hash verdict",
+    cc.verifyCose(optout.coseSign1, pair.publicKey, { timestampHashAlg: "MD5", audit: false }).reason === "content-credentials/bad-tst-hash");
+  check("verifyCose non-CBOR (0x00) returns cose-malformed verdict",
+    cc.verifyCose(Buffer.from([0x00]), pair.publicKey, { audit: false }).reason === "content-credentials/cose-malformed");
+  check("verifyCose undecodable CBOR (0xff) returns cose-malformed verdict",
+    cc.verifyCose(Buffer.from([0xff]), pair.publicKey, { audit: false }).reason === "content-credentials/cose-malformed");
+  var otherPair = b.crypto.generateSigningKeyPair("ml-dsa-87");
+  var vWrongKey = cc.verifyCose(optout.coseSign1, otherPair.publicKey, { requireTimestamp: false, audit: false });
+  check("verifyCose wrong key returns signature-mismatch verdict",
+    vWrongKey.valid === false && vWrongKey.reason === "signature-mismatch");
+
+  // ---- attachIdentityAssertion() config-time refusals ----
+  var refs = [{ label: "c2pa.actions", data: { action: "c2pa.created" } }];
+  check("attach() no args rejected (bad binding)",
+    (e = _err(function () { cc.attachIdentityAssertion(); })) && e.code === "content-credentials/bad-identity-binding");
+  check("attach subject non-object rejected",
+    (e = _err(function () { cc.attachIdentityAssertion({ binding: "x509", subject: "nope", referencedAssertions: refs, privateKeyPem: pair.privateKey }); })) &&
+    e.code === "content-credentials/bad-identity-subject");
+  check("attach subject array rejected",
+    (e = _err(function () { cc.attachIdentityAssertion({ binding: "x509", subject: [], referencedAssertions: refs, privateKeyPem: pair.privateKey }); })) &&
+    e.code === "content-credentials/bad-identity-subject");
+  check("attach subject empty object rejected",
+    (e = _err(function () { cc.attachIdentityAssertion({ binding: "x509", subject: {}, referencedAssertions: refs, privateKeyPem: pair.privateKey }); })) &&
+    e.code === "content-credentials/bad-identity-subject");
+  check("attach referencedAssertions non-array rejected",
+    (e = _err(function () { cc.attachIdentityAssertion({ binding: "x509", subject: { name: "x" }, referencedAssertions: "nope", privateKeyPem: pair.privateKey }); })) &&
+    e.code === "content-credentials/bad-referenced-assertions");
+  check("attach referencedAssertions empty rejected",
+    (e = _err(function () { cc.attachIdentityAssertion({ binding: "x509", subject: { name: "x" }, referencedAssertions: [], privateKeyPem: pair.privateKey }); })) &&
+    e.code === "content-credentials/bad-referenced-assertions");
+  check("attach missing privateKeyPem rejected",
+    (e = _err(function () { cc.attachIdentityAssertion({ binding: "x509", subject: { name: "x" }, referencedAssertions: refs }); })) &&
+    e.code === "BAD_KEY");
+  check("attach unknown opt key rejected",
+    (e = _err(function () { cc.attachIdentityAssertion({ binding: "x509", subject: { name: "x" }, referencedAssertions: refs, privateKeyPem: pair.privateKey, bogus: 1 }); })) &&
+    /unknown option/.test(e.message));
+
+  // ---- verifyIdentityAssertion() fail-closed verdicts (never throws) ----
+  var ia = cc.attachIdentityAssertion({
+    binding: "x509", subject: { name: "Acme Newsroom" },
+    referencedAssertions: refs, privateKeyPem: pair.privateKey, audit: false,
+  });
+  check("verifyIdentity null assertion returns assertion-shape",
+    cc.verifyIdentityAssertion(null, pair.publicKey, { referencedAssertions: refs }).reason === "assertion-shape");
+  check("verifyIdentity missing signer_payload returns assertion-shape",
+    cc.verifyIdentityAssertion({ signature: "x" }, pair.publicKey, { referencedAssertions: refs }).reason === "assertion-shape");
+  check("verifyIdentity non-string key returns public-key-required",
+    cc.verifyIdentityAssertion(ia, 123, { referencedAssertions: refs }).reason === "public-key-required");
+  check("verifyIdentity bad signer_payload binding returns signer-payload-shape",
+    cc.verifyIdentityAssertion({ signer_payload: { binding: "bogus", referenced_assertions: [] }, signature: "AA==" }, pair.publicKey, { referencedAssertions: refs }).reason === "signer-payload-shape");
+  check("verifyIdentity missing referencedAssertions opt returns referenced-assertions-required",
+    cc.verifyIdentityAssertion(ia, pair.publicKey, { audit: false }).reason === "referenced-assertions-required");
+  check("verifyIdentity referencedAssertions count mismatch returns count-mismatch",
+    cc.verifyIdentityAssertion(ia, pair.publicKey, { referencedAssertions: [refs[0], { label: "b" }], audit: false }).reason === "referenced-assertions-count-mismatch");
+
+  // x509 trust-resolution reason branches (self-asserted -> verified:false).
+  var vNoChain = cc.verifyIdentityAssertion(ia, pair.publicKey, {
+    referencedAssertions: refs, identityTrustAnchorsPem: "anchor-pem", audit: false,
+  });
+  check("verifyIdentity anchor but no chain -> verified:false no-cert-chain",
+    vNoChain.valid === true && vNoChain.verified === false && vNoChain.reason === "no-cert-chain");
+  var vBadAnchors = cc.verifyIdentityAssertion(ia, pair.publicKey, {
+    referencedAssertions: refs, identityCertChainPem: "chain-pem", identityTrustAnchorsPem: "", audit: false,
+  });
+  check("verifyIdentity empty trust anchor -> verified:false bad-trust-anchors",
+    vBadAnchors.verified === false && vBadAnchors.reason === "bad-trust-anchors");
+  var vBadChain = cc.verifyIdentityAssertion(ia, pair.publicKey, {
+    referencedAssertions: refs, identityCertChainPem: "not a pem", identityTrustAnchorsPem: "also not a pem", audit: false,
+  });
+  check("verifyIdentity unparseable chain cert -> verified:false bad-chain-cert",
+    vBadChain.verified === false && vBadChain.reason === "bad-chain-cert");
+
+  // ---- cacImplicitLabel() GB 45438-2025 gate ----
+  var CAC_VALID = {
+    providerName: "Example AI", providerCode: "91110000600037341A",
+    contentId: "asset-2026-05-17-abc123", contentKind: "image",
+    generatedAt: "2026-05-17T20:00:00Z",
+  };
+  function _cac(overrides) { return Object.assign({}, CAC_VALID, overrides); }
+
+  var label = cc.cacImplicitLabel(CAC_VALID);
+  check("cacImplicitLabel valid returns frozen AIGC block",
+    Object.isFrozen(label) && label.aigcMarker === "AIGC" && label.providerCode === "91110000600037341A");
+  check("cacImplicitLabel(null) rejected",
+    (e = _err(function () { cc.cacImplicitLabel(null); })) && e.code === "cac-implicit-label/bad-opts");
+  check("cacImplicitLabel missing providerName rejected",
+    (e = _err(function () { cc.cacImplicitLabel(_cac({ providerName: undefined })); })) &&
+    e.code === "cac-implicit-label/bad-provider-name");
+  check("cacImplicitLabel oversize providerName rejected",
+    (e = _err(function () { cc.cacImplicitLabel(_cac({ providerName: "a".repeat(257) })); })) &&
+    e.code === "cac-implicit-label/oversize-provider-name");
+  check("cacImplicitLabel bad providerCode rejected",
+    (e = _err(function () { cc.cacImplicitLabel(_cac({ providerCode: "123" })); })) &&
+    e.code === "cac-implicit-label/bad-provider-code");
+  check("cacImplicitLabel illegal contentId rejected",
+    (e = _err(function () { cc.cacImplicitLabel(_cac({ contentId: "bad id!" })); })) &&
+    e.code === "cac-implicit-label/bad-content-id");
+  check("cacImplicitLabel unknown contentKind rejected",
+    (e = _err(function () { cc.cacImplicitLabel(_cac({ contentKind: "hologram" })); })) &&
+    e.code === "cac-implicit-label/bad-content-kind");
+  check("cacImplicitLabel non-ISO generatedAt rejected",
+    (e = _err(function () { cc.cacImplicitLabel(_cac({ generatedAt: "yesterday" })); })) &&
+    e.code === "cac-implicit-label/bad-generated-at");
+
+  // ---- cacImplicitLabelRead() parser ----
+  check("cacImplicitLabelRead object input",
+    cc.cacImplicitLabelRead(Object.assign({ aigcMarker: "AIGC" }, CAC_VALID)).aigcMarker === "AIGC");
+  check("cacImplicitLabelRead string input",
+    cc.cacImplicitLabelRead(JSON.stringify(Object.assign({ aigcMarker: "AIGC" }, CAC_VALID))).contentKind === "image");
+  check("cacImplicitLabelRead Buffer input",
+    cc.cacImplicitLabelRead(Buffer.from(JSON.stringify(Object.assign({ aigcMarker: "AIGC" }, CAC_VALID)))).providerCode === "91110000600037341A");
+  check("cacImplicitLabelRead malformed JSON string rejected",
+    (e = _err(function () { cc.cacImplicitLabelRead("{not json"); })) && e.code === "cac-implicit-label/bad-json");
+  check("cacImplicitLabelRead malformed JSON Buffer rejected",
+    (e = _err(function () { cc.cacImplicitLabelRead(Buffer.from("{not json")); })) && e.code === "cac-implicit-label/bad-json");
+  check("cacImplicitLabelRead numeric input rejected",
+    (e = _err(function () { cc.cacImplicitLabelRead(42); })) && e.code === "cac-implicit-label/bad-input");
+  check("cacImplicitLabelRead missing AIGC marker rejected",
+    (e = _err(function () { cc.cacImplicitLabelRead({ providerName: "x" }); })) &&
+    e.code === "cac-implicit-label/missing-aigc-marker");
+  check("cacImplicitLabelRead re-applies field gate",
+    (e = _err(function () { cc.cacImplicitLabelRead(Object.assign({ aigcMarker: "AIGC" }, CAC_VALID, { providerCode: "BAD" })); })) &&
+    e.code === "cac-implicit-label/bad-provider-code");
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[content-credentials-coverage] 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/cycle2-bugfixes.test.js

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+/**
+ * Behavioral regression tests for the error/adversarial-branch defects found
+ * while raising coverage on metrics / safe-buffer / tus-upload / guard-sql /
+ * mcp / safe-yaml / content-credentials. Each assertion reproduces a specific
+ * failure: it fails on the pre-fix tree (RED) and passes on the fixed tree.
+ *
+ * Run standalone: `node test/layer-0-primitives/cycle2-bugfixes.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers    = require("../helpers");
+var b          = helpers.b;
+var check      = helpers.check;
+var nodeCrypto = require("crypto");
+var Readable   = require("stream").Readable;
+
+function threwCode(fn) {
+  try { fn(); return null; } catch (e) { return e.code || null; }
+}
+function threw(fn) {
+  try { fn(); return false; } catch (_e) { return true; }
+}
+
+async function main() {
+  // ---- metrics: credential redaction reaches the exposition stream (HIGH) ----
+  var m1 = b.metrics.create({ namespace: "p" });
+  var c1 = m1.counter("logins_total", { labelNames: ["authorization"] });
+  c1.inc({ authorization: "Bearer aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" });
+  var out = m1.exposition();
+  check("metrics: credential label redacted in exposition, not just the map key",
+    out.indexOf("[REDACTED-CREDENTIAL]") !== -1 && out.indexOf("Bearer aaaa") === -1);
+
+  // ---- metrics: +/-Infinity rejected as non-finite (was isNaN-only) ----
+  var m2 = b.metrics.create({ namespace: "q" });
+  check("metrics: gauge.set(Infinity) rejected", threw(function () { m2.gauge("g", {}).set(Infinity); }));
+  check("metrics: counter.inc(Infinity) rejected", threw(function () { m2.counter("c", {}).inc(Infinity); }));
+  check("metrics: histogram.observe(Infinity) rejected",
+    threw(function () { m2.histogram("h", { buckets: [0.5] }).observe(Infinity); }));
+  check("metrics: gauge.set(42) still accepted", !threw(function () { m2.gauge("g2", {}).set(42); }));
+
+  // ---- safe-buffer.collectStream: a defineClass errorClass keeps code/message
+  //      the right way round (was swapped -> callers branching on e.code missed) ----
+  var MyError = b.frameworkError.defineClass("CollectProbeError", { alwaysPermanent: true });
+  var stream = new Readable({ read: function () {} });
+  var caught = null;
+  var p = b.safeBuffer.collectStream(stream, {
+    maxBytes: b.constants.BYTES.bytes(4), errorClass: MyError,
+    sizeCode: "probe/too-large", sizeMessage: "body exceeded max",
+  }).then(function () { /* unexpected */ }, function (e) { caught = e; });
+  stream.push(Buffer.from("way too many bytes"));
+  stream.push(null);
+  await p;
+  check("safe-buffer: collectStream defineClass error keeps .code = sizeCode (not swapped)",
+    !!caught && caught.code === "probe/too-large" && caught.message === "body exceeded max");
+
+  // ---- guard-sql: fragment embedded-literal floor covers dollar-quotes + lone ; ----
+  function frag(s) { return b.guardSql.validate(s, { contextMode: "fragment", profile: "strict" }).ok; }
+  check("guard-sql: $tag$ dollar-quote refused in fragment", frag("x = $tag$secret$tag$") === false);
+  check("guard-sql: $$ empty-tag dollar-quote refused", frag("x = $$secret$$") === false);
+  check("guard-sql: lone trailing ; refused in fragment", frag("x = 1;") === false);
+  check("guard-sql: single-quote literal still refused", frag("x = 'secret'") === false);
+  check("guard-sql: ? placeholder still passes", frag("x = ?") === true);
+
+  // ---- mcp: validation gates enforce without an explicit top-level type:object ----
+  var inferredObjSchema = { properties: { path: { type: "string" } }, required: ["path"] };
+  check("mcp: validateToolInput enforces required with no type:object (fail-open closed)",
+    threw(function () { b.mcp.validateToolInput("t", {}, inferredObjSchema); }));
+  check("mcp: validateToolInput rejects a scalar for an inferred object schema",
+    threw(function () { b.mcp.validateToolInput("t", "oops", inferredObjSchema); }));
+  check("mcp: validateToolInput rejects an array for an inferred object schema",
+    threw(function () { b.mcp.validateToolInput("t", ["x"], inferredObjSchema); }));
+  check("mcp: validateToolInput rejects null for an inferred object schema",
+    threw(function () { b.mcp.validateToolInput("t", null, inferredObjSchema); }));
+  check("mcp: validateToolInput still accepts a valid object for an inferred object schema",
+    !threw(function () { b.mcp.validateToolInput("t", { path: "ok" }, inferredObjSchema); }));
+  check("mcp: assertProtocolVersion honors explicit empty accepted:[]",
+    threw(function () {
+      b.mcp.assertProtocolVersion({ headers: { "mcp-protocol-version": "2024-11-05" } }, { accepted: [] });
+    }));
+  var sg = b.mcp.sampling.guard({ maxTokensPerRequest: 100 });
+  check("mcp: sampling.guard rejects a string maxTokens (type-confusion)",
+    threw(function () { sg.enforce({ messages: [{ role: "user", content: "x" }], maxTokens: "999999" }, "sid"); }));
+
+  // ---- mcp serverGuard middleware (async): /register/ refusal + 401 challenge ----
+  async function drive(guard, req) {
+    var captured = { status: 200, headers: {}, nexted: false };
+    var res = {
+      statusCode: 200,
+      setHeader: function (k, v) { captured.headers[k.toLowerCase()] = v; },
+      end: function () { captured.status = this.statusCode; },
+    };
+    await guard(req, res, function () { captured.nexted = true; });
+    return captured;
+  }
+  var gReg = b.mcp.serverGuard({ requireBearer: false });
+  check("mcp: /register/ (trailing slash) refused like /register",
+    (await drive(gReg, { url: "/register/", method: "POST", headers: {} })).nexted === false);
+  var gBear = b.mcp.serverGuard({ requireBearer: true, verifyBearer: function () { return { sub: "x" }; } });
+  var bearCap = await drive(gBear, { url: "/", method: "POST", headers: {} });
+  check("mcp: missing bearer challenge returns 401 (was 400)",
+    bearCap.status === 401 && !!bearCap.headers["www-authenticate"]);
+
+  // ---- safe-yaml: flow-style parity with block style + root flow correctness ----
+  check("safe-yaml: flow-mapping duplicate key rejected",
+    threwCode(function () { b.parsers.yaml.parse("root: {a: 1, a: 2}"); }) === "yaml/duplicate-key");
+  check("safe-yaml: flow-mapping merge key '<<' rejected",
+    threwCode(function () { b.parsers.yaml.parse("root: {<<: base}"); }) === "yaml/merge-key-banned");
+  check("safe-yaml: trailing content after flow collection rejected",
+    threwCode(function () { b.parsers.yaml.parse("root: [1, 2] junk"); }) === "yaml/trailing-content");
+  check("safe-yaml: root-level JSON object parses correctly (not mis-scanned as block key)",
+    JSON.stringify(b.parsers.yaml.parse('{"a": 1, "b": 2}')) === '{"a":1,"b":2}');
+  check("safe-yaml: root-level flow sequence still parses",
+    JSON.stringify(b.parsers.yaml.parse("[1, 2, 3]")) === "[1,2,3]");
+
+  // ---- content-credentials: immutability + typed rejections ----
+  var m = b.contentCredentials.build({ provider: "Acme", system: "s", systemVersion: "1.0.0", contentId: "c" });
+  var before = m.content.id;
+  try { m.content.id = "HACKED"; } catch (_e) { /* strict-mode throw is fine too */ }
+  check("content-credentials: nested claim object is deep-frozen",
+    m.content.id === before && Object.isFrozen(m.content));
+  check("content-credentials: NaN generatedAt typed-rejected",
+    threwCode(function () {
+      b.contentCredentials.build({ provider: "x", system: "s", systemVersion: "1.0.0", contentId: "c", generatedAt: NaN });
+    }) === "content-credentials/bad-generated-at");
+  var kp = nodeCrypto.generateKeyPairSync("ed25519");
+  var pem = kp.privateKey.export({ type: "pkcs8", format: "pem" });
+  check("content-credentials: non-Buffer certChain entry typed-rejected",
+    threwCode(function () {
+      b.contentCredentials.signCose(m, { privateKeyPem: pem, timestamp: false, timestampOptOutReason: "x", certChain: ["nope"] });
+    }) === "content-credentials/bad-cert-chain");
+}
+
+if (require.main === module) {
+  main().then(function () {
+    console.log("cycle2-bugfixes OK — " + helpers.getChecks() + " checks");
+  }, function (e) { console.error(e); process.exit(1); });
+}
+
+module.exports = { run: main };