@blamejs/blamejs-shop 0.4.56 → 0.4.57

package/lib/vendor/blamejs/lib/guard-pdf.js

@@ -69,9 +69,9 @@
  */
 
 var lazyRequire = require("./lazy-require");
+var safeBuffer = require("./safe-buffer");
 var gateContract = require("./gate-contract");
 var C = require("./constants");
-var numericBounds = require("./numeric-bounds");
 var { GuardPdfError } = require("./framework-error");
 
 var observability = lazyRequire(function () { return require("./observability"); });
@@ -132,34 +132,9 @@ var PROFILES = Object.freeze({
   },
 });
 
-var DEFAULTS = Object.freeze(Object.assign({}, PROFILES["strict"], {
-  mode: "enforce",
-}));
+var DEFAULTS = gateContract.strictDefaults(PROFILES);
 
-var COMPLIANCE_POSTURES = Object.freeze({
-  "hipaa":   Object.assign({}, PROFILES["strict"], {
-    forensicSnippetBytes: C.BYTES.bytes(512),
-  }),
-  "pci-dss": Object.assign({}, PROFILES["strict"], {
-    forensicSnippetBytes: C.BYTES.bytes(512),
-  }),
-  "gdpr":    Object.assign({}, PROFILES["balanced"], {
-    forensicSnippetBytes: C.BYTES.bytes(256),
-  }),
-  "soc2":    Object.assign({}, PROFILES["strict"], {
-    forensicSnippetBytes: C.BYTES.bytes(1024),
-  }),
-});
-
-function _resolveOpts(opts) {
-  return gateContract.resolveProfileAndPosture(opts, {
-    profiles:           PROFILES,
-    compliancePostures: COMPLIANCE_POSTURES,
-    defaults:           DEFAULTS,
-    errorClass:         GuardPdfError,
-    errCodePrefix:      "pdf",
-  });
-}
+var COMPLIANCE_POSTURES = gateContract.compliancePostures(PROFILES, { base: 512 });
 
 function _hasPdfMagic(buf) {
   if (!buf || typeof buf.length !== "number" || buf.length < PDF_MAGIC.length) {
@@ -180,7 +155,7 @@ function _detectIssues(metadata, opts) {
   }
 
   var bytes = metadata.bytes;
-  if (bytes && typeof bytes.length === "number" && bytes.length > opts.maxBytes) {
+  if (bytes && typeof bytes.length === "number" && safeBuffer.byteLengthOf(bytes) > opts.maxBytes) {
     return [{ kind: "pdf-cap", severity: "high",
               ruleId: "pdf.pdf-cap",
               snippet: "pdf bytes exceed maxBytes " + opts.maxBytes }];
@@ -339,15 +314,13 @@ function _detectIssues(metadata, opts) {
  *   launch.issues.some(function (i) { return i.kind === "launch-action"; });
  *   //                                                   → true
  */
-function validate(input, opts) {
-  opts = _resolveOpts(opts);
-  numericBounds.requireAllPositiveFiniteIntIfPresent(opts,
-    ["maxBytes", "maxPageCount"],
-    "guardPdf.validate", GuardPdfError, "pdf.bad-opt");
-  // maxEmbeddedFileCount allows 0 (strict refuses all embedded files);
-  // skip the positive-finite check.
-  return gateContract.aggregateIssues(_detectIssues(input, opts));
-}
+// validate is assembled by gateContract.defineGuard from `detect`
+// (_detectIssues) below — `validate(input, opts) = aggregateIssues(detect(
+// input, resolveOpts(opts)))`, with the maxBytes / maxPageCount caps
+// declared via `intOpts`. maxEmbeddedFileCount allows 0 (strict refuses all
+// embedded files) so it is NOT an intOpt — the positive-finite check would
+// reject the strict default. The @primitive block above documents the
+// resulting public ABI.
 
 /**
  * @primitive b.guardPdf.sanitize
@@ -356,13 +329,19 @@ function validate(input, opts) {
  * @status    stable
  * @related   b.guardPdf.validate, b.guardPdf.gate
  *
- * Best-effort metadata pass-through. PDF byte sanitization
- * (stripping JavaScript actions, embedded files, OpenActions) is
- * the operator parser's responsibility — the guard cannot rewrite
- * the byte stream without a vendored PDF library. `sanitize`
- * validates the metadata against the active profile and re-throws
- * `GuardPdfError` when any issue is `critical` or `high`. Returns
- * the input unchanged when every issue is `warn` or below.
+ * Disarm-by-refusal. PDF active content (`/JavaScript`, `/Launch`,
+ * `/OpenAction`, embedded files) and encryption live in a
+ * cross-referenced object graph; excising them safely needs a vendored
+ * PDF parser, which the framework does not ship (a parser per format is
+ * a supply-chain hop, and a fragile in-house excision on a security
+ * primitive is worse than an honest refusal). So `sanitize` forces every
+ * active-content / exfil / encryption policy to `reject` and re-throws
+ * `GuardPdfError` on any finding — it never hands back a PDF that still
+ * carries JavaScript, a launch/open action, embedded files, or
+ * encryption. A PDF with none of these passes through unchanged
+ * (genuinely nothing to strip). Operators needing a repaired file run a
+ * vendored disarm tool (e.g. `qpdf --decrypt` plus removing
+ * `/OpenAction` / `/Names` / `/JavaScript`).
  *
  * @opts
  *   profile:           "strict"|"balanced"|"permissive",
@@ -379,12 +358,21 @@ function validate(input, opts) {
  *   }
  */
 function sanitize(input, opts) {
-  opts = _resolveOpts(opts);
-  if (!input || typeof input !== "object") {
-    throw _err("pdf.bad-input", "sanitize requires metadata object");
-  }
-  var issues = _detectIssues(input, opts);
-  gateContract.throwOnRefusalSeverity(issues, { errorClass: GuardPdfError, codePrefix: "pdf" });
+  var resolved = module.exports.resolveOpts(opts);
+  // Force the active-content / exfil / encryption policies to reject, then
+  // refuse anything the validate chain flags. The object graph can't be
+  // edited without a parser, so disarm collapses to "refuse if not already
+  // inert" — never a silent passthrough of a live action.
+  var strict = Object.assign({}, resolved, {
+    magicPolicy:             "reject",
+    openActionPolicy:        "reject",
+    embeddedFilePolicy:      "reject",
+    embeddedFileCountPolicy: "reject",
+    encryptedPolicy:         "reject",
+  });
+  var issues = _detectIssues(input, strict);
+  gateContract.throwOnRefusalSeverity(issues,
+    { errorClass: GuardPdfError, codePrefix: "pdf" });
   return input;
 }
 
@@ -400,8 +388,10 @@ function sanitize(input, opts) {
  * { "application/pdf": gate } })` or `b.staticServe`. Operators pass
  * `ctx.metadata` (the parser's structural report) plus the original
  * `bytes`. Action chain: `serve` (no issues) → `audit-only`
- * (warn-only) → `refuse` (any critical / high). No `sanitize` action
- * — PDF byte streams can't be rewritten without a vendored parser.
+ * (warn-only) → `refuse` (any critical / high). The gate does not
+ * rewrite bytes; `b.guardPdf.sanitize(bag)` is disarm-by-refusal (it
+ * refuses any PDF still carrying active content / embedded files /
+ * encryption rather than silently passing it through).
  *
  * @opts
  *   profile:    "strict"|"balanced"|"permissive",
@@ -422,25 +412,21 @@ function sanitize(input, opts) {
  *   verdict.issues[0].kind;                              // → "javascript-action"
  */
 function gate(opts) {
-  opts = _resolveOpts(opts);
+  opts = gateContract.resolveProfileAndPosture(opts, {
+    profiles:           PROFILES,
+    compliancePostures: COMPLIANCE_POSTURES,
+    defaults:           DEFAULTS,
+    errorClass:         GuardPdfError,
+    errCodePrefix:      "pdf",
+  });
   return gateContract.buildGuardGate(
     opts.name || "guardPdf:" + (opts.profile || "default"),
     opts,
     async function (ctx) {
       var meta = ctx && (ctx.metadata || ctx.pdfMetadata);
       if (!meta) return { ok: true, action: "serve" };
-      var rv = validate(meta, opts);
-      if (rv.issues.length === 0) return { ok: true, action: "serve" };
-      var hasCritical = rv.issues.some(function (i) {
-        return i.severity === "critical";
-      });
-      var hasHigh = rv.issues.some(function (i) {
-        return i.severity === "high";
-      });
-      if (!hasCritical && !hasHigh) {
-        return { ok: true, action: "audit-only", issues: rv.issues };
-      }
-      return { ok: false, action: "refuse", issues: rv.issues };
+      var rv = module.exports.validate(meta, opts);
+      return gateContract.severityDisposition(rv.issues);
     });
 }
 
@@ -492,10 +478,13 @@ var INTEGRATION_FIXTURES = Object.freeze({
 // Assembled from the gate-contract guard factory: error class, registry
 // exports (NAME / KIND / INTEGRATION_FIXTURES), buildProfile /
 // compliancePosture / loadRulePack wiring, plus the per-guard inspection
-// surface (validate / sanitize / gate) and the pdf extra (inspectMagic)
-// passed through verbatim. KIND="metadata" is a custom kind, so the bespoke
-// `gate` (operator-feeds-metadata ctx.metadata reader) is REQUIRED and
-// carries the JavaScript / launch-action / embedded-file chain unchanged.
+// surface. validate + sanitize are generated from `detect` (_detectIssues)
+// and `sanitizeTransform` (_sanitizeTransform) with the positive-finite-int
+// caps declared via `intOpts` (maxEmbeddedFileCount is excluded — strict
+// defaults it to 0). The pdf extra (inspectMagic) passes through verbatim.
+// KIND="metadata" is a custom kind, so the bespoke `gate`
+// (operator-feeds-metadata ctx.metadata reader) is REQUIRED and carries the
+// JavaScript / launch-action / embedded-file chain unchanged.
 module.exports = gateContract.defineGuard({
   name:        "pdf",
   kind:        "metadata",
@@ -504,8 +493,12 @@ module.exports = gateContract.defineGuard({
   defaults:    DEFAULTS,
   postures:    COMPLIANCE_POSTURES,
   integrationFixtures: INTEGRATION_FIXTURES,
-  validate:    validate,
-  sanitize:    sanitize,
+  // detect reads a structured `{ bytes, hasJavaScript, ... }` metadata report,
+  // not text. The generated validate's default "raw" input contract hands the
+  // bag straight to detect (which owns its own bad-input).
+  detect:            _detectIssues,
+  sanitize:          sanitize,
+  intOpts:           ["maxBytes", "maxPageCount"],
   gate:        gate,
   extra: {
     inspectMagic: inspectMagic,

package/lib/vendor/blamejs/lib/guard-pop3-command.js

@@ -75,6 +75,8 @@
 
 var { defineClass } = require("./framework-error");
 var gateContract = require("./gate-contract");
+var codepointClass = require("./codepoint-class");
+var safeBuffer = require("./safe-buffer");
 
 var GuardPop3CommandError = defineClass("GuardPop3CommandError", { alwaysPermanent: true });
 
@@ -167,17 +169,14 @@ function validate(line, opts) {
     throw new GuardPop3CommandError("guard-pop3-command/empty-line",
       "guardPop3Command.validate: empty command line");
   }
-  if (line.length > caps.maxLineBytes) {
+  if (safeBuffer.byteLengthOf(line) > caps.maxLineBytes) {
     throw new GuardPop3CommandError("guard-pop3-command/line-too-long",
-      "guardPop3Command.validate: line " + line.length + " bytes exceeds cap " + caps.maxLineBytes);
+      "guardPop3Command.validate: line " + safeBuffer.byteLengthOf(line) + " bytes exceeds cap " + caps.maxLineBytes);
   }
-  for (var i = 0; i < line.length; i += 1) {
-    var c = line.charCodeAt(i);
-    if (c === 0x00 || c === 0x7F || (c < 0x20 && c !== 0x09)) {                                       // control-byte refusal
-      if (c === 0x0A && caps.allowBareLf) continue;
-      throw new GuardPop3CommandError("guard-pop3-command/bad-byte",
-        "guardPop3Command.validate: control byte 0x" + c.toString(16) + " at offset " + i);          // hex format literal in error message
-    }
+  var ctrlAt = codepointClass.firstControlCharOffset(line, { allowLf: caps.allowBareLf });            // bare LF permitted only when caps allow
+  if (ctrlAt !== -1) {
+    throw new GuardPop3CommandError("guard-pop3-command/bad-byte",
+      "guardPop3Command.validate: control byte 0x" + line.charCodeAt(ctrlAt).toString(16) + " at offset " + ctrlAt);  // hex format literal in error message
   }
 
   var firstSpace = line.indexOf(" ");
@@ -200,9 +199,9 @@ function validate(line, opts) {
   case "USER":
     if (!rest) throw new GuardPop3CommandError("guard-pop3-command/missing-username",
       "guardPop3Command.validate: USER requires a name argument");
-    if (rest.length > caps.maxUsernameBytes) {
+    if (safeBuffer.byteLengthOf(rest) > caps.maxUsernameBytes) {
       throw new GuardPop3CommandError("guard-pop3-command/username-too-long",
-        "guardPop3Command.validate: USER name " + rest.length + " bytes exceeds cap " + caps.maxUsernameBytes);
+        "guardPop3Command.validate: USER name " + safeBuffer.byteLengthOf(rest) + " bytes exceeds cap " + caps.maxUsernameBytes);
     }
     if (opts.tls === false && profileName === "strict") {
       throw new GuardPop3CommandError("guard-pop3-command/cleartext-auth",
@@ -213,9 +212,9 @@ function validate(line, opts) {
   case "PASS":
     if (!rest) throw new GuardPop3CommandError("guard-pop3-command/missing-password",
       "guardPop3Command.validate: PASS requires a password argument");
-    if (rest.length > caps.maxPasswordBytes) {
+    if (safeBuffer.byteLengthOf(rest) > caps.maxPasswordBytes) {
       throw new GuardPop3CommandError("guard-pop3-command/password-too-long",
-        "guardPop3Command.validate: PASS argument " + rest.length + " bytes exceeds cap " + caps.maxPasswordBytes);
+        "guardPop3Command.validate: PASS argument " + safeBuffer.byteLengthOf(rest) + " bytes exceeds cap " + caps.maxPasswordBytes);
     }
     if (opts.tls === false && profileName === "strict") {
       throw new GuardPop3CommandError("guard-pop3-command/cleartext-auth",

package/lib/vendor/blamejs/lib/guard-posture-chain.js

@@ -27,6 +27,7 @@
 
 var { defineClass } = require("./framework-error");
 var gateContract = require("./gate-contract");
+var codepointClass = require("./codepoint-class");
 
 var GuardPostureChainError = defineClass("GuardPostureChainError", { alwaysPermanent: true });
 
@@ -127,7 +128,7 @@ function validate(envelope, opts) {
         throw new GuardPostureChainError("posture-chain/non-ascii-hop",
           "guardPostureChain.validate: chainTrail[" + h + "] has non-ASCII codepoint");
       }
-      if (hc < 0x20 || hc === 0x7F) {                                                                 // C0/DEL
+      if (codepointClass.isForbiddenControlChar(hc, { forbidTab: true })) {                                                                 // C0/DEL
         throw new GuardPostureChainError("posture-chain/bad-hop-char",
           "guardPostureChain.validate: chainTrail[" + h + "] has forbidden char 0x" + hc.toString(16));
       }

package/lib/vendor/blamejs/lib/guard-regex.js

@@ -45,11 +45,9 @@
  *   Regex-pattern content-safety guard — refuses user-supplied pattern strings that exhibit catastrophic-backtracking (ReDoS) shapes BEFORE the framework compiles them with `new RegExp(...)`.
  */
 
-var codepointClass = require("./codepoint-class");
 var lazyRequire = require("./lazy-require");
 var gateContract = require("./gate-contract");
 var C = require("./constants");
-var numericBounds = require("./numeric-bounds");
 var { GuardRegexError } = require("./framework-error");
 
 var observability = lazyRequire(function () { return require("./observability"); });
@@ -82,10 +80,7 @@ var EXTGLOB_HEAD_RE = /[*+?@!]\(/g;
 
 var PROFILES = Object.freeze({
   "strict": {
-    bidiPolicy:               "reject",
-    controlPolicy:             "reject",
-    nullBytePolicy:            "reject",
-    zeroWidthPolicy:           "reject",
+    ...gateContract.CHAR_THREATS_REJECT_ALL,
     nestedQuantPolicy:         "reject",
     alternationQuantPolicy:    "reject",
     boundedRepeatPolicy:       "reject",
@@ -100,10 +95,7 @@ var PROFILES = Object.freeze({
     maxRuntimeMs:              C.TIME.seconds(2),
   },
   "balanced": {
-    bidiPolicy:               "reject",
-    controlPolicy:             "reject",
-    nullBytePolicy:            "reject",
-    zeroWidthPolicy:           "reject",
+    ...gateContract.CHAR_THREATS_REJECT_ALL,
     nestedQuantPolicy:         "reject",
     alternationQuantPolicy:    "audit",
     boundedRepeatPolicy:       "audit",
@@ -117,10 +109,7 @@ var PROFILES = Object.freeze({
     maxRuntimeMs:              C.TIME.seconds(2),
   },
   "permissive": {
-    bidiPolicy:               "reject",                                          // BIDI refused at every profile
-    controlPolicy:             "reject",                                          // controls refused at every profile
-    nullBytePolicy:            "reject",                                          // null refused at every profile
-    zeroWidthPolicy:           "reject",                                          // zero-width refused at every profile
+    ...gateContract.CHAR_THREATS_REJECT_ALL,
     nestedQuantPolicy:         "reject",                                          // canonical ReDoS class refused at every profile
     alternationQuantPolicy:    "allow",
     boundedRepeatPolicy:       "audit",
@@ -135,56 +124,15 @@ var PROFILES = Object.freeze({
   },
 });
 
-var DEFAULTS = Object.freeze(Object.assign({}, PROFILES["strict"], {
-  mode: "enforce",
-}));
+var DEFAULTS = gateContract.strictDefaults(PROFILES);
 
-var COMPLIANCE_POSTURES = Object.freeze({
-  "hipaa":   Object.assign({}, PROFILES["strict"], {
-    forensicSnippetBytes: C.BYTES.bytes(256),
-  }),
-  "pci-dss": Object.assign({}, PROFILES["strict"], {
-    forensicSnippetBytes: C.BYTES.bytes(256),
-  }),
-  "gdpr":    Object.assign({}, PROFILES["balanced"], {
-    forensicSnippetBytes: C.BYTES.bytes(128),
-  }),
-  "soc2":    Object.assign({}, PROFILES["strict"], {
-    forensicSnippetBytes: C.BYTES.bytes(512),
-  }),
-});
+var COMPLIANCE_POSTURES = gateContract.compliancePostures(PROFILES, { base: 256 });
 
-function _resolveOpts(opts) {
-  return gateContract.resolveProfileAndPosture(opts, {
-    profiles:           PROFILES,
-    compliancePostures: COMPLIANCE_POSTURES,
-    defaults:           DEFAULTS,
-    errorClass:         GuardRegexError,
-    errCodePrefix:      "regex",
-  });
-}
 
 function _detectIssues(input, opts) {
-  var issues = [];
-  if (typeof input !== "string") {
-    return [{ kind: "bad-input", severity: "high",
-              ruleId: "regex.bad-input",
-              snippet: "regex pattern is not a string" }];
-  }
-  if (input.length === 0) {
-    return [{ kind: "empty", severity: "high",
-              ruleId: "regex.empty",
-              snippet: "regex pattern is empty" }];
-  }
-  if (Buffer.byteLength(input, "utf8") > opts.maxPatternBytes) {
-    return [{ kind: "pattern-cap", severity: "high",
-              ruleId: "regex.pattern-cap",
-              snippet: "regex pattern exceeds maxPatternBytes " +
-                       opts.maxPatternBytes }];
-  }
-
-  var charThreats = codepointClass.detectCharThreats(input, opts, "regex");
-  for (var ci = 0; ci < charThreats.length; ci += 1) issues.push(charThreats[ci]);
+  var pre = gateContract.detectStringInput(input, opts, { name: "regex", noun: "regex pattern", cap: { bytes: opts.maxPatternBytes, kind: "pattern-cap", snippet: "regex pattern exceeds maxPatternBytes " + opts.maxPatternBytes } });
+  if (pre.done) return pre.issues;
+  var issues = pre.issues;
 
   if (opts.nestedQuantPolicy !== "allow" && NESTED_QUANT_RE.test(input)) {       // allow:regex-no-length-cap — input bounded by maxPatternBytes
     issues.push({
@@ -394,13 +342,9 @@ function _detectNestedExtglob(input, opts, issues) {
  *   hostile.ok;                                        // → false
  *   hostile.issues.some(function (i) { return i.kind === "nested-quantifier"; });  // → true
  */
-function validate(input, opts) {
-  opts = _resolveOpts(opts);
-  numericBounds.requireAllPositiveFiniteIntIfPresent(opts,
-    ["maxBytes", "maxPatternBytes", "maxBoundedRepeat", "maxConsecutiveStars"],
-    "guardRegex.validate", GuardRegexError, "regex.bad-opt");
-  return gateContract.aggregateIssues(_detectIssues(input, opts));
-}
+// validate is assembled by gateContract.defineGuard from `detect`
+// (_detectIssues), with the positive-finite-int caps declared via `intOpts`.
+// The @primitive block above documents the resulting ABI.
 
 /**
  * @primitive  b.guardRegex.sanitize
@@ -444,15 +388,11 @@ function validate(input, opts) {
  *     e.code;                                          // → "regex.nested-quantifier"
  *   }
  */
-function sanitize(input, opts) {
-  opts = _resolveOpts(opts);
-  if (typeof input !== "string") {
-    throw _err("regex.bad-input", "sanitize requires string input");
-  }
-  var issues = _detectIssues(input, opts);
-  gateContract.throwOnRefusalSeverity(issues, {
-    errorClass: GuardRegexError, codePrefix: "regex",
-  });
+// _sanitizeTransform — the normalize tail applied by defineGuard's generated
+// sanitize AFTER resolve -> detect -> throwOnRefusalSeverity. Regex patterns
+// cannot be safely repaired, so the transform is a pass-through: a non-string
+// or any critical/high finding refuses upstream, clean input returns verbatim.
+function _sanitizeTransform(input) {
   return input;
 }
 
@@ -500,7 +440,7 @@ function sanitize(input, opts) {
  *   });
  */
 function gate(opts) {
-  opts = _resolveOpts(opts);
+  opts = _guard.resolveOpts(opts);
   return gateContract.buildGuardGate(
     opts.name || "guardRegex:" + (opts.profile || "default"),
     opts,
@@ -509,18 +449,8 @@ function gate(opts) {
       if (pattern === undefined || pattern === null) {
         return { ok: true, action: "serve" };
       }
-      var rv = validate(pattern, opts);
-      if (rv.issues.length === 0) return { ok: true, action: "serve" };
-      var hasCritical = rv.issues.some(function (i) {
-        return i.severity === "critical";
-      });
-      var hasHigh = rv.issues.some(function (i) {
-        return i.severity === "high";
-      });
-      if (!hasCritical && !hasHigh) {
-        return { ok: true, action: "audit-only", issues: rv.issues };
-      }
-      return { ok: false, action: "refuse", issues: rv.issues };
+      var rv = module.exports.validate(pattern, opts);
+      return gateContract.severityDisposition(rv.issues);
     });
 }
 
@@ -531,20 +461,14 @@ function gate(opts) {
 // in gate-contract.js, instantiated per guard by the page generator.
 
 // ---- adaptive integration-test fixtures (consumed by layer-5 host harness) ----
-var INTEGRATION_FIXTURES = Object.freeze({
-  kind:              "identifier",
-  benignBytes:       Buffer.from("^[a-z]+$", "utf8"),
-  hostileBytes:      Buffer.from("(a+)+b", "utf8"),
-  benignIdentifier:  "^[a-z]+$",
-  hostileIdentifier: "(a+)+b",
-});
+var INTEGRATION_FIXTURES = gateContract.identifierFixtures("^[a-z]+$", "(a+)+b");
 
 // Assembled from the gate-contract guard factory: error class, registry
 // exports (NAME / KIND / INTEGRATION_FIXTURES), buildProfile /
 // compliancePosture / loadRulePack wiring, plus the per-guard inspection
 // surface (validate / sanitize / gate). The bespoke `gate` carries
 // guardRegex's ctx.identifier || ctx.pattern dispatch unchanged.
-module.exports = gateContract.defineGuard({
+var _guard = module.exports = gateContract.defineGuard({
   name:        "regex",
   kind:        "identifier",
   errorClass:  GuardRegexError,
@@ -552,7 +476,8 @@ module.exports = gateContract.defineGuard({
   defaults:    DEFAULTS,
   postures:    COMPLIANCE_POSTURES,
   integrationFixtures: INTEGRATION_FIXTURES,
-  validate:    validate,
-  sanitize:    sanitize,
+  detect:            _detectIssues,
+  sanitizeTransform: _sanitizeTransform,
+  intOpts:           ["maxBytes", "maxPatternBytes", "maxBoundedRepeat", "maxConsecutiveStars"],
   gate:        gate,
 });

package/lib/vendor/blamejs/lib/guard-saga-config.js

@@ -17,6 +17,7 @@
 
 var { defineClass } = require("./framework-error");
 var gateContract = require("./gate-contract");
+var codepointClass = require("./codepoint-class");
 
 var GuardSagaConfigError = defineClass("GuardSagaConfigError", { alwaysPermanent: true });
 
@@ -80,7 +81,7 @@ function validate(config, opts) {
       throw new GuardSagaConfigError("saga-config/non-ascii-name",
         "guardSagaConfig.validate: name has non-ASCII codepoint at offset " + i);
     }
-    if (c < 0x20 || c === 0x7F) {                                                                     // C0/DEL
+    if (codepointClass.isForbiddenControlChar(c, { forbidTab: true })) {                                                                     // C0/DEL
       throw new GuardSagaConfigError("saga-config/bad-name-char",
         "guardSagaConfig.validate: name has forbidden char 0x" + c.toString(16));
     }