@blamejs/core 0.7.51 → 0.7.52

package/CHANGELOG.md

@@ -8,6 +8,8 @@ upgrading across more than a few patches at a time.
 
 ## v0.7.x
 
+- **0.7.52** (2026-05-05) — `b.guardGraphql` — GraphQL request-shape safety primitive (KIND="graphql-request"). Validates user-supplied GraphQL request bundles against the canonical query-shape DoS catalog before the framework hands the query to a schema-aware executor. Threat catalog: query depth bombs (N² query-shape DoS — caps at strict 8 / balanced 12 / permissive 24); alias-bomb breadth DoS (caps at 8/16/32 aliases per selection-set); introspection in production (`__schema` / `__type` schema-leak); batch query DoS (caps at 1/10/50 entries per array); persisted-query enforcement (refuse free-form queries when `persistedQueryPolicy: "require"`); operation-name allowlist drift; variable type confusion (operator declares `variableShapes: { id: "string", limit: "number" }`); oversized query / variable / total bytes; BIDI / null / control / zero-width universal refuse on the query string. Brace-counting query-shape walker handles strings + comments correctly without requiring a full GraphQL parser. Profiles: `strict` (refuse introspection + batch + shape-DoS), `balanced` (audit most, allow batch up to 10), `permissive` (universal-refuse class still refused; rest allow / audit). Postures: `hipaa` / `pci-dss` / `soc2` strict overlay; `gdpr` balanced overlay. Adaptive integration harness gains a KIND="graphql-request" dispatcher reading `ctx.graphqlRequest`. Auto-registers into `b.guardAll` as a STANDALONE_GUARD.
+
 - **0.7.51** (2026-05-05) — `b.guardOauth` — OAuth flow-shape safety primitive (KIND="oauth-flow"). Validates user-supplied OAuth 2.x / OIDC authorization-code-flow parameter bundles before the framework's `b.auth.oauth` client exchanges them. Threat catalog: PKCE missing or non-S256 (RFC 7636 / OAuth 2.1 mandate; `plain` is the downgrade-attack class); state missing (RFC 6749 §10.12 CSRF); redirect_uri not in operator allowlist (exact-match per OAuth 2.1 — no prefix / wildcard / scheme drift); response_type allowlist drift (refuse implicit `token` deprecated in OAuth 2.1, require operator-allowed types); scope-token shape per RFC 6749 §3.3 (refuse non-printable / control / whitespace-other-than-space); issuer missing on callback (RFC 9207 IdP-mix-up defense — set `flow._isCallback = true` to enforce); authorization-code reuse via operator-supplied `seenCodeStore.hasSeen(code)` (RFC 6749 §10.5 replay class); excessive parameter / total bytes; BIDI / null / control / zero-width universal refuse. Profiles: `strict` (PKCE S256, state required, redirect_uri exact-match, RFC 9207 iss required), `balanced` (PKCE any method, state + redirect_uri allowlist required, iss audited), `permissive` (universal-refuse class still refused; rest audit). Postures: `hipaa` / `pci-dss` / `soc2` strict overlay; `gdpr` balanced overlay. Adaptive integration harness gains a KIND="oauth-flow" dispatcher reading `ctx.oauthFlow`. Auto-registers into `b.guardAll` as a STANDALONE_GUARD.
 
 - **0.7.50** (2026-05-05) — `b.guardJwt` — JWT identifier-safety primitive (KIND="identifier"). Validates user-supplied JWT compact-serialization strings against the canonical CVE-class refuse list before hand-off to a verifier — `b.guardJwt` never replaces signature verification, it reduces the input space the verifier sees. Threat catalog: shape malformation; `alg=none` (CVE-2015-9235 jsonwebtoken / CVE-2018-0114 java-jwt) — universally refused at every profile; alg-allowlist drift (PQC-first default: ML-DSA / SLH-DSA / EdDSA / ES* / RS* / PS*); `kid` path-traversal (operator `keyResolver` path-injection class — e.g. `kid: "../etc/passwd"` would escape a key-directory `fs.readFile(keyDir + kid)` resolver); `typ` confusion (non-JWT-shape media-type tokens coerced into the slot); oversized header / payload / signature segment defense (decompression bomb + parser DoS); `exp` / `nbf` / `iat` sanity (past `exp` = replay; far-future `nbf` / `iat` = clock-skew / attacker-shaped); required-claims enforcement (default `iss` / `exp` / `iat` at strict); unknown `crit` field refuse (RFC 7515 §4.1.11 — operator MUST refuse crit values it doesn't understand); BIDI / null / control / zero-width universal refuse. **`b.guardJwt.kidSafe(kid)`** is the documented contract for operator `keyResolver` implementations: throws on traversal indicators or control bytes, returns the validated kid on success. Profiles: `strict` (refuse everything), `balanced` (refuse alg=none / kid-traversal / unknown-crit; audit the rest), `permissive` (universal-refuse class still refused). Postures: `hipaa` / `pci-dss` / `soc2` strict overlay; `gdpr` balanced overlay. Auto-registers into `b.guardAll` as a STANDALONE_GUARD.

package/index.js

@@ -117,6 +117,7 @@ var guardTime = require("./lib/guard-time");
 var guardMime = require("./lib/guard-mime");
 var guardJwt = require("./lib/guard-jwt");
 var guardOauth = require("./lib/guard-oauth");
+var guardGraphql = require("./lib/guard-graphql");
 var guardAll = require("./lib/guard-all");
 var ssrfGuard = require("./lib/ssrf-guard");
 var authHeader = require("./lib/auth-header");
@@ -265,6 +266,7 @@ module.exports = {
   guardMime:        guardMime,
   guardJwt:         guardJwt,
   guardOauth:       guardOauth,
+  guardGraphql:     guardGraphql,
   guardAll:         guardAll,
   ssrfGuard:        ssrfGuard,
   authHeader:       authHeader,

package/lib/framework-error.js

@@ -306,6 +306,14 @@ var GuardJwtError         = defineClass("GuardJwtError",         { alwaysPermane
 // BIDI / null / control / zero-width universal refuse.
 // alwaysPermanent.
 var GuardOauthError       = defineClass("GuardOauthError",       { alwaysPermanent: true });
+// GuardGraphqlError covers GraphQL request-shape violations: query
+// depth bombs (N² query-shape DoS), alias-bomb breadth DoS,
+// introspection in production, batch-query DoS, persisted-query
+// enforcement, operation-name allowlist drift, variable type
+// confusion, oversized query / variable / total bytes, BIDI / null /
+// control / zero-width universal refuse on the query string.
+// alwaysPermanent.
+var GuardGraphqlError     = defineClass("GuardGraphqlError",     { alwaysPermanent: true });
 // DoraError covers DORA Article 17 incident-reporting workflow errors
 // (classification refusal, report-shape validation, ESA-template
 // generation, audit-chain integration). Permanent — these are
@@ -372,6 +380,7 @@ module.exports = {
   GuardMimeError:         GuardMimeError,
   GuardJwtError:          GuardJwtError,
   GuardOauthError:        GuardOauthError,
+  GuardGraphqlError:      GuardGraphqlError,
   DoraError:              DoraError,
   ComplianceError:        ComplianceError,
   SmtpPolicyError:        SmtpPolicyError,

package/lib/guard-all.js

@@ -96,6 +96,7 @@ var STANDALONE_GUARDS = [
   require("./guard-mime"),
   require("./guard-jwt"),
   require("./guard-oauth"),
+  require("./guard-graphql"),
 ];
 
 // Framework-wide profile + posture vocabulary that every guard MUST

package/lib/guard-graphql.js

@@ -0,0 +1,461 @@
+"use strict";
+/**
+ * guard-graphql — GraphQL request-shape safety primitive
+ * (b.guardGraphql).
+ *
+ * Validates user-supplied GraphQL request bundles against the
+ * canonical query-shape DoS catalog before the framework hands the
+ * query to a schema-aware executor. KIND="graphql-request" — consumes
+ * `ctx.graphqlRequest` shape: { query, operationName?, variables? }.
+ *
+ * Threat catalog:
+ *   - Query depth bombs — deeply-nested selection sets multiply N²
+ *     against schema depth, bypassing field-level rate limits.
+ *   - Query breadth / alias bombs — same field repeated under
+ *     different aliases (`a:friend b:friend c:friend ...`) bypasses
+ *     per-field limits.
+ *   - Variable type confusion — variables passed as the wrong shape
+ *     (string for ID expecting Int, object for scalar). Many
+ *     executors coerce silently; the guard refuses non-shape-matching
+ *     types when the operator declares variable shapes.
+ *   - Introspection in production — `__schema` / `__type` queries
+ *     leak schema details; refused unless operator opts in.
+ *   - Batch query DoS — operators supporting [{},{}] batch arrays
+ *     get N requests for one HTTP hit; the guard caps batch length.
+ *   - Persisted-query opt-in — when operatorRequiresPersistedQuery,
+ *     refuse free-form queries that don't carry a persisted-query
+ *     hash extension.
+ *   - Operation-name allowlist — operator may pin operationName to
+ *     a whitelist of named operations (denylist for ad-hoc queries).
+ *   - Excessive query / variable / total byte length — parser DoS.
+ *   - BIDI / null / control / zero-width universal refuse on the
+ *     query string.
+ *
+ *   var rv = b.guardGraphql.validate(req, { profile: "strict" });
+ *   var g  = b.guardGraphql.gate({ profile: "strict" });
+ */
+
+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 { GuardGraphqlError } = require("./framework-error");
+
+var observability = lazyRequire(function () { return require("./observability"); });
+void observability;
+
+var _err = GuardGraphqlError.factory;
+
+// ---- Profile presets ----
+
+var PROFILES = Object.freeze({
+  "strict": {
+    bidiPolicy:                 "reject",
+    controlPolicy:              "reject",
+    nullBytePolicy:             "reject",
+    zeroWidthPolicy:            "reject",
+    introspectionPolicy:        "reject",
+    persistedQueryPolicy:       "audit",
+    operationNamePolicy:        "audit",
+    batchPolicy:                "reject",
+    aliasBombPolicy:            "reject",
+    depthPolicy:                "reject",
+    variableShapePolicy:        "reject",
+    maxDepth:                   8,                                               // allow:raw-byte-literal — selection-set depth ceiling
+    maxAliasesPerSelection:     8,                                               // allow:raw-byte-literal — alias breadth ceiling
+    maxBatchSize:               1,                                               // allow:raw-byte-literal — strict refuses batch
+    maxQueryBytes:              C.BYTES.kib(8),
+    maxVariableBytes:           C.BYTES.kib(8),
+    maxBytes:                   C.BYTES.kib(32),
+    maxRuntimeMs:               C.TIME.seconds(2),
+  },
+  "balanced": {
+    bidiPolicy:                 "reject",
+    controlPolicy:              "reject",
+    nullBytePolicy:             "reject",
+    zeroWidthPolicy:            "reject",
+    introspectionPolicy:        "audit",
+    persistedQueryPolicy:       "audit",
+    operationNamePolicy:        "audit",
+    batchPolicy:                "audit",
+    aliasBombPolicy:            "audit",
+    depthPolicy:                "audit",
+    variableShapePolicy:        "audit",
+    maxDepth:                   12,                                              // allow:raw-byte-literal — selection-set depth ceiling
+    maxAliasesPerSelection:     16,                                              // allow:raw-byte-literal — alias breadth ceiling
+    maxBatchSize:               10,                                              // allow:raw-byte-literal — batch size ceiling
+    maxQueryBytes:              C.BYTES.kib(16),
+    maxVariableBytes:           C.BYTES.kib(16),
+    maxBytes:                   C.BYTES.kib(64),
+    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
+    introspectionPolicy:        "allow",
+    persistedQueryPolicy:       "allow",
+    operationNamePolicy:        "allow",
+    batchPolicy:                "allow",
+    aliasBombPolicy:            "audit",
+    depthPolicy:                "audit",
+    variableShapePolicy:        "audit",
+    maxDepth:                   24,                                              // allow:raw-byte-literal — selection-set depth ceiling
+    maxAliasesPerSelection:     32,                                              // allow:raw-byte-literal — alias breadth ceiling
+    maxBatchSize:               50,                                              // allow:raw-byte-literal — batch size ceiling
+    maxQueryBytes:              C.BYTES.kib(64),
+    maxVariableBytes:           C.BYTES.kib(64),
+    maxBytes:                   C.BYTES.kib(256),
+    maxRuntimeMs:               C.TIME.seconds(2),
+  },
+});
+
+var DEFAULTS = Object.freeze(Object.assign({}, PROFILES["strict"], {
+  mode: "enforce",
+}));
+
+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:         GuardGraphqlError,
+    errCodePrefix:      "graphql",
+  });
+}
+
+// _measureQueryShape — walks the query string and computes
+// brace-depth + per-selection-set alias counts using simple paren
+// counting. Not a full GraphQL parser (operator runs the schema-
+// aware parser downstream); the heuristic catches DoS shapes
+// without a full lex/parse.
+function _measureQueryShape(query) {
+  var maxDepth = 0;
+  var maxAliases = 0;
+  var depth = 0;
+  var inString = false;
+  var inComment = false;
+  var aliasCounts = [0];                                                         // per-depth alias counter
+  for (var i = 0; i < query.length; i += 1) {
+    var c = query.charAt(i);
+    if (inComment) {
+      if (c === "\n") inComment = false;
+      continue;
+    }
+    if (inString) {
+      if (c === '"' && query.charAt(i - 1) !== "\\") inString = false;
+      continue;
+    }
+    if (c === '"') { inString = true; continue; }
+    if (c === "#") { inComment = true; continue; }
+    if (c === "{") {
+      depth += 1;
+      if (depth > maxDepth) maxDepth = depth;
+      aliasCounts.push(0);
+    } else if (c === "}") {
+      // Capture the current selection-set's alias count before popping
+      // — otherwise we lose the per-block max when the block closes.
+      var current = aliasCounts[aliasCounts.length - 1] || 0;
+      if (current > maxAliases) maxAliases = current;
+      depth -= 1;
+      aliasCounts.pop();
+      if (depth < 0) depth = 0;
+    } else if (c === ":") {
+      // Alias indicator — `alias: field`. Increment the current depth's
+      // counter when the char before `:` looks like an identifier.
+      var prev = i > 0 ? query.charAt(i - 1) : "";
+      if (/[A-Za-z0-9_]/.test(prev) && depth > 0) {
+        aliasCounts[depth] += 1;
+      }
+    }
+  }
+  // Final sweep covers any unclosed selection-sets (operator-supplied
+  // syntactically-invalid queries).
+  for (var ai = 0; ai < aliasCounts.length; ai += 1) {
+    if (aliasCounts[ai] > maxAliases) maxAliases = aliasCounts[ai];
+  }
+  return { maxDepth: maxDepth, maxAliases: maxAliases };
+}
+
+function _detectIssues(req, opts) {
+  var issues = [];
+  if (!req || typeof req !== "object") {
+    return [{ kind: "bad-input", severity: "high",
+              ruleId: "graphql.bad-input",
+              snippet: "graphql request is not an object" }];
+  }
+
+  // Batch handling.
+  if (Array.isArray(req)) {
+    if (opts.batchPolicy !== "allow") {
+      if (opts.batchPolicy === "reject" || req.length > opts.maxBatchSize) {
+        issues.push({
+          kind: "batch-size",
+          severity: opts.batchPolicy === "reject" ? "high" : "warn",
+          ruleId: "graphql.batch-size",
+          snippet: "GraphQL batch length " + req.length + " exceeds " +
+                   "maxBatchSize " + opts.maxBatchSize +
+                   (opts.batchPolicy === "reject" ?
+                    " (strict refuses any batch)" : ""),
+        });
+        if (opts.batchPolicy === "reject") return issues;
+      }
+    }
+    // Apply per-request validation to each entry.
+    for (var bi = 0; bi < req.length; bi += 1) {
+      var sub = _detectIssues(req[bi], opts);
+      for (var si = 0; si < sub.length; si += 1) {
+        issues.push(Object.assign({}, sub[si], {
+          snippet: "[batch[" + bi + "]] " + sub[si].snippet,
+        }));
+      }
+    }
+    return issues;
+  }
+
+  // Total-bytes cap.
+  try {
+    var totalBytes = Buffer.byteLength(JSON.stringify(req), "utf8");
+    if (totalBytes > opts.maxBytes) {
+      return [{ kind: "request-cap", severity: "high",
+                ruleId: "graphql.request-cap",
+                snippet: "graphql request " + totalBytes + " bytes " +
+                         "exceeds maxBytes " + opts.maxBytes }];
+    }
+  } catch (_e) { /* unstringifiable surfaces below */ }
+
+  if (typeof req.query !== "string" || req.query.length === 0) {
+    issues.push({
+      kind: "query-missing", severity: "high",
+      ruleId: "graphql.query-missing",
+      snippet: "graphql request missing `query` string",
+    });
+    return issues;
+  }
+  if (Buffer.byteLength(req.query, "utf8") > opts.maxQueryBytes) {
+    issues.push({
+      kind: "query-cap", severity: "high",
+      ruleId: "graphql.query-cap",
+      snippet: "query " + req.query.length + " bytes exceeds " +
+               "maxQueryBytes " + opts.maxQueryBytes,
+    });
+    return issues;
+  }
+
+  // Codepoint-class threats on the query.
+  var charThreats = codepointClass.detectCharThreats(req.query, opts, "graphql");
+  for (var ci = 0; ci < charThreats.length; ci += 1) issues.push(charThreats[ci]);
+
+  // Variables byte cap.
+  if (req.variables !== undefined) {
+    try {
+      var varBytes = Buffer.byteLength(JSON.stringify(req.variables), "utf8");
+      if (varBytes > opts.maxVariableBytes) {
+        issues.push({
+          kind: "variables-cap", severity: "high",
+          ruleId: "graphql.variables-cap",
+          snippet: "variables exceed maxVariableBytes " + opts.maxVariableBytes,
+        });
+      }
+    } catch (_e) { /* unstringifiable variables */ }
+  }
+
+  // Introspection.
+  if (opts.introspectionPolicy !== "allow") {
+    if (req.query.indexOf("__schema") !== -1 ||
+        req.query.indexOf("__type") !== -1) {
+      issues.push({
+        kind: "introspection",
+        severity: opts.introspectionPolicy === "reject" ? "high" : "warn",
+        ruleId: "graphql.introspection",
+        snippet: "query contains `__schema` / `__type` introspection — " +
+                 "leaks schema details in production",
+      });
+    }
+  }
+
+  // Persisted-query enforcement.
+  if (opts.persistedQueryPolicy === "require") {
+    var ext = req.extensions;
+    var hasPersisted = ext && ext.persistedQuery &&
+                       typeof ext.persistedQuery.sha256Hash === "string";
+    if (!hasPersisted) {
+      issues.push({
+        kind: "persisted-query-missing", severity: "high",
+        ruleId: "graphql.persisted-query-missing",
+        snippet: "persistedQueryPolicy is `require` but request carries " +
+                 "no extensions.persistedQuery.sha256Hash",
+      });
+    }
+  }
+
+  // Operation-name allowlist.
+  if (Array.isArray(opts.allowedOperations) &&
+      opts.operationNamePolicy !== "allow") {
+    if (typeof req.operationName !== "string" ||
+        opts.allowedOperations.indexOf(req.operationName) === -1) {
+      issues.push({
+        kind: "operation-not-allowed",
+        severity: opts.operationNamePolicy === "reject" ? "high" : "warn",
+        ruleId: "graphql.operation-not-allowed",
+        snippet: "operationName `" + (req.operationName || "<missing>") +
+                 "` not in operator allowlist",
+      });
+    }
+  }
+
+  // Query shape — depth + alias bombs.
+  var shape = _measureQueryShape(req.query);
+  if (opts.depthPolicy !== "allow" && shape.maxDepth > opts.maxDepth) {
+    issues.push({
+      kind: "depth-exceeded",
+      severity: opts.depthPolicy === "reject" ? "high" : "warn",
+      ruleId: "graphql.depth-exceeded",
+      snippet: "query depth " + shape.maxDepth + " exceeds maxDepth " +
+               opts.maxDepth + " — N² query-shape DoS class",
+    });
+  }
+  if (opts.aliasBombPolicy !== "allow" &&
+      shape.maxAliases > opts.maxAliasesPerSelection) {
+    issues.push({
+      kind: "alias-bomb",
+      severity: opts.aliasBombPolicy === "reject" ? "high" : "warn",
+      ruleId: "graphql.alias-bomb",
+      snippet: "selection-set alias count " + shape.maxAliases +
+               " exceeds maxAliasesPerSelection " +
+               opts.maxAliasesPerSelection +
+               " — alias-bomb breadth-DoS class",
+    });
+  }
+
+  // Variable shape (operator-declared via opts.variableShapes).
+  if (opts.variableShapePolicy !== "allow" &&
+      opts.variableShapes && typeof opts.variableShapes === "object" &&
+      req.variables && typeof req.variables === "object") {
+    var keys = Object.keys(opts.variableShapes);
+    for (var ki = 0; ki < keys.length; ki += 1) {
+      var k = keys[ki];
+      var expected = opts.variableShapes[k];
+      var actual = req.variables[k];
+      if (actual === undefined) continue;
+      if (typeof actual !== expected) {
+        issues.push({
+          kind: "variable-type-confusion",
+          severity: opts.variableShapePolicy === "reject" ? "high" : "warn",
+          ruleId: "graphql.variable-type-confusion",
+          snippet: "variable `" + k + "` is " + typeof actual +
+                   ", expected " + expected,
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+function validate(input, opts) {
+  opts = _resolveOpts(opts);
+  numericBounds.requireAllPositiveFiniteIntIfPresent(opts,
+    ["maxBytes", "maxQueryBytes", "maxVariableBytes",
+     "maxDepth", "maxAliasesPerSelection", "maxBatchSize"],
+    "guardGraphql.validate", GuardGraphqlError, "graphql.bad-opt");
+  return gateContract.aggregateIssues(_detectIssues(input, opts));
+}
+
+function sanitize(input, opts) {
+  opts = _resolveOpts(opts);
+  var issues = _detectIssues(input, opts);
+  for (var i = 0; i < issues.length; i += 1) {
+    if (issues[i].severity === "critical" || issues[i].severity === "high") {
+      throw _err(issues[i].ruleId || "graphql.refused",
+        "guardGraphql.sanitize: " + issues[i].snippet);
+    }
+  }
+  return input;
+}
+
+function gate(opts) {
+  opts = _resolveOpts(opts);
+  return gateContract.buildGuardGate(
+    opts.name || "guardGraphql:" + (opts.profile || "default"),
+    opts,
+    async function (ctx) {
+      var req = ctx && (ctx.graphqlRequest || ctx.gql);
+      if (!req) return { ok: true, action: "serve" };
+      var rv = validate(req, 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 buildProfile = gateContract.makeProfileBuilder(PROFILES);
+
+function compliancePosture(name) {
+  return gateContract.lookupCompliancePosture(name, COMPLIANCE_POSTURES,
+    _err, "graphql");
+}
+
+var _gqlRulePacks = gateContract.makeRulePackLoader(GuardGraphqlError, "graphql");
+var loadRulePack = _gqlRulePacks.load;
+
+module.exports = {
+  // ---- guard-* family registry exports ----
+  NAME:                "graphql",
+  KIND:                "graphql-request",
+  INTEGRATION_FIXTURES: Object.freeze({
+    kind: "graphql-request",
+    benignBytes: Buffer.from(JSON.stringify({
+      query: "query GetMe { me { id name } }",
+      operationName: "GetMe",
+    }), "utf8"),
+    hostileBytes: Buffer.from(JSON.stringify({
+      query: "query Inspect { __schema { types { name } } }",
+      operationName: "Inspect",
+    }), "utf8"),
+    benignGraphqlRequest: {
+      query: "query GetMe { me { id name } }",
+      operationName: "GetMe",
+    },
+    hostileGraphqlRequest: {
+      query: "query Inspect { __schema { types { name } } }",
+      operationName: "Inspect",
+    },
+  }),
+  // ---- primitive surface ----
+  validate:            validate,
+  sanitize:            sanitize,
+  gate:                gate,
+  buildProfile:        buildProfile,
+  compliancePosture:   compliancePosture,
+  loadRulePack:        loadRulePack,
+  PROFILES:            PROFILES,
+  DEFAULTS:            DEFAULTS,
+  COMPLIANCE_POSTURES: COMPLIANCE_POSTURES,
+  GuardGraphqlError:   GuardGraphqlError,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.7.51",
+  "version": "0.7.52",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cyclonedx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:dab55eee-319c-4677-a33f-e9950e36d7d8",
+  "serialNumber": "urn:uuid:5f6f1fab-e230-4b2c-ad06-d5b9143d8fe2",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-05-05T22:37:56.695Z",
+    "timestamp": "2026-05-05T22:47:38.526Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.7.51",
+      "bom-ref": "@blamejs/core@0.7.52",
       "type": "library",
       "name": "blamejs",
-      "version": "0.7.51",
+      "version": "0.7.52",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.7.51",
+      "purl": "pkg:npm/%40blamejs/core@0.7.52",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.7.51",
+      "ref": "@blamejs/core@0.7.52",
       "dependsOn": []
     }
   ]