@blamejs/blamejs-shop 0.5.12 → 0.5.13

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

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function expectThrows(label, fn, codeMatch) {
+  var threw = null;
+  try { fn(); } catch (e) { threw = e; }
+  check(label, !!threw && (threw.code || "") === codeMatch);
+  return threw;
+}
+
+function _kinds(rv) {
+  return rv.issues.map(function (i) { return i.kind; });
+}
+
+function testValidate() {
+  // Benign: a registered, well-formed media type is clean under strict.
+  var okRv = b.guardMime.validate("application/json", { profile: "strict" });
+  check("guardMime.validate benign ok",           okRv.ok === true);
+  check("guardMime.validate benign no issues",    okRv.issues.length === 0);
+
+  // Hostile: an executable/script-host media type is on the risky-type
+  // refuse list — high severity under strict.
+  var risky = b.guardMime.validate("application/x-msdownload", { profile: "strict" });
+  check("guardMime.validate risky refused",       risky.ok === false);
+  check("guardMime.validate risky-type kind",
+    _kinds(risky).indexOf("risky-type") !== -1);
+
+  // Hostile: missing `/` between type and subtype — mime-shape refuse.
+  var shape = b.guardMime.validate("noslash", { profile: "strict" });
+  check("guardMime.validate mime-shape refused",  shape.ok === false);
+  check("guardMime.validate mime-shape kind",
+    _kinds(shape).indexOf("mime-shape") !== -1);
+
+  // Hostile: a space in the subtype violates the RFC 6838 restricted-
+  // name grammar — subtype-shape refuse.
+  var badTok = b.guardMime.validate("application/js on", { profile: "strict" });
+  check("guardMime.validate subtype-shape refused", badTok.ok === false);
+  check("guardMime.validate subtype-shape kind",
+    _kinds(badTok).indexOf("subtype-shape") !== -1);
+
+  // Wildcard is Accept-only — refused as a content-type at strict.
+  var wild = b.guardMime.validate("*/*", { profile: "strict" });
+  check("guardMime.validate wildcard refused",    wild.ok === false);
+  check("guardMime.validate wildcard kind",
+    _kinds(wild).indexOf("wildcard") !== -1);
+}
+
+function testSanitize() {
+  // Benign: lower-cases the canonical type/subtype while preserving the
+  // parameter value's case (boundary tokens are case-significant).
+  var norm = b.guardMime.sanitize("Application/JSON; charset=UTF-8", { profile: "balanced" });
+  check("guardMime.sanitize lowercases type/subtype",
+    norm === "application/json; charset=UTF-8");
+  check("guardMime.sanitize preserves param-value case",
+    norm.indexOf("charset=UTF-8") !== -1);
+  check("guardMime.sanitize output neutralized",
+    norm !== "Application/JSON; charset=UTF-8");
+
+  // Already-canonical input is returned unchanged under strict.
+  var same = b.guardMime.sanitize("application/json", { profile: "strict" });
+  check("guardMime.sanitize canonical unchanged",  same === "application/json");
+
+  // Hostile: a script-host media type throws rather than normalizing a
+  // risky type into place.
+  var err = expectThrows("guardMime.sanitize risky-type throws",
+    function () { b.guardMime.sanitize("application/javascript", { profile: "strict" }); },
+    "mime.risky-type");
+  check("guardMime.sanitize risky GuardMimeError",
+    err instanceof b.guardMime.GuardMimeError);
+}
+
+async function run() {
+  testValidate();
+  testSanitize();
+}
+
+module.exports = { run: run };
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e); process.exit(1); });
+}

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

@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+// A spec-clean authorization-code flow: PKCE S256, state present,
+// allowlisted redirect_uri, single `code` response_type.
+var BENIGN_FLOW = Object.freeze({
+  response_type: "code",
+  redirect_uri:  "https://app.example.com/callback",
+  state:         "csrf-rand-1",
+  scope:         "openid profile",
+  code_challenge: "abc123def456ghi789jkl012mno345pqr678",
+  code_challenge_method: "S256",
+});
+
+var ALLOWED_REDIRECTS = Object.freeze(["https://app.example.com/callback"]);
+
+function expectThrows(label, fn, codeMatch) {
+  var threw = null;
+  try { fn(); } catch (e) { threw = e; }
+  check(label, !!threw && (threw.code || "") === codeMatch);
+  return threw;
+}
+
+function testSanitize() {
+  // Benign: a well-formed flow passes through unchanged (OAuth bundles
+  // can't be partially repaired — clean or refused).
+  var out = b.guardOauth.sanitize(BENIGN_FLOW, {
+    profile: "strict",
+    allowedRedirectUris: ALLOWED_REDIRECTS,
+  });
+  check("guardOauth.sanitize benign passthrough", out === BENIGN_FLOW);
+
+  // Hostile: no PKCE at all — OAuth 2.1 mandates PKCE for every client;
+  // sanitize throws rather than returning the downgraded flow.
+  var pkceErr = expectThrows("guardOauth.sanitize pkce-missing throws",
+    function () {
+      b.guardOauth.sanitize({
+        response_type: "code",
+        redirect_uri:  "https://app.example.com/callback",
+        scope:         "openid",
+      }, { profile: "strict" });
+    },
+    "oauth.pkce-missing");
+  check("guardOauth.sanitize pkce GuardOauthError",
+    pkceErr instanceof b.guardOauth.GuardOauthError);
+
+  // Hostile: `plain` PKCE method under strict is a downgrade-attack
+  // class — refused (require-s256).
+  expectThrows("guardOauth.sanitize pkce plain-method throws",
+    function () {
+      b.guardOauth.sanitize({
+        response_type: "code",
+        redirect_uri:  "https://app.example.com/callback",
+        state:         "s1",
+        scope:         "openid",
+        code_challenge: "abc123def456ghi789jkl012mno345pqr678",
+        code_challenge_method: "plain",
+      }, { profile: "strict", allowedRedirectUris: ALLOWED_REDIRECTS });
+    },
+    "oauth.pkce-method");
+}
+
+async function testGate() {
+  var oauthGate = b.guardOauth.gate({
+    profile: "strict",
+    allowedRedirectUris: ALLOWED_REDIRECTS,
+  });
+
+  // Benign flow → serve.
+  var served = await oauthGate.check({ oauthFlow: BENIGN_FLOW });
+  check("guardOauth.gate benign serves", served.ok === true && served.action === "serve");
+
+  // Hostile: redirect_uri not on the operator allowlist — the canonical
+  // loose-match account-takeover class. Gate refuses before the token
+  // exchange, even though state/PKCE are present.
+  var refused = await oauthGate.check({
+    oauthFlow: {
+      response_type: "code",
+      redirect_uri:  "https://attacker.example/callback",
+      state:         "csrf-rand-1",
+      scope:         "openid",
+      code_challenge: "abc123def456ghi789jkl012mno345pqr678",
+      code_challenge_method: "S256",
+    },
+  });
+  check("guardOauth.gate hostile redirect refuses",
+    refused.ok === false && refused.action === "refuse");
+  check("guardOauth.gate redirect-uri-not-allowed kind",
+    (refused.issues || []).some(function (i) { return i.kind === "redirect-uri-not-allowed"; }));
+
+  // Hostile: replay — a code the operator's seenCodeStore has already
+  // seen is a critical code-reuse refuse (RFC 6749 §10.5).
+  var replayGate = b.guardOauth.gate({
+    profile: "strict",
+    allowedRedirectUris: ALLOWED_REDIRECTS,
+    seenCodeStore: { hasSeen: function () { return true; } },
+  });
+  var replay = await replayGate.check({
+    oauthFlow: Object.assign({}, BENIGN_FLOW, { code: "authcode-123" }),
+  });
+  check("guardOauth.gate replayed code refuses",
+    replay.ok === false && replay.action === "refuse");
+  check("guardOauth.gate code-reused kind",
+    (replay.issues || []).some(function (i) { return i.kind === "code-reused"; }));
+
+  // Fail-closed: a seenCodeStore that errors can't prove the code is
+  // unused → refuse (code-reuse-unverifiable), never silently serve.
+  var errGate = b.guardOauth.gate({
+    profile: "strict",
+    allowedRedirectUris: ALLOWED_REDIRECTS,
+    seenCodeStore: { hasSeen: function () { throw new Error("store down"); } },
+  });
+  var failClosed = await errGate.check({
+    oauthFlow: Object.assign({}, BENIGN_FLOW, { code: "authcode-123" }),
+  });
+  check("guardOauth.gate replay-store error fails closed",
+    failClosed.ok === false && failClosed.action === "refuse");
+  check("guardOauth.gate code-reuse-unverifiable kind",
+    (failClosed.issues || []).some(function (i) { return i.kind === "code-reuse-unverifiable"; }));
+
+  // No flow on the ctx → serve (nothing to gate).
+  var empty = await oauthGate.check({});
+  check("guardOauth.gate absent flow serves", empty.ok === true && empty.action === "serve");
+}
+
+async function run() {
+  testSanitize();
+  await testGate();
+}
+
+module.exports = { run: run };
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e); process.exit(1); });
+}

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

@@ -77,11 +77,71 @@ function testSanitizeForcesEncryptedReject() {
     _code(function () { b.guardPdf.sanitize({ bytes: _PDF, isEncrypted: true }, { profile: "permissive" }); }) === "pdf.encrypted");
 }
 
+// An operator-supplied permissive policy opt must NOT let sanitize hand back a
+// PDF that still carries an RCE-class action. sanitize is disarm-by-refusal and
+// forces the active-content policies to reject; the forced set previously
+// covered open-action / embedded-file / encrypted but OMITTED the three classes
+// the guard "refuses to negotiate" on — JavaScript, Launch, and polyglot — so
+// `sanitize(bag, { javascriptPolicy: "allow" })` returned the live PDF. Each of
+// these drives the same override object and must refuse regardless of the opt.
+function testSanitizeForcesJavaScriptRejectOverOperatorAllow() {
+  check("javascript refused under sanitize even when javascriptPolicy:allow",
+    _code(function () {
+      b.guardPdf.sanitize({ bytes: _PDF, hasJavaScript: true },
+        { profile: "strict", javascriptPolicy: "allow" });
+    }) === "pdf.javascript-action");
+  check("javascript refused under sanitize even when javascriptPolicy:audit",
+    _code(function () {
+      b.guardPdf.sanitize({ bytes: _PDF, hasJavaScript: true },
+        { profile: "permissive", javascriptPolicy: "audit" });
+    }) === "pdf.javascript-action");
+}
+
+function testSanitizeForcesLaunchRejectOverOperatorAllow() {
+  check("launch refused under sanitize even when launchActionPolicy:allow",
+    _code(function () {
+      b.guardPdf.sanitize({ bytes: _PDF, hasLaunchAction: true },
+        { profile: "strict", launchActionPolicy: "allow" });
+    }) === "pdf.launch-action");
+}
+
+function testSanitizeForcesPolyglotRejectOverOperatorAllow() {
+  check("polyglot refused under sanitize even when polyglotPolicy:allow",
+    _code(function () {
+      b.guardPdf.sanitize({ bytes: _PDF, polyglotDetected: true },
+        { profile: "strict", polyglotPolicy: "allow" });
+    }) === "pdf.polyglot");
+}
+
 function testSanitizeBadInput() {
   check("bad input refused",
     _code(function () { b.guardPdf.sanitize(null, { profile: "balanced" }); }) === "pdf.bad-input");
 }
 
+// ---- magic-byte inspection ----
+
+function testInspectMagic() {
+  // %PDF-1.7 header (25 50 44 46 2D 31 2E 37) — real PDF prefix.
+  var pdfBytes = Buffer.from([0x25, 0x50, 0x44, 0x46, 0x2D, 0x31, 0x2E, 0x37]);
+  check("inspectMagic: %PDF- prefix → true",
+    b.guardPdf.inspectMagic(pdfBytes) === true);
+  // Exactly the 5-byte magic is enough.
+  check("inspectMagic: bare %PDF- (5 bytes) → true",
+    b.guardPdf.inspectMagic(_PDF) === true);
+  // Non-PDF bytes — the operator fed the wrong gate.
+  check("inspectMagic: mismatching bytes → false",
+    b.guardPdf.inspectMagic(Buffer.from([0x00, 0x01, 0x02])) === false);
+  // A buffer shorter than the 5-byte magic can't match.
+  check("inspectMagic: too-short buffer → false",
+    b.guardPdf.inspectMagic(Buffer.from([0x25, 0x50])) === false);
+  // Near-miss: right length, one byte off (0x2E vs 0x2D at index 4).
+  check("inspectMagic: one-byte-off prefix → false",
+    b.guardPdf.inspectMagic(Buffer.from([0x25, 0x50, 0x44, 0x46, 0x2E])) === false);
+  // Pure inspection — never throws on non-Buffer input.
+  check("inspectMagic: null input → false (no throw)",
+    b.guardPdf.inspectMagic(null) === false);
+}
+
 function run() {
   testGuardPdfSurface();
   testGuardPdfRegistryParity();
@@ -92,7 +152,27 @@ function run() {
   testSanitizeForcesOpenActionReject();
   testSanitizeForcesEmbeddedFileReject();
   testSanitizeForcesEncryptedReject();
+  testSanitizeForcesJavaScriptRejectOverOperatorAllow();
+  testSanitizeForcesLaunchRejectOverOperatorAllow();
+  testSanitizeForcesPolyglotRejectOverOperatorAllow();
   testSanitizeBadInput();
+  testInspectMagic();
+  testValidateNeverThrowsOnArrayLikeBytes();
+}
+
+// ---- validate must never throw on hostile metadata (sibling of the guard-image
+// array-like crash: byteLengthOf was called for any numeric-.length value, but
+// it only accepts string/Buffer/Uint8Array and threw TypeError on a plain Array
+// / array-like bag, crashing a direct validate/sanitize caller). ----
+function testValidateNeverThrowsOnArrayLikeBytes() {
+  check("validate does not throw on Array-typed bytes",
+    _code(function () { b.guardPdf.validate({ bytes: [0x25, 0x50, 0x44, 0x46] }, { profile: "balanced" }); }) === null);
+  check("validate does not throw on array-like-object bytes",
+    _code(function () { b.guardPdf.validate({ bytes: { length: 1e9 } }, { profile: "strict" }); }) === null);
+  // The unrecognized array-like content is still refused (unknown-magic under
+  // strict), not served — never-throw does not mean fail-open.
+  var rv = b.guardPdf.validate({ bytes: [1, 2, 3] }, { profile: "strict" });
+  check("array-like bytes → refused (ok:false), not a crash", rv.ok === false);
 }
 
 module.exports = { run: run };

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

@@ -162,6 +162,32 @@ function testByteCapMultibyte() {
     t3 && t3.code === "guard-pop3-command/password-too-long");
 }
 
+function testProfilePrototypeKeyRefused() {
+  // A profile name that collides with a JS prototype-key must resolve to
+  // bad-profile, never silently disable the caps. Pre-fix the resolver
+  // read PROFILES[profileName] by bracket access, so PROFILES["constructor"]
+  // was the inherited Object function — truthy — and `if (!caps)` never
+  // fired; the line / username / password caps then compared against
+  // `undefined` (always false) and failed open.
+  var protoKeys = ["constructor", "__proto__", "toString", "valueOf", "hasOwnProperty"];
+  for (var i = 0; i < protoKeys.length; i += 1) {
+    var threw = null;
+    try { b.guardPop3Command.validate("NOOP", { profile: protoKeys[i] }); }
+    catch (e) { threw = e; }
+    check("profile '" + protoKeys[i] + "' refused as bad-profile",
+      threw && threw.code === "guard-pop3-command/bad-profile");
+  }
+  // Concrete fail-open proof: a USER name past the strict 40-byte cap
+  // must NOT be accepted under a prototype-key profile.
+  var threwLong = null;
+  try {
+    b.guardPop3Command.validate("USER " + "a".repeat(300),
+      { profile: "constructor", tls: true });
+  } catch (e) { threwLong = e; }
+  check("prototype-key profile does not fail open on the username cap",
+    threwLong && threwLong.code === "guard-pop3-command/bad-profile");
+}
+
 function run() {
   testByteCapMultibyte();
   testSurface();
@@ -170,6 +196,7 @@ function run() {
   testAuthCleartextRefused();
   testApopRefusedUnderStrict();
   testBadInputRefused();
+  testProfilePrototypeKeyRefused();
   testCompliancePosture();
 }
 

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

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+/**
+ * b.guardRegex — ReDoS screening for operator-supplied patterns. Covers the
+ * nested-quantifier detector's true positives AND the linear shapes it must NOT
+ * false-refuse (#432 / #429): a quantified non-capturing group (`(?:…)?`,
+ * `(?:…)*`) and an OPTIONAL quantified group (`(X+)?`, `(?:X+)?`) repeat the
+ * group at most once, so they are linear, not catastrophic. The catastrophic
+ * class requires the OUTER quantifier to be unbounded (`*`/`+`/`{n,}`).
+ *
+ * Run standalone: `node test/layer-0-primitives/guard-regex.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function assertSafeAccepts(src) {
+  try { b.guardRegex.assertSafe(new RegExp(src), "x"); return true; } catch (_e) { return false; }
+}
+function sanitizeAccepts(src) {
+  try { b.guardRegex.sanitize(src); return true; } catch (_e) { return false; }
+}
+
+// ---- #432 / #429: linear shapes must be ACCEPTED (were false-refused) ----
+function testLinearShapesAccepted() {
+  var linear = [
+    "^(?:/page/\\d+)?$",            // optional non-capturing group
+    "^foo(?:bar)*$",               // quantified non-capturing group
+    "^foo(?:bar)?$",
+    "^(a+)?$",                     // optional quantified group — repeats 0..1
+    "(?:[-+][0-9A-Za-z.-]+)?",     // optional group with inner quantifier (#429)
+    "(?:[-+][0-9A-Za-z.-]{1,64})?",
+    "v\\d+\\.\\d+\\.\\d+(?:[-+][0-9A-Za-z.-]+)?-linux-x64",
+  ];
+  linear.forEach(function (src) {
+    check("assertSafe accepts linear " + JSON.stringify(src), assertSafeAccepts(src));
+    check("sanitize accepts linear " + JSON.stringify(src), sanitizeAccepts(src));
+  });
+}
+
+// ---- genuine nested-UNBOUNDED shapes must still be REFUSED ----
+function testCatastrophicShapesRefused() {
+  var bad = ["^(a+)+$", "(a+)*", "((a)+)+", "(([a-z]+)*)*", "(a+){2,}"];
+  bad.forEach(function (src) {
+    check("assertSafe refuses catastrophic " + JSON.stringify(src), assertSafeAccepts(src) === false);
+  });
+}
+
+// ---- other ReDoS classes the guard covers stay covered ----
+function testOtherClasses() {
+  check("alternation-with-quantifier refused", assertSafeAccepts("^(a|b|c)+$") === false);
+  check("plain linear pattern accepted", assertSafeAccepts("^[a-z0-9_-]{1,64}$"));
+  check("anchored alternation without group-quantifier accepted", assertSafeAccepts("^(?:cat|dog|bird)$"));
+}
+
+// ---- b.guardRegex.gate — the request-boundary screener ----
+// The gate reads ctx.identifier (or ctx.pattern) and maps validate's
+// severity to serve / audit-only / refuse before any new RegExp() compile.
+async function testGate() {
+  var gate = b.guardRegex.gate({ profile: "strict" });
+
+  var clean = await gate.check({ identifier: "^[a-z]+$" });
+  check("gate: linear pattern → action=serve, ok=true",
+    clean.ok === true && clean.action === "serve");
+
+  var nested = await gate.check({ identifier: "(a+)+b" });
+  check("gate: nested-quantifier ReDoS → action=refuse, ok=false",
+    nested.ok === false && nested.action === "refuse");
+  check("gate: nested-quantifier → nested-quantifier issue",
+    nested.issues.some(function (i) { return i.kind === "nested-quantifier"; }));
+
+  // ctx.pattern is the documented fallback field for the pattern.
+  var alt = await gate.check({ pattern: "(a|b|c)+" });
+  check("gate: alternation-with-quantifier via ctx.pattern → refuse",
+    alt.action === "refuse");
+
+  // Absent pattern is a no-op serve (nothing to screen).
+  var none = await gate.check({});
+  check("gate: no pattern supplied → action=serve",
+    none.ok === true && none.action === "serve");
+}
+
+async function run() {
+  testLinearShapesAccepted();
+  testCatastrophicShapesRefused();
+  testOtherClasses();
+  await testGate();
+}
+
+if (require.main === module) {
+  run()
+    .then(function () { console.log("guard-regex OK — " + helpers.getChecks() + " checks"); })
+    .catch(function (e) { console.error("FAIL:", e.stack || e); process.exit(1); });
+}
+
+module.exports = { run: run };

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

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+/**
+ * guard-shell — shell-argument content-safety primitive (b.guardShell).
+ *
+ * Covers the pass-through-or-throw sanitize contract: a clean argument
+ * returns unchanged, while an argument carrying a shell-injection shape
+ * throws GuardShellError with the offending rule id. Command / process
+ * substitution, backticks and newlines are refused at EVERY profile
+ * (including permissive) — the RCE class is never an operator opt-in.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function _code(fn) { try { fn(); return null; } catch (e) { return e && e.code; } }
+
+function testGuardShellSurface() {
+  check("guardShell is an object",           typeof b.guardShell === "object");
+  check("guardShell.NAME === 'shell'",       b.guardShell.NAME === "shell");
+  check("guardShell.sanitize is a function", typeof b.guardShell.sanitize === "function");
+  check("guardShell registered in guardAll",
+    b.guardAll.allGuards().some(function (g) { return (g.name || g.NAME) === "shell"; }));
+  check("frameworkError.GuardShellError exposed",
+    typeof b.frameworkError.GuardShellError === "function");
+}
+
+function testSanitizeCleanPassthrough() {
+  // A metacharacter-free argument survives sanitize verbatim.
+  var out = b.guardShell.sanitize("safe-arg-value", { profile: "strict" });
+  check("clean arg passes through unchanged", out === "safe-arg-value");
+}
+
+function testSanitizeRefusesMetacharChain() {
+  // `safe; rm -rf /` carries the POSIX `;` command separator — a shell
+  // would run `rm -rf /` after the intended arg.
+  check("posix metacharacter chain refused under strict",
+    _code(function () { b.guardShell.sanitize("safe; rm -rf /", { profile: "strict" }); })
+      === "shell.posix-metachar");
+}
+
+function testSanitizeRefusesCommandSubstitutionEveryProfile() {
+  // $(...) command substitution is refused even at permissive.
+  check("$(...) command substitution refused at permissive",
+    _code(function () { b.guardShell.sanitize("$(whoami)", { profile: "permissive" }); })
+      === "shell.dollar-substitution");
+  // Backtick substitution is likewise refused at permissive.
+  check("backtick substitution refused at permissive",
+    _code(function () { b.guardShell.sanitize("`id`", { profile: "permissive" }); })
+      === "shell.backtick");
+}
+
+function testSanitizeThrowsGuardShellError() {
+  var caught = null;
+  try { b.guardShell.sanitize("a|b", { profile: "strict" }); }
+  catch (e) { caught = e; }
+  check("sanitize throws a GuardShellError instance",
+    caught instanceof b.frameworkError.GuardShellError);
+}
+
+function run() {
+  testGuardShellSurface();
+  testSanitizeCleanPassthrough();
+  testSanitizeRefusesMetacharChain();
+  testSanitizeRefusesCommandSubstitutionEveryProfile();
+  testSanitizeThrowsGuardShellError();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  try { run(); console.log("[guard-shell] OK — " + helpers.getChecks() + " checks passed"); }
+  catch (e) { console.error("FAIL:", e.stack || e); process.exit(1); }
+}

package/lib/vendor/blamejs/test/layer-0-primitives/{guard-sql-coverage.test.js → guard-sql.test.js}

@@ -2,7 +2,7 @@
 // Copyright (c) blamejs contributors
 "use strict";
 /**
- * guard-sql-coverage — error / adversarial-branch coverage for
+ * guard-sql — error / adversarial-branch coverage for
  * b.guardSql (the raw-SQL content-safety primitive).
  *
  * The smoke + integration suites already exercise the happy path (a
@@ -28,7 +28,7 @@
  *   - sanitize's refuse-throw path and gate's serve / audit-only /
  *     refuse / fail-closed dispositions.
  *
- * Run standalone: node test/layer-0-primitives/guard-sql-coverage.test.js
+ * Run standalone: node test/layer-0-primitives/guard-sql.test.js
  * Or via smoke:   node test/smoke.js
  */
 
@@ -426,7 +426,7 @@ module.exports = { run: run };
 
 if (require.main === module) {
   run().then(
-    function () { console.log("[guard-sql-coverage] OK — " + helpers.getChecks() + " checks passed"); process.exit(0); },
+    function () { console.log("[guard-sql] OK — " + helpers.getChecks() + " checks passed"); process.exit(0); },
     function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }
   );
 }