@blamejs/blamejs-shop 0.5.5 → 0.5.7

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Layer 0 — b.network.dns.dnssec (local DNSSEC RRSIG verification).
@@ -482,6 +484,40 @@ function testKeyTrapCaps() {
       dnskeyRdata: rd, ds: { keyTag: tag, algorithm: 13, digestType: 2, digest: Buffer.alloc(32) } }); }) === "dnssec/bad-name");
 }
 
+// RFC 4034 §3.1.5: the 32-bit RRSIG inception/expiration fields MUST be
+// compared with RFC 1982 serial-number arithmetic, not magnitude. A
+// validity window that wraps the 2^32-second boundary (inception just
+// below 2^32, expiration just past the wrap) is valid at an instant that
+// is serially inside it; a plain `<` / `>` compare wrongly rejects it as
+// expired. Sign a real synthetic zone with such a window so the bytes
+// verify, then check the window decision at serially-in- and out-of-window
+// instants.
+function testRrsigSerialArithmetic() {
+  function code(fn) { try { fn(); return "NO-THROW"; } catch (e) { return e.code; } }
+  var kp = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+  var rd = _ecDnskey(kp.publicKey);
+  var inc = 0xFFFFFF00;   // ~year 2106, just below 2^32
+  var exp = 0x00010000;   // wrapped past 0
+  var rrsig = _signDnskeyRrset("test.", [rd], kp.privateKey, rd, inc, exp);
+  var digest = nodeCrypto.createHash("sha256").update(Buffer.concat([_canonName("test."), rd])).digest();
+  var anchor = [{ keyTag: b.network.dns.dnssec.keyTag(rd), algorithm: 13, digestType: 2, digest: digest }];
+  function verifyAt(atSer) {
+    return b.network.dns.dnssec.verifyChain({
+      links: [{ zone: "test.", dnskeys: [rd], dnskeyRrsig: rrsig }],
+      trustAnchors: anchor, at: new Date(atSer * 1000),
+    });
+  }
+  // Serially inside the wrapped window (just before the 2^32 wrap): the
+  // magnitude compare wrongly returns dnssec/expired here; serial arithmetic
+  // accepts it and the real signature verifies.
+  var inWindow = verifyAt(0xFFFFFFF0);
+  check("verifyRrset: RRSIG window wrapping 2^32 validates at a serially-in-window instant (RFC 1982)",
+    inWindow.ok === true);
+  // Serially after expiration is still refused.
+  check("verifyRrset: wrapped RRSIG window still refuses a serially-out-of-window instant",
+    code(function () { verifyAt(0x00020000); }) === "dnssec/expired");
+}
+
 async function run() {
   testSurface();
   testRealVectors();
@@ -490,6 +526,7 @@ async function run() {
   testVerifyChain();
   testKeyTrapCaps();
   testDeepChainBudget();
+  testRrsigSerialArithmetic();
   testNsec3Real();
   testNsec3Caps();
   testNsec3OptOut();

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.dora — DORA Article 17 incident-reporting workflow.

package/lib/vendor/blamejs/test/layer-0-primitives/dpop-alg-kty.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.auth.dpop.verify — alg/kty cross-check (alg-confusion family,

package/lib/vendor/blamejs/test/layer-0-primitives/dpop-htu-peergating.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * DPoP htu reconstruction must peer-gate X-Forwarded-Proto / X-Forwarded-Host

package/lib/vendor/blamejs/test/layer-0-primitives/dpop-middleware-replaystore-required.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 // b.middleware.dpop must REQUIRE a replayStore. The store IS the jti-replay
 // defense: without it a captured DPoP proof can be replayed indefinitely — the

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.drRunbook — disaster-recovery runbook generator.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 // b.dsa — EU Digital Services Act (Reg 2022/2065) record-builders:
 // Art. 16 noticeAndAction, Art. 17 statementOfReasons, Art. 15/24(3)

package/lib/vendor/blamejs/test/layer-0-primitives/dsr-state-rules.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 // b.dsr.stateRules + b.dsr.listStateRules — US state DSR drift registry.
 

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Tests for b.dsr — Data Subject Rights workflow primitive (v0.7.104).

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 
 var helpers = require("../helpers");
@@ -115,6 +117,32 @@ async function run() {
   var readyN = consumeResults.filter(function (r) { return r.ready === true; }).length;
   check("concurrent consume: exactly one ready (no double-consume)", readyN === 1);
 
+  // ---- Approver-role gate: wildcard match is segment-aware ----
+  var roleApprovals = b.dualControl.create({
+    namespace:     "test.rolewild",
+    cache:         b.cache.create({ namespace: "dual-role-wild" }),
+    audit:         b.audit,
+    approverRoles: ["security:officer"],
+  });
+  // "security:o*" is a partial-segment wildcard — NOT the segment wildcard
+  // "security:*" — so it must not authorize approval of a flow requiring
+  // "security:officer" (segment-aware match via b.permissions.match, not a raw
+  // string prefix where "security:officer".indexOf("security:o") === 0).
+  var rwReq = await roleApprovals.request({ action: "<test>.rolewild", requestedBy: { id: "alice" } });
+  var rwPartial = await roleApprovals.approve({
+    grantId: rwReq.grantId, approver: { id: "bob", roles: ["security:o*"] },
+  });
+  check("dual-control: partial-segment role 'security:o*' is NOT authorized for 'security:officer'",
+        rwPartial.error === "approver-role-required");
+
+  // A proper segment wildcard "security:*" DOES authorize (legit wildcard kept).
+  var rwReq2 = await roleApprovals.request({ action: "<test>.rolewild2", requestedBy: { id: "alice" } });
+  var rwWild = await roleApprovals.approve({
+    grantId: rwReq2.grantId, approver: { id: "carol", roles: ["security:*"] },
+  });
+  check("dual-control: segment wildcard 'security:*' authorizes approval",
+        !rwWild.error && rwWild.approvedBy && rwWild.approvedBy.length === 1);
+
   // ---- Validation ----
   var threwBadCache = null;
   try { b.dualControl.create({ namespace: "x", cache: {} }); }

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.earlyHints — RFC 8297 103 Early Hints helper.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * Layer 0 — b.eat (RFC 9711 Entity Attestation Token) over b.cwt.

package/lib/vendor/blamejs/test/layer-0-primitives/erase-posture-vacuum.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.cryptoField.eraseRow posture-driven VACUUM cascade.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * events — framework breach-detection signal bus.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * exploit-replay - replay every fixture under test/fixtures/exploit-corpus/

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.externalDb hardening additions:

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.externalDb.migrate — migration runner for an externalDb backend.

package/lib/vendor/blamejs/test/layer-0-primitives/external-db-non-atomic-backend.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 // #343: externalDb.transaction (and the b.outbox built on it) silently
 // non-atomic on a stateless / autocommit-per-statement adapter.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.externalDb v0.6.3 additions:

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.auth.fal — NIST 800-63-4 Federation Assurance Level classifier.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.fapi2 — FAPI 2.0 conformance posture assertion.

package/lib/vendor/blamejs/test/layer-0-primitives/fda-21cfr11.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.fda21cfr11 — 21 CFR Part 11 §11.10(e) audit-content + §11.50(b)

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.fdx — CFPB §1033 / FDX bind primitive.

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.fedcm + b.dbsc — federated credentials + device-bound session

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * v0.8.62 federation / VC slice — Layer 0 coverage for:
@@ -661,6 +663,104 @@ async function testOid4vciKidResolver() {
   check("OID4VCI: resolveKid failure is a typed AuthError", isAuthErr);
 }
 
+// ---- OID4VCI single-use enforcement under concurrency -----------------
+
+async function testOid4vciPreAuthCodeSingleUseConcurrent() {
+  // RFC OID4VCI §3.5 — a pre-authorized_code is single-use. Two concurrent
+  // /token requests bearing the same code both read the entry before either
+  // deletes it; they must NOT both mint an access token.
+  // exchangePreAuthorizedCode gates issuance on winning the atomic
+  // codeStore.del (the losing redemption is refused). RED before the gate:
+  // both resolve with distinct access tokens (two credentials from one code).
+  var iss = b.auth.oid4vci.issuer.create({
+    credentialIssuerUrl: "https://issuer.example",
+    credentialEndpoint:  "https://issuer.example/credential",
+    tokenEndpoint:       "https://issuer.example/token",
+    sdJwtIssuer:         { issue: async function () { return { token: "fake" }; } },
+    supportedCredentials: { "id-card-1": { format: "vc+sd-jwt", vct: "https://x/vct" } },
+  });
+  var offer = await iss.createCredentialOffer({ subject: "u-1", credentialIds: ["id-card-1"] });
+  var results = await Promise.allSettled([
+    iss.exchangePreAuthorizedCode({ preAuthCode: offer.preAuthCode }),
+    iss.exchangePreAuthorizedCode({ preAuthCode: offer.preAuthCode }),
+  ]);
+  var ok = results.filter(function (r) { return r.status === "fulfilled" && r.value && r.value.access_token; });
+  var rejected = results.filter(function (r) { return r.status === "rejected"; });
+  check("OID4VCI: concurrent pre-auth-code redemption mints exactly one access token",
+        ok.length === 1);
+  check("OID4VCI: the losing concurrent pre-auth redemption is refused (already redeemed)",
+        rejected.length === 1 && /already redeemed/.test(rejected[0].reason.message));
+}
+
+async function testOid4vciAccessTokenSingleUseConcurrent() {
+  // A single-use access token (default) must yield exactly ONE credential.
+  // Two concurrent issueCredential calls bearing the same access token both
+  // read it and the same un-rotated c_nonce, so both proofs verify; they must
+  // NOT both mint. The token is claimed (atomic gated delete) BEFORE the mint.
+  // RED before the fix: both resolve with a credential (the post-mint cleanup
+  // delete couldn't stop the race).
+  var aud = "https://issuer.example";
+  var holderKp = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
+  var holderPubJwk = holderKp.publicKey.export({ format: "jwk" });
+  var iss = b.auth.oid4vci.issuer.create({
+    credentialIssuerUrl: aud, credentialEndpoint: aud + "/credential", tokenEndpoint: aud + "/token",
+    sdJwtIssuer:         { issue: async function () { return { token: "fake-sd-jwt" }; } },
+    supportedCredentials: { "id-card-1": { format: "vc+sd-jwt", vct: "https://x/vct" } },
+    resolveKid:          function (kid) { return kid === "holder-key-1" ? holderPubJwk : null; },
+  });
+  var offer  = await iss.createCredentialOffer({ subject: "u-2", credentialIds: ["id-card-1"] });
+  var tokens = await iss.exchangePreAuthorizedCode({ preAuthCode: offer.preAuthCode });
+  var proof  = _signKidProof(holderKp.privateKey, "holder-key-1", aud, tokens.c_nonce);
+  var mk = function () {
+    return iss.issueCredential({ accessToken: tokens.access_token, credentialIdentifier: "id-card-1",
+                                 proof: proof, claims: { given_name: "A" } });
+  };
+  var results = await Promise.allSettled([mk(), mk()]);
+  var ok = results.filter(function (r) { return r.status === "fulfilled" && r.value && r.value.credential; });
+  var rejected = results.filter(function (r) { return r.status === "rejected"; });
+  check("OID4VCI: concurrent issueCredential on a single-use access token mints exactly one credential",
+        ok.length === 1);
+  check("OID4VCI: the losing concurrent issueCredential is refused (access token consumed)",
+        rejected.length === 1 && /already used|consumed/.test(rejected[0].reason.message));
+}
+
+async function testOid4vciAccessTokenRestoredOnIssuerFailure() {
+  // The single-use access token is claimed (atomic delete) BEFORE the mint to
+  // stop a concurrent double-mint. But if the operator's issuer throws (a
+  // transient signer/KMS outage), the token must be RESTORED so the wallet can
+  // retry — claiming it must not permanently burn it when no credential was
+  // returned. RED before the rollback: the retry is refused as access-token-
+  // consumed though no credential was ever issued.
+  var aud = "https://issuer.example";
+  var holderKp = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
+  var holderPubJwk = holderKp.publicKey.export({ format: "jwk" });
+  var failNext = true;
+  var iss = b.auth.oid4vci.issuer.create({
+    credentialIssuerUrl: aud, credentialEndpoint: aud + "/credential", tokenEndpoint: aud + "/token",
+    sdJwtIssuer: { issue: async function () {
+      if (failNext) { failNext = false; throw new Error("transient signer outage"); }
+      return { token: "fake-sd-jwt" };
+    } },
+    supportedCredentials: { "id-card-1": { format: "vc+sd-jwt", vct: "https://x/vct" } },
+    resolveKid: function (kid) { return kid === "holder-key-1" ? holderPubJwk : null; },
+  });
+  var offer  = await iss.createCredentialOffer({ subject: "u-3", credentialIds: ["id-card-1"] });
+  var tokens = await iss.exchangePreAuthorizedCode({ preAuthCode: offer.preAuthCode });
+  var proof  = _signKidProof(holderKp.privateKey, "holder-key-1", aud, tokens.c_nonce);
+  var firstThrew = false;
+  try {
+    await iss.issueCredential({ accessToken: tokens.access_token, credentialIdentifier: "id-card-1",
+                                proof: proof, claims: { given_name: "A" } });
+  } catch (_e) { firstThrew = true; }
+  check("OID4VCI: an issuer failure after claiming the token propagates the error", firstThrew);
+  // Retry with the SAME token + proof — the token was restored (the c_nonce was
+  // not rotated, since the mint failed), so the retry succeeds.
+  var retry = await iss.issueCredential({ accessToken: tokens.access_token, credentialIdentifier: "id-card-1",
+                                          proof: proof, claims: { given_name: "A" } });
+  check("OID4VCI: single-use access token is restored after an issuer failure (retry succeeds)",
+        retry && retry.credential === "fake-sd-jwt");
+}
+
 // ---- OID4VCI x5c proof (RFC 7515 §4.1.6 / OID4VCI §8.2.1.1) -----------
 
 // Build a self-signed P-256 EC leaf certificate (the holder cert the
@@ -1013,9 +1113,30 @@ async function testFileLifecycle() {
   }
 }
 
+function testXmlC14nRejectsDeepNesting() {
+  // The MAX_DEPTH nesting cap must actually fire: an XML nested far deeper
+  // than the cap (but well below the JS stack limit) must be refused, not
+  // parsed. A dead cap leaves the recursive-descent parser open to a
+  // stack-overflow DoS on deeply-nested untrusted XML (SAML / WebDAV input).
+  function deep(n) {
+    var open = "", close = "";
+    for (var i = 0; i < n; i++) { open += "<a>"; close = "</a>" + close; }
+    return "<root>" + open + "x" + close + "</root>";
+  }
+  var threw = null;
+  try { b.xmlC14n.parse(deep(500)); } catch (e) { threw = e; }
+  check("xmlC14n.parse: nesting past the cap is refused (cap fires)",
+    threw && /nesting depth/.test(threw.message || ""));
+  var okThrew = null;
+  try { b.xmlC14n.parse(deep(10)); } catch (e) { okThrew = e; }
+  check("xmlC14n.parse: shallow nesting still parses (no over-rejection)",
+    okThrew === null);
+}
+
 async function run() {
   testXmlC14nBasic();
   testXmlC14nSingleMatchInvariant();
+  testXmlC14nRejectsDeepNesting();
   testSamlSpAuthnRequest();
   testSamlSpRefusesUnsigned();
   testFederationParseAndPolicy();
@@ -1025,6 +1146,9 @@ async function run() {
   testDcqlMatch();
   testOid4vciIssuerConfig();
   await testOid4vciKidResolver();
+  await testOid4vciPreAuthCodeSingleUseConcurrent();
+  await testOid4vciAccessTokenSingleUseConcurrent();
+  await testOid4vciAccessTokenRestoredOnIssuerFailure();
   await testOid4vciX5cProof();
   await testOid4vciCNonceExpired();
   testCibaConfig();

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.middleware.fetchMetadata — Sec-Fetch-* resource-isolation gate.

package/lib/vendor/blamejs/test/layer-0-primitives/fido-mds3-cert-bad-validity.test.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.auth.fidoMds3 — x5c cert validity-window must fail closed when the

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * b.auth.fidoMds3 — FIDO MDS3 metadata BLOB verifier + AAGUID lookup.

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

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

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
 "use strict";
 /**
  * file-upload — content-safety SKIP is audited.
@@ -181,6 +183,70 @@ async function run() {
     check("skip[throwing-sink]: upload finalized despite throwing audit sink",
           threw === false && rv && rv.ok === true && rv.size === s0.length);
   }
+
+  // ---- A magic-byte-mislabeled file cannot dodge the content-safety scanner
+  //      for its REAL type via its filename extension ----
+  {
+    var pdfGateRan = false;
+    var u6 = b.fileUpload.create({
+      stagingDir:     _tmpDir("mislabel"),
+      filenameSafety: null,
+      fileType:       b.fileType,
+      contentSafety:  {
+        // A gate ONLY for .pdf, which refuses; there is NO .png gate, so a
+        // file named "*.png" would skip content scanning by its extension.
+        ".pdf": { check: function () {
+          pdfGateRan = true;
+          return { ok: false, action: "refuse", issues: [{ kind: "pdf-refused" }] };
+        } },
+      },
+      audit: { safeEmit: function () {} },
+    });
+    // PDF magic bytes (%PDF-) named "evil.png": the filename extension (.png)
+    // has no gate, so without sniffed-type gating the .pdf scanner is dodged and
+    // the upload finalizes. The sniffed-type gate must run the .pdf scanner.
+    var pdfBytes = Buffer.from("%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\n", "utf8");
+    var refusedCode = null;
+    try {
+      await _uploadAndFinalize(u6, "u-mislabel", [pdfBytes], { metadata: { filename: "evil.png" } });
+    } catch (e) { refusedCode = e.code || null; }
+    check("mislabel: PDF content named .png is scanned by the sniffed .pdf gate (not dodged by extension)",
+          pdfGateRan === true && refusedCode === "CONTENT_SAFETY_REFUSED");
+  }
+
+  // ---- A STREAMED mislabel routes to its real type's gate, so the skip
+  //      surfaces as "streamed-over-reassembly-cap" (not "no-gate") ----
+  {
+    var emitted7 = [];
+    var pdfStreamGateChecked = false;
+    var u7 = b.fileUpload.create({
+      stagingDir:               _tmpDir("streamed-mislabel"),
+      filenameSafety:           null,
+      fileType:                 b.fileType,
+      maxStreamReassemblyBytes: 4,   // tiny — the PDF streams (bodyBuffer null)
+      contentSafety:  {
+        ".pdf": { check: function () { pdfStreamGateChecked = true; return { ok: true, action: "serve" }; } },
+      },
+      audit: { safeEmit: function (e) { emitted7.push(e); } },
+      onFinalize: async function (info) {
+        if (info.stream) { for await (var _c of info.stream) { void _c; } }
+        return { ok: true, sha3: info.sha3, size: info.size };
+      },
+    });
+    emitted7.length = 0;
+    var pdfBig = Buffer.from("%PDF-1.4\n" + "x".repeat(64) + "\n%%EOF\n", "utf8");   // > 4-byte cap
+    await _uploadAndFinalize(u7, "u-streamed-mislabel", [pdfBig], { metadata: { filename: "evil.png" } });
+    var skips7 = _skipEvents(emitted7);
+    // The .pdf gate cannot scan the un-reassembled body, but the magic bytes
+    // (read from the first chunk) routed to it — so the skip names the
+    // reassembly cap, surfacing the bypass, rather than "no-gate-for-extension"
+    // which would hide that the configured .pdf gate was skipped.
+    check("streamed mislabel: the sniffed .pdf gate could not scan the streamed body",
+          pdfStreamGateChecked === false);
+    check("streamed mislabel: skip reason is the reassembly cap (sniffed gate surfaced, not no-gate)",
+          skips7.some(function (s) { return s.reason === "streamed-over-reassembly-cap"; }) &&
+          !skips7.some(function (s) { return s.reason === "no-gate-for-extension"; }));
+  }
 }
 
 module.exports = { run: run };