@blamejs/core 0.12.61 → 0.12.62

package/CHANGELOG.md

@@ -8,6 +8,8 @@ upgrading across more than a few patches at a time.
 
 ## v0.12.x
 
+- v0.12.62 (2026-05-26) — **`b.jtd` — JSON Type Definition validation (RFC 8927).** Validate JSON against a JSON Type Definition schema (RFC 8927) — a small, portable, cross-implementation schema language, the interop-friendly companion to the framework's fluent b.safeSchema builder. b.jtd.validate(schema, instance) returns an array of { instancePath, schemaPath } errors (empty = valid); b.jtd.isValid is the boolean form. All eight schema forms are supported — empty, type, enum, elements, properties (with optional / additional properties and nullable), values, discriminator (with mapping), and ref (with definitions) — including the integer-range and RFC 3339 timestamp types. A malformed schema is rejected at compile time with jtd/bad-schema rather than silently mis-validating. Verified against the official json-typedef-spec suites: all 316 validation cases and all 49 invalid-schema cases. **Added:** *`b.jtd.validate(schema, instance)` / `b.jtd.isValid(schema, instance)`* — `validate` returns the RFC 8927 error list — each `{ instancePath, schemaPath }` naming the offending value and the broken schema rule — and `isValid` is the boolean convenience form. Supports every JTD form and type: the numeric types enforce their exact ranges (int8 … uint32, float32 / float64), `timestamp` requires an RFC 3339 date-time, `properties` honours `optionalProperties` / `additionalProperties` / `nullable`, and `discriminator` selects a `mapping` schema by a tag property. The schema is checked for well-formedness before validation, so unknown keywords, multiple forms, bad refs, or a discriminator over a non-properties mapping all throw `jtd/bad-schema`. Use JTD for schemas you share across implementations or generate code from; use `b.safeSchema` for in-process fluent validation.
+
 - v0.12.61 (2026-05-26) — **`b.jsonPath` — JSONPath query (RFC 9535).** A full RFC 9535 JSONPath query evaluator, complementing the framework's JSONPath guards (which screen path strings). b.jsonPath.query(doc, path) compiles a path and returns the matched node values; b.jsonPath.paths returns their normalized locations. The complete surface is implemented: name / wildcard / index / slice selectors, descendant segments (..), filter selectors (?) with comparison and logical operators, relative (@) and absolute ($) embedded queries, and the five standard functions length / count / match / search / value — with the spec's well-typedness rules enforced at compile time so a malformed or ill-typed query is rejected rather than silently mis-evaluated. Descendant walks are node-capped to bound work on hostile input. Verified against all 703 cases of the official jsonpath-compliance-test-suite. **Added:** *`b.jsonPath.query(doc, path)` / `b.jsonPath.paths(doc, path)`* — `query` returns the array of node values selected by an RFC 9535 JSONPath; `paths` returns the normalized-path string of each match (e.g. `$['a'][1]['p']`). Supports every selector (name, wildcard `*`, index incl. negative, slice `start:end:step` incl. negative step, comma-separated selections), child and descendant (`..`) segments, and filter expressions with `==` / `!=` / `<` / `<=` / `>` / `>=`, `&&` / `||` / `!`, existence tests, and the standard functions. The well-typedness rules are checked when the path is compiled — a non-singular query used as a comparison operand, an ill-typed function argument, or a value-typed function used as a test all throw `json-path/invalid`. Pairs with `b.guardJsonPath`, which screens operator-supplied path strings before they reach the evaluator.
 
 - v0.12.60 (2026-05-25) — **`b.jsonMergePatch` — JSON Merge Patch (RFC 7396).** The simpler companion to JSON Patch: b.jsonMergePatch.merge applies an RFC 7396 merge patch (application/merge-patch+json), the partial-document PATCH body. A member present in the patch replaces or — for nested objects — merges into the target, a member whose value is null removes that key, and a patch that is itself an array, scalar, or null replaces the target wholesale. The inputs are never mutated (the merge runs on a deep copy) and member keys are written as literal own properties, so a "__proto__" member cannot reach any prototype. Verified against every RFC 7396 Appendix A test case. **Added:** *`b.jsonMergePatch.merge(target, patch)`* — Applies a JSON Merge Patch to a target document and returns the result without mutating either input. When the patch is an object it overlays the target (a null member deletes the key, a nested object merges recursively, any other value replaces); when the patch is an array, scalar, or null it replaces the whole target. Member keys are set via `Object.defineProperty`, so a `"__proto__"` member becomes a literal own key rather than altering a prototype. Pairs with `b.jsonPatch` — merge patch reads like the resource you want, JSON Patch expresses precise operations (array reordering, literal-null values).

package/README.md

@@ -99,6 +99,7 @@ The framework bundles the surface a typical Node app reaches for. Every primitiv
 - **Signed webhooks + API encryption** — SLH-DSA-SHAKE-256f default; ML-DSA-65 opt-in; ECIES API encryption (`b.webhook`, `b.crypto`)
 - **HPKE / HTTP signatures** — RFC 9180 HPKE with ML-KEM-1024 + HKDF-SHA3-512 + ChaCha20-Poly1305 (`b.crypto.hpke`); RFC 9421 HTTP Message Signatures with derived components and ed25519 / ML-DSA-65 (`b.crypto.httpSig`); RFC 9530 Content-Digest / Repr-Digest body-integrity fields (SHA-256 / SHA-512, legacy algorithms refused — `b.contentDigest`) to sign the digest rather than the whole body
 - **Link header** — RFC 8288 Web Linking codec (`b.linkHeader.parse` / `serialize`): parse and build `Link: <uri>; rel="next"` relations, the standard REST pagination mechanism; quote-aware (a comma inside a quoted parameter never splits the list)
+- **JSON Type Definition** — RFC 8927 validation (`b.jtd.validate` / `isValid`): portable, cross-implementation schema validation (all eight forms — type / enum / elements / properties / values / discriminator / ref / empty), returning instancePath / schemaPath errors; validated against the official 316-case suite. Interop companion to the fluent `b.safeSchema` builder
 - **JSONPath** — full RFC 9535 query evaluator (`b.jsonPath.query` / `paths`): name / wildcard / index / slice / descendant selectors, `?filter` expressions, and the five standard functions, with compile-time well-typedness checks (validated against the official 703-case compliance suite); complements the JSONPath guards
 - **JSON Pointer / Patch** — RFC 6901 `b.jsonPointer.get` (reference a value by `/foo/0/bar`) + RFC 6902 `b.jsonPatch.apply` (atomic add / remove / replace / move / copy / test for HTTP PATCH; the input document is never mutated, structural `test` comparison) + RFC 7396 `b.jsonMergePatch.merge` (the `merge-patch+json` partial-document format; both PATCH formats are prototype-pollution-safe)
 - **Canonical JSON** — RFC 8785 JSON Canonicalization Scheme (`b.canonicalJson.stringifyJcs`): the deterministic, sorted-key byte form to hash or sign (custom credentials, receipts, deterministic request signing); UTF-16 key ordering + ECMAScript number formatting, with a lenient `stringify` variant for Buffers / Dates / BigInts

package/index.js

@@ -402,6 +402,7 @@ var jsonPointer = require("./lib/json-pointer");
 var jsonPatch = require("./lib/json-patch");
 var jsonMergePatch = require("./lib/json-merge-patch");
 var jsonPath = require("./lib/json-path");
+var jtd = require("./lib/jtd");
 var standardWebhooks = require("./lib/standard-webhooks");
 var lro = require("./lib/lro");
 var jsonApi = require("./lib/jsonapi");
@@ -425,6 +426,7 @@ module.exports = {
   jsonPatch:        jsonPatch,
   jsonMergePatch:   jsonMergePatch,
   jsonPath:         jsonPath,
+  jtd:              jtd,
   standardWebhooks: standardWebhooks,
   lro:              lro,
   jsonApi:          jsonApi,

package/lib/jtd.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * @module b.jtd
+ * @nav    Data
+ * @title  JSON Type Definition
+ *
+ * @intro
+ *   Validate a JSON value against a JSON Type Definition schema (RFC
+ *   8927) — a small, portable, cross-implementation schema language.
+ *   Unlike the framework's fluent <code>b.safeSchema</code> builder, a
+ *   JTD schema is plain JSON you can share with any JTD implementation
+ *   (and generate code from), which makes it the right choice for
+ *   interop contracts.
+ *
+ *   <code>validate(schema, instance)</code> returns an array of errors,
+ *   each a <code>{ instancePath, schemaPath }</code> pair pointing at the
+ *   offending value and the schema rule it broke (an empty array means
+ *   valid). All eight schema forms are supported — empty, <code>type</code>,
+ *   <code>enum</code>, <code>elements</code>, <code>properties</code>,
+ *   <code>values</code>, <code>discriminator</code>, and <code>ref</code>
+ *   (with <code>definitions</code>) — and a malformed schema is rejected
+ *   at compile time rather than mis-validating.
+ *
+ * @card
+ *   JSON Type Definition (RFC 8927) — validate JSON against a portable,
+ *   standardized schema (all eight forms), returning instancePath /
+ *   schemaPath errors. The interop-friendly companion to the fluent
+ *   <code>b.safeSchema</code> builder.
+ */
+
+var { defineClass } = require("./framework-error");
+
+var JtdError = defineClass("JtdError", { alwaysPermanent: true });
+
+var MAX_DEPTH = 10000;                                       // allow:raw-time-literal — recursion cap for self-referential refs
+
+var TYPES = {
+  boolean: 1, string: 1, timestamp: 1, float32: 1, float64: 1,
+  int8: 1, uint8: 1, int16: 1, uint16: 1, int32: 1, uint32: 1,
+};
+var INT_RANGES = {
+  int8: [-128, 127], uint8: [0, 255], int16: [-32768, 32767],                              // allow:raw-byte-literal — RFC 8927 integer type bounds
+  uint16: [0, 65535], int32: [-2147483648, 2147483647], uint32: [0, 4294967295],            // allow:raw-byte-literal — RFC 8927 integer type bounds
+};
+var FORM_KEYWORDS = ["ref", "type", "enum", "elements", "properties", "optionalProperties", "values", "discriminator"];
+var SHARED_KEYWORDS = { definitions: 1, nullable: 1, metadata: 1 };
+
+function _isPlainObject(v) { return v !== null && typeof v === "object" && !Array.isArray(v); }
+function _isInteger(v) { return typeof v === "number" && isFinite(v) && Math.floor(v) === v; }
+
+// RFC 3339 date-time (the JTD "timestamp" type).
+var RFC3339 = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/;
+function _validTimestamp(s) {
+  var m = RFC3339.exec(s);
+  if (!m) return false;
+  var mo = +m[2], d = +m[3], h = +m[4], mi = +m[5], se = +m[6];
+  if (mo < 1 || mo > 12 || d < 1 || d > 31 || h > 23 || mi > 59 || se > 60) return false;   // allow:raw-time-literal — RFC 3339 field ranges (60 = leap second)
+  var days = [31, ((+m[1] % 4 === 0 && +m[1] % 100 !== 0) || +m[1] % 400 === 0) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];   // allow:raw-time-literal — days per month
+  if (d > days[mo - 1]) return false;
+  var tz = m[8];
+  if (tz !== "Z" && tz !== "z") {                            // numeric offset must be in range
+    if (+tz.slice(1, 3) > 23 || +tz.slice(4, 6) > 59) return false;   // allow:raw-time-literal — RFC 3339 offset hour/minute ranges
+  }
+  return true;
+}
+
+// --- compile-time well-formedness (RFC 8927 section 2.2) ---
+function _checkSchema(schema, root, isRoot) {
+  if (!_isPlainObject(schema)) throw new JtdError("jtd/bad-schema", "jtd: schema must be an object");
+  if (!isRoot && Object.prototype.hasOwnProperty.call(schema, "definitions")) throw new JtdError("jtd/bad-schema", "jtd: 'definitions' is allowed only at the root");
+  Object.keys(schema).forEach(function (k) {
+    if (FORM_KEYWORDS.indexOf(k) === -1 && !SHARED_KEYWORDS[k] && k !== "additionalProperties" && k !== "mapping") throw new JtdError("jtd/bad-schema", "jtd: unknown keyword '" + k + "'");
+  });
+  if (Object.prototype.hasOwnProperty.call(schema, "nullable") && typeof schema.nullable !== "boolean") throw new JtdError("jtd/bad-schema", "jtd: 'nullable' must be a boolean");
+  if (Object.prototype.hasOwnProperty.call(schema, "metadata") && !_isPlainObject(schema.metadata)) throw new JtdError("jtd/bad-schema", "jtd: 'metadata' must be an object");
+  if (Object.prototype.hasOwnProperty.call(schema, "definitions")) {
+    if (!_isPlainObject(schema.definitions)) throw new JtdError("jtd/bad-schema", "jtd: 'definitions' must be an object");
+    Object.keys(schema.definitions).forEach(function (k) { _checkSchema(schema.definitions[k], root, false); });
+  }
+  if (Object.prototype.hasOwnProperty.call(schema, "mapping") && !Object.prototype.hasOwnProperty.call(schema, "discriminator")) throw new JtdError("jtd/bad-schema", "jtd: 'mapping' is only valid with 'discriminator'");
+  var formSet = {};
+  FORM_KEYWORDS.forEach(function (k) { if (Object.prototype.hasOwnProperty.call(schema, k)) formSet[(k === "optionalProperties") ? "properties" : k] = 1; });
+  var formNames = Object.keys(formSet);
+  if (formNames.length > 1) throw new JtdError("jtd/bad-schema", "jtd: a schema may use only one form (got " + formNames.join(", ") + ")");
+
+  if ("ref" in schema) {
+    if (typeof schema.ref !== "string" || !root.definitions || !Object.prototype.hasOwnProperty.call(root.definitions, schema.ref)) throw new JtdError("jtd/bad-schema", "jtd: 'ref' must name a key in the root definitions");
+  }
+  if ("type" in schema && !TYPES[schema.type]) throw new JtdError("jtd/bad-schema", "jtd: unknown type '" + schema.type + "'");
+  if ("enum" in schema) {
+    if (!Array.isArray(schema.enum) || schema.enum.length === 0) throw new JtdError("jtd/bad-schema", "jtd: 'enum' must be a non-empty array");
+    var seen = Object.create(null);
+    schema.enum.forEach(function (e) { if (typeof e !== "string") throw new JtdError("jtd/bad-schema", "jtd: 'enum' values must be strings"); if (seen[e]) throw new JtdError("jtd/bad-schema", "jtd: duplicate enum value"); seen[e] = 1; });
+  }
+  if ("elements" in schema) _checkSchema(schema.elements, root, false);
+  if ("values" in schema) _checkSchema(schema.values, root, false);
+  if ("properties" in schema || "optionalProperties" in schema) {
+    var props = schema.properties || {}, opt = schema.optionalProperties || {};
+    if (!_isPlainObject(props) || !_isPlainObject(opt)) throw new JtdError("jtd/bad-schema", "jtd: properties / optionalProperties must be objects");
+    Object.keys(props).forEach(function (k) { if (Object.prototype.hasOwnProperty.call(opt, k)) throw new JtdError("jtd/bad-schema", "jtd: '" + k + "' in both properties and optionalProperties"); _checkSchema(props[k], root, false); });
+    Object.keys(opt).forEach(function (k) { _checkSchema(opt[k], root, false); });
+    if ("additionalProperties" in schema && typeof schema.additionalProperties !== "boolean") throw new JtdError("jtd/bad-schema", "jtd: 'additionalProperties' must be a boolean");
+  }
+  if ("discriminator" in schema) {
+    if (typeof schema.discriminator !== "string") throw new JtdError("jtd/bad-schema", "jtd: 'discriminator' must be a string");
+    if (!_isPlainObject(schema.mapping)) throw new JtdError("jtd/bad-schema", "jtd: 'discriminator' requires a 'mapping' object");
+    Object.keys(schema.mapping).forEach(function (k) {
+      var sub = schema.mapping[k];
+      _checkSchema(sub, root, false);
+      if (!_isPlainObject(sub) || (!("properties" in sub) && !("optionalProperties" in sub))) throw new JtdError("jtd/bad-schema", "jtd: discriminator mapping schemas must use the properties form");
+      if (sub.nullable === true) throw new JtdError("jtd/bad-schema", "jtd: discriminator mapping schemas must not be nullable");
+      var p = sub.properties || {}, o = sub.optionalProperties || {};
+      if (Object.prototype.hasOwnProperty.call(p, schema.discriminator) || Object.prototype.hasOwnProperty.call(o, schema.discriminator)) throw new JtdError("jtd/bad-schema", "jtd: discriminator tag must not appear in a mapping schema's properties");
+    });
+  }
+  if ("additionalProperties" in schema && !("properties" in schema) && !("optionalProperties" in schema)) throw new JtdError("jtd/bad-schema", "jtd: 'additionalProperties' requires a properties form");
+}
+
+// --- validation (RFC 8927 section 3.3) ---
+function _typeOk(type, v) {
+  if (type === "boolean") return typeof v === "boolean";
+  if (type === "string") return typeof v === "string";
+  if (type === "timestamp") return typeof v === "string" && _validTimestamp(v);
+  if (type === "float32" || type === "float64") return typeof v === "number" && isFinite(v);
+  var range = INT_RANGES[type];
+  return _isInteger(v) && v >= range[0] && v <= range[1];
+}
+
+function _val(schema, inst, ip, sp, root, depth, errors, discrimTag) {
+  if (depth > MAX_DEPTH) throw new JtdError("jtd/too-deep", "jtd: schema recursion exceeded the depth cap");
+  if (schema.nullable === true && inst === null) return;
+
+  if ("ref" in schema) { _val(root.definitions[schema.ref], inst, ip, ["definitions", schema.ref], root, depth + 1, errors, undefined); return; }
+
+  if ("type" in schema) {
+    if (!_typeOk(schema.type, inst)) errors.push({ instancePath: ip.slice(), schemaPath: sp.concat("type") });
+    return;
+  }
+  if ("enum" in schema) {
+    if (typeof inst !== "string" || schema.enum.indexOf(inst) === -1) errors.push({ instancePath: ip.slice(), schemaPath: sp.concat("enum") });
+    return;
+  }
+  if ("elements" in schema) {
+    if (!Array.isArray(inst)) { errors.push({ instancePath: ip.slice(), schemaPath: sp.concat("elements") }); return; }
+    for (var i = 0; i < inst.length; i++) _val(schema.elements, inst[i], ip.concat(String(i)), sp.concat("elements"), root, depth + 1, errors, undefined);
+    return;
+  }
+  if ("properties" in schema || "optionalProperties" in schema) {
+    if (!_isPlainObject(inst)) {
+      errors.push({ instancePath: ip.slice(), schemaPath: sp.concat("properties" in schema ? "properties" : "optionalProperties") });
+      return;
+    }
+    var props = schema.properties || {}, opt = schema.optionalProperties || {};
+    Object.keys(props).forEach(function (k) {
+      if (Object.prototype.hasOwnProperty.call(inst, k)) _val(props[k], inst[k], ip.concat(k), sp.concat("properties", k), root, depth + 1, errors, undefined);
+      else errors.push({ instancePath: ip.slice(), schemaPath: sp.concat("properties", k) });
+    });
+    Object.keys(opt).forEach(function (k) {
+      if (Object.prototype.hasOwnProperty.call(inst, k)) _val(opt[k], inst[k], ip.concat(k), sp.concat("optionalProperties", k), root, depth + 1, errors, undefined);
+    });
+    if (schema.additionalProperties !== true) {
+      Object.keys(inst).forEach(function (k) {
+        if (!Object.prototype.hasOwnProperty.call(props, k) && !Object.prototype.hasOwnProperty.call(opt, k) && k !== discrimTag) {
+          errors.push({ instancePath: ip.concat(k), schemaPath: sp.slice() });
+        }
+      });
+    }
+    return;
+  }
+  if ("values" in schema) {
+    if (!_isPlainObject(inst)) { errors.push({ instancePath: ip.slice(), schemaPath: sp.concat("values") }); return; }
+    Object.keys(inst).forEach(function (k) { _val(schema.values, inst[k], ip.concat(k), sp.concat("values"), root, depth + 1, errors, undefined); });
+    return;
+  }
+  if ("discriminator" in schema) {
+    if (!_isPlainObject(inst)) { errors.push({ instancePath: ip.slice(), schemaPath: sp.concat("discriminator") }); return; }
+    var tag = schema.discriminator;
+    if (!Object.prototype.hasOwnProperty.call(inst, tag)) { errors.push({ instancePath: ip.slice(), schemaPath: sp.concat("discriminator") }); return; }
+    if (typeof inst[tag] !== "string") { errors.push({ instancePath: ip.concat(tag), schemaPath: sp.concat("discriminator") }); return; }
+    if (!Object.prototype.hasOwnProperty.call(schema.mapping, inst[tag])) { errors.push({ instancePath: ip.concat(tag), schemaPath: sp.concat("mapping") }); return; }
+    _val(schema.mapping[inst[tag]], inst, ip, sp.concat("mapping", inst[tag]), root, depth + 1, errors, tag);
+    return;
+  }
+  // empty form: accepts anything
+}
+
+/**
+ * @primitive b.jtd.validate
+ * @signature b.jtd.validate(schema, instance)
+ * @since     0.12.62
+ * @status    stable
+ * @compliance soc2
+ * @related   b.safeSchema, b.jsonPointer.get
+ *
+ * Validate a JSON value against a JSON Type Definition schema (RFC 8927)
+ * and return the array of validation errors — each a
+ * <code>{ instancePath, schemaPath }</code> pair of token arrays naming
+ * the offending value and the schema rule it broke. An empty array means
+ * the instance is valid. All eight schema forms are supported. The schema
+ * itself is checked for well-formedness first; a malformed schema throws
+ * <code>jtd/bad-schema</code> rather than silently mis-validating.
+ *
+ * @example
+ *   b.jtd.validate({ properties: { id: { type: "uint32" } } }, { id: -1 });
+ *   // -> [ { instancePath: ["id"], schemaPath: ["properties", "id", "type"] } ]
+ */
+function validate(schema, instance) {
+  _checkSchema(schema, schema, true);
+  var errors = [];
+  _val(schema, instance, [], [], schema, 0, errors, undefined);
+  return errors;
+}
+
+/**
+ * @primitive b.jtd.isValid
+ * @signature b.jtd.isValid(schema, instance)
+ * @since     0.12.62
+ * @status    stable
+ * @related   b.jtd.validate
+ *
+ * Convenience boolean form of <code>validate</code> — <code>true</code>
+ * when the instance conforms to the JTD schema (no errors). Throws
+ * <code>jtd/bad-schema</code> on a malformed schema.
+ *
+ * @example
+ *   b.jtd.isValid({ type: "string" }, "hello");   // -> true
+ */
+function isValid(schema, instance) { return validate(schema, instance).length === 0; }
+
+module.exports = {
+  validate: validate,
+  isValid:  isValid,
+  JtdError: JtdError,
+};

package/package.json

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

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:ad83b06e-a1bc-47e4-9b53-db78947055a5",
+  "serialNumber": "urn:uuid:f56710ee-2e4e-4c8e-af88-80f79561870e",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-05-26T02:37:15.214Z",
+    "timestamp": "2026-05-26T03:54:31.896Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.12.61",
+      "bom-ref": "@blamejs/core@0.12.62",
       "type": "application",
       "name": "blamejs",
-      "version": "0.12.61",
+      "version": "0.12.62",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.12.61",
+      "purl": "pkg:npm/%40blamejs/core@0.12.62",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.12.61",
+      "ref": "@blamejs/core@0.12.62",
       "dependsOn": []
     }
   ]