@blamejs/core 0.4.28 → 0.5.0

package/lib/cache.js

@@ -683,15 +683,7 @@ function create(opts) {
   }
 
   function _actor(callerOpts) {
-    var override = {};
-    if (callerOpts && callerOpts.context && typeof callerOpts.context === "object") {
-      for (var k in callerOpts.context) {
-        if (Object.prototype.hasOwnProperty.call(callerOpts.context, k)) {
-          override[k] = callerOpts.context[k];
-        }
-      }
-    }
-    return requestHelpers.extractActorContext(callerOpts && callerOpts.req, override);
+    return requestHelpers.resolveActorWithOverride(callerOpts);
   }
 
   function _backendFailedAudit(op, err) {

package/lib/db.js

@@ -109,6 +109,8 @@ var RESERVED_TABLE_NAMES = new Set([
   "_blamejs_cache",
   "_blamejs_seeders",
   "_blamejs_seeders_lock",
+  "_blamejs_break_glass_policies",
+  "_blamejs_break_glass_grants",
 ]);
 
 var FRAMEWORK_SCHEMA = [
@@ -423,6 +425,67 @@ var FRAMEWORK_SCHEMA = [
     },
     sealedFields: [],
   },
+  {
+    // _blamejs_break_glass_policies — column-level break-glass policy
+    // registry. One row per (table) declares which columns are
+    // glass-locked and what the operator's grant rules are. Sealed
+    // columns hold the column-list, factor-list, and bypass config so
+    // policy contents aren't browsable in cleartext.
+    name: "_blamejs_break_glass_policies",
+    columns: {
+      tableName:                  "TEXT PRIMARY KEY",
+      columnsJson:                "TEXT NOT NULL",
+      factorsJson:                "TEXT NOT NULL",
+      cryptographic:              "INTEGER NOT NULL DEFAULT 0",
+      grantTtlMs:                 "INTEGER NOT NULL",
+      maxRowsPerGrant:            "INTEGER NOT NULL DEFAULT 1",
+      reasonRequired:             "INTEGER NOT NULL DEFAULT 1",
+      reasonMinLength:            "INTEGER NOT NULL DEFAULT 12",
+      pinIp:                      "INTEGER NOT NULL DEFAULT 1",
+      sessionPin:                 "INTEGER NOT NULL DEFAULT 1",
+      onLockedAccess:             "TEXT NOT NULL DEFAULT 'throw'",
+      requireScope:               "TEXT",
+      serviceAccountBypassJson:   "TEXT",
+      auditReasonStorage:         "TEXT NOT NULL DEFAULT 'cleartext'",
+      updatedAt:                  "INTEGER NOT NULL",
+    },
+    indexes: [],
+    sealedFields: ["columnsJson", "factorsJson", "serviceAccountBypassJson"],
+  },
+  {
+    // _blamejs_break_glass_grants — issued grants. Each successful
+    // step-up creates one row; each row read decrements rowsRemaining.
+    // Default maxRowsPerGrant=1 enforces "row by row" auth per the
+    // operator-confirmed shape (each row access = its own grant).
+    // Sealed columns hold reason + scopeColumns so audit-readable
+    // metadata doesn't leak in cleartext.
+    name: "_blamejs_break_glass_grants",
+    columns: {
+      _id:                "TEXT PRIMARY KEY",
+      issuedToActorId:    "TEXT NOT NULL",
+      issuedToActorHash:  "TEXT NOT NULL",
+      factorType:         "TEXT NOT NULL",
+      reasonSealed:       "TEXT",
+      scopeTable:         "TEXT NOT NULL",
+      scopeColumnsJson:   "TEXT NOT NULL",
+      issuedAt:           "INTEGER NOT NULL",
+      expiresAt:          "INTEGER NOT NULL",
+      maxRowsPerGrant:    "INTEGER NOT NULL",
+      rowsConsumed:       "INTEGER NOT NULL DEFAULT 0",
+      revokedAt:          "INTEGER",
+      sessionId:          "TEXT",
+      ip:                 "TEXT",
+      kwGrantHalf:        "TEXT",
+    },
+    indexes: [
+      { name: "idx_bg_grants_actor",   columns: ["issuedToActorHash"] },
+      { name: "idx_bg_grants_table",   columns: ["scopeTable"] },
+      "expiresAt",
+      "revokedAt",
+    ],
+    derivedHashes: { issuedToActorHash: { from: "issuedToActorId" } },
+    sealedFields: ["reasonSealed", "scopeColumnsJson"],
+  },
 ];
 
 var log = boot("db");
@@ -1118,6 +1181,7 @@ module.exports = {
     try { require("./storage")._resetForTest(); }    catch (_e) {}
     try { require("./audit-sign")._resetForTest(); } catch (_e) {}
     try { require("./queue")._resetForTest(); } catch (_e) {}
+    try { require("./break-glass")._resetForTest(); } catch (_e) {}
     try { require("./log-stream")._resetForTest(); } catch (_e) {}
     try { require("./redact")._resetForTest(); } catch (_e) {}
     try { require("./external-db")._resetForTest(); } catch (_e) {}

package/lib/framework-schema.js

@@ -120,6 +120,11 @@ var LOCAL_TO_EXTERNAL = Object.freeze({
   // FRAMEWORK_SCHEMA so cluster-storage.execute routes to either side.
   _blamejs_seeders:        "_blamejs_seeders",
   _blamejs_seeders_lock:   "_blamejs_seeders_lock",
+  // Break-glass policy + grant tables. Cluster-shared so a grant
+  // issued on node A is honored on node B; policies updated on the
+  // leader propagate to all followers via the shared table.
+  _blamejs_break_glass_policies: "_blamejs_break_glass_policies",
+  _blamejs_break_glass_grants:   "_blamejs_break_glass_grants",
 });
 
 function tableName(localName) {
@@ -556,6 +561,70 @@ function _cacheDDL(dialect) {
   };
 }
 
+// _blamejs_break_glass_policies — column-level break-glass policy
+// registry. One row per (table) declares which columns are
+// glass-locked + the operator's grant rules. Sealed columns hide
+// column-list / factor-list / bypass config from cleartext browsing.
+function _breakGlassPoliciesDDL(dialect) {
+  var t = _types(dialect);
+  var name = LOCAL_TO_EXTERNAL._blamejs_break_glass_policies;
+  return {
+    create:
+      "CREATE TABLE IF NOT EXISTS " + name + " (" +
+      "  tableName                  TEXT PRIMARY KEY," +
+      "  columnsJson                TEXT NOT NULL," +
+      "  factorsJson                TEXT NOT NULL," +
+      "  cryptographic              " + t.INT + " NOT NULL DEFAULT 0," +
+      "  grantTtlMs                 " + t.INT + " NOT NULL," +
+      "  maxRowsPerGrant            " + t.INT + " NOT NULL DEFAULT 1," +
+      "  reasonRequired             " + t.INT + " NOT NULL DEFAULT 1," +
+      "  reasonMinLength            " + t.INT + " NOT NULL DEFAULT 12," +
+      "  pinIp                      " + t.INT + " NOT NULL DEFAULT 1," +
+      "  sessionPin                 " + t.INT + " NOT NULL DEFAULT 1," +
+      "  onLockedAccess             TEXT NOT NULL DEFAULT 'throw'," +
+      "  requireScope               TEXT," +
+      "  serviceAccountBypassJson   TEXT," +
+      "  auditReasonStorage         TEXT NOT NULL DEFAULT 'cleartext'," +
+      "  updatedAt                  " + t.INT + " NOT NULL" +
+      ")",
+    indexes: [],
+  };
+}
+
+// _blamejs_break_glass_grants — issued grants. One row per successful
+// step-up. Default maxRowsPerGrant=1 enforces row-by-row auth per the
+// operator-confirmed shape ("each row access = its own grant").
+function _breakGlassGrantsDDL(dialect) {
+  var t = _types(dialect);
+  var name = LOCAL_TO_EXTERNAL._blamejs_break_glass_grants;
+  return {
+    create:
+      "CREATE TABLE IF NOT EXISTS " + name + " (" +
+      "  _id                TEXT PRIMARY KEY," +
+      "  issuedToActorId    TEXT NOT NULL," +
+      "  issuedToActorHash  TEXT NOT NULL," +
+      "  factorType         TEXT NOT NULL," +
+      "  reasonSealed       TEXT," +
+      "  scopeTable         TEXT NOT NULL," +
+      "  scopeColumnsJson   TEXT NOT NULL," +
+      "  issuedAt           " + t.INT + " NOT NULL," +
+      "  expiresAt          " + t.INT + " NOT NULL," +
+      "  maxRowsPerGrant    " + t.INT + " NOT NULL," +
+      "  rowsConsumed       " + t.INT + " NOT NULL DEFAULT 0," +
+      "  revokedAt          " + t.INT + "," +
+      "  sessionId          TEXT," +
+      "  ip                 TEXT," +
+      "  kwGrantHalf        TEXT" +
+      ")",
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_" + name + "_actor   ON " + name + " (issuedToActorHash)",
+      "CREATE INDEX IF NOT EXISTS idx_" + name + "_table   ON " + name + " (scopeTable)",
+      "CREATE INDEX IF NOT EXISTS idx_" + name + "_expires ON " + name + " (expiresAt)",
+      "CREATE INDEX IF NOT EXISTS idx_" + name + "_revoked ON " + name + " (revokedAt)",
+    ],
+  };
+}
+
 // ---- ensureSchema ----
 
 async function ensureSchema(opts) {
@@ -590,6 +659,8 @@ async function ensureSchema(opts) {
     _cacheDDL(dialect),
     _seedersDDL(dialect),
     _seedersLockDDL(dialect),
+    _breakGlassPoliciesDDL(dialect),
+    _breakGlassGrantsDDL(dialect),
   ];
 
   var created = [];

package/lib/mail.js

@@ -62,15 +62,22 @@
  * resend-*. Vendor-specific presets carry their own code prefix so
  * diagnostic logs identify the provider that rejected the message.
  */
+var C = require("./constants");
 var lazyRequire = require("./lazy-require");
+var nodeCrypto = require("node:crypto");
 var audit = lazyRequire(function () { return require("./audit"); });
 var httpClient = lazyRequire(function () { return require("./http-client"); });
 var net = lazyRequire(function () { return require("net"); });
 var tls = lazyRequire(function () { return require("tls"); });
+var safeJson = require("./safe-json");
 var safeSchema = require("./safe-schema");
 var validateOpts = require("./validate-opts");
 var { FrameworkError } = require("./framework-error");
 
+// Cap on responses parsed from upstream mail providers (Resend, etc.).
+// Vendor responses are tiny in spec; 256 KiB is generous headroom.
+var MAIL_RESPONSE_MAX_BYTES = C.BYTES.kib(256);
+
 class MailError extends FrameworkError {
   constructor(code, message, permanent, statusCode) {
     super(message, code);
@@ -286,7 +293,11 @@ function memoryTransport() {
 // to send AUTH or DATA in cleartext if the upgrade is rejected.
 
 function _newBoundary(label) {
-  return "blamejs-" + label + "-" + Date.now() + "-" + Math.floor(Math.random() * 1e9);
+  // crypto.randomBytes for the boundary suffix matches the framework
+  // convention. RFC 5322 only requires uniqueness within a message,
+  // but consistency with how every other identifier in lib/ is built
+  // wins over premature differentiation.
+  return "blamejs-" + label + "-" + Date.now() + "-" + nodeCrypto.randomBytes(8).toString("hex");
 }
 
 // base64-encode the buffer with line wrapping at 76 chars (RFC 2045
@@ -773,7 +784,7 @@ function resendTransport(opts) {
     interpret: function (res) {
       var text = res.body ? res.body.toString("utf8") : "";
       var data;
-      try { data = JSON.parse(text); }
+      try { data = safeJson.parse(text, { maxBytes: MAIL_RESPONSE_MAX_BYTES }); }
       catch (_e) {
         throw new MailError("mail/resend-bad-response",
           "resend response was not JSON: " + text.slice(0, 200), false);

package/lib/middleware/api-encrypt.js

@@ -100,6 +100,8 @@ var crypto = require("../crypto");
 var C = require("../constants");
 var lazyRequire = require("../lazy-require");
 var nonceStoreLib = require("../nonce-store");
+var requestHelpers = require("../request-helpers");
+var safeJson = require("../safe-json");
 var validateOpts = require("../validate-opts");
 var { defineClass } = require("../framework-error");
 
@@ -172,10 +174,19 @@ function create(opts) {
   validateOpts(opts, [
     "keypair", "keypairs", "replayWindowMs", "pruneIntervalMs",
     "nonceStore", "exemptPaths", "contentTypes", "audit",
+    "maxDecryptedBytes",
   ], "middleware.apiEncrypt");
   var keypairs       = _resolveKeypairs(opts);
   var activeKeypair  = keypairs[0];
   var replayWindowMs = opts.replayWindowMs || DEFAULT_REPLAY_WINDOW_MS;
+  // Cap on decrypted-payload size handed to safeJson.parse. Defaults
+  // to 4 MiB (bodyParser's default 1 MiB plus headroom for crypto +
+  // base64 round-trip). Operators with chunkier inbound payloads
+  // raise this; the framework refuses to parse anything larger as a
+  // parse-bomb defense.
+  var maxDecryptedBytes = opts.maxDecryptedBytes != null
+    ? opts.maxDecryptedBytes
+    : C.BYTES.mib(4);
   // The spec calls for a sweep cadence of replayWindowMs/2 — short
   // enough that expired nonces don't pile up but not so frequent the
   // sweep query becomes a hot path. Operators can override.
@@ -230,7 +241,7 @@ function create(opts) {
     };
     if (auditOn) {
       audit().safeEmit({
-        actor:    { ip: info.ip },
+        actor:    requestHelpers.extractActorContext(req),
         action:   "system.api_encrypt.failure",
         outcome:  "denied",
         reason:   reason,
@@ -348,7 +359,7 @@ function create(opts) {
     try {
       var ctBuf = Buffer.from(ct, "base64");
       var ptBuf = crypto.decryptPacked(ctBuf, sessionKey);
-      clearObj = JSON.parse(ptBuf.toString("utf8"));
+      clearObj = safeJson.parse(ptBuf.toString("utf8"), { maxBytes: maxDecryptedBytes });
     } catch (_e) {
       _emitFailure(req, "tag");
       return _writeRejection(res, 400, { error: "encrypted-payload-rejected" });
@@ -403,7 +414,7 @@ function create(opts) {
 
 function client(opts) {
   opts = opts || {};
-  validateOpts(opts, ["pubkey"], "middleware.apiEncrypt.client");
+  validateOpts(opts, ["pubkey", "maxDecryptedBytes"], "middleware.apiEncrypt.client");
   if (!opts.pubkey || typeof opts.pubkey !== "object") {
     throw _err("CLIENT_INVALID_PUBKEY",
       "apiEncrypt.client: opts.pubkey is required ({ publicKey, ecPublicKey })", 500);
@@ -414,6 +425,9 @@ function client(opts) {
       "apiEncrypt.client: pubkey.publicKey + ecPublicKey must be PEM strings", 500);
   }
   var pubkey = opts.pubkey;
+  var maxDecryptedBytes = opts.maxDecryptedBytes != null
+    ? opts.maxDecryptedBytes
+    : C.BYTES.mib(4);
 
   function encryptRequest(payload) {
     if (payload === undefined) payload = null;
@@ -441,7 +455,7 @@ function client(opts) {
         }
         var resCtBuf = Buffer.from(responseBody._ct, "base64");
         var resPtBuf = crypto.decryptPacked(resCtBuf, sessionKey);
-        return JSON.parse(resPtBuf.toString("utf8"));
+        return safeJson.parse(resPtBuf.toString("utf8"), { maxBytes: maxDecryptedBytes });
       },
     };
   }
@@ -474,13 +488,16 @@ function client(opts) {
 function httpClientEncrypted(opts) {
   opts = opts || {};
   validateOpts(opts, [
-    "pubkey", "baseUrl", "headers", "method",
+    "pubkey", "baseUrl", "headers", "method", "maxDecryptedBytes",
   ], "middleware.apiEncrypt.httpClient");
   if (!opts.pubkey) {
     throw _err("CLIENT_INVALID_PUBKEY",
       "httpClient.encrypted: opts.pubkey is required (the callee's bootstrap doc)", 500);
   }
-  var clientCtx     = client({ pubkey: opts.pubkey });
+  var maxDecryptedBytes = opts.maxDecryptedBytes != null
+    ? opts.maxDecryptedBytes
+    : C.BYTES.mib(4);
+  var clientCtx     = client({ pubkey: opts.pubkey, maxDecryptedBytes: maxDecryptedBytes });
   var baseUrl       = opts.baseUrl ? String(opts.baseUrl).replace(/\/$/, "") : "";
   var defaultHdrs   = opts.headers || {};
   var defaultMethod = opts.method  || "POST";
@@ -531,7 +548,7 @@ function httpClientEncrypted(opts) {
       return { statusCode: resp.statusCode, headers: resp.headers, body: null };
     }
     var parsed;
-    try { parsed = JSON.parse(resp.body.toString("utf8")); }
+    try { parsed = safeJson.parse(resp.body.toString("utf8"), { maxBytes: maxDecryptedBytes }); }
     catch (e) {
       throw _err("CLIENT_RESPONSE_NOT_JSON",
         "httpClient.encrypted: response body is not valid JSON: " + e.message);

package/lib/middleware/attach-user.js

@@ -43,6 +43,7 @@
  */
 var lazyRequire = require("../lazy-require");
 var cookies = require("../cookies");
+var requestHelpers = require("../request-helpers");
 var validateOpts = require("../validate-opts");
 var session = lazyRequire(function () { return require("../session"); });
 var audit   = lazyRequire(function () { return require("../audit"); });
@@ -120,7 +121,7 @@ function create(opts) {
           audit().emit({
             action:   "auth.session.user_loader_threw",
             outcome:  "failure",
-            actor:    { userId: verified.userId, ip: req.socket && req.socket.remoteAddress },
+            actor:    requestHelpers.extractActorContext(req, { userId: verified.userId }),
             reason:   (e && e.message) || String(e),
           });
         } catch (_ignored) { /* audit best-effort */ }
@@ -135,7 +136,7 @@ function create(opts) {
           audit().emit({
             action:   "auth.session.user_unloadable",
             outcome:  "failure",
-            actor:    { userId: verified.userId, ip: req.socket && req.socket.remoteAddress },
+            actor:    requestHelpers.extractActorContext(req, { userId: verified.userId }),
           });
         } catch (_ignored) { /* audit best-effort */ }
       }

package/lib/middleware/cors.js

@@ -44,10 +44,20 @@
  */
 var lazyRequire = require("../lazy-require");
 var audit = lazyRequire(function () { return require("../audit"); });
+var requestHelpers = require("../request-helpers");
 var safeUrl = require("../safe-url");
 var validateOpts = require("../validate-opts");
 var { defineClass } = require("../framework-error");
 
+// CORS audit events trust the proxy header for actor.ip — same
+// semantics as bot-guard (the apparent origin is what matters when
+// blocking cross-origin attempts behind a CDN).
+function _xffIp(req) {
+  var xff = req.headers && req.headers["x-forwarded-for"];
+  if (xff) return String(xff).split(",")[0].trim();
+  return (req.socket && req.socket.remoteAddress) || null;
+}
+
 var CorsError = defineClass("CorsError", { alwaysPermanent: true });
 
 function _matchOrigin(origin, allowList) {
@@ -188,7 +198,7 @@ function create(opts) {
       if (refuseUnknown) {
         try {
           audit().emit({
-            actor:    { ip: (req.headers && req.headers["x-forwarded-for"]) || (req.socket && req.socket.remoteAddress) },
+            actor:    requestHelpers.extractActorContext(req, { ip: _xffIp(req) }),
             action:   "system.cors.block",
             outcome:  "denied",
             reason:   "origin not in allow-list",

package/lib/notify.js

@@ -370,15 +370,7 @@ function create(opts) {
   }
 
   function _actor(callerOpts) {
-    var override = {};
-    if (callerOpts && callerOpts.context && typeof callerOpts.context === "object") {
-      for (var k in callerOpts.context) {
-        if (Object.prototype.hasOwnProperty.call(callerOpts.context, k)) {
-          override[k] = callerOpts.context[k];
-        }
-      }
-    }
-    return requestHelpers.extractActorContext(callerOpts && callerOpts.req, override);
+    return requestHelpers.resolveActorWithOverride(callerOpts);
   }
 
   function _redactedMetadata(channel, message, extra) {

package/lib/request-helpers.js

@@ -87,6 +87,31 @@ function extractActorContext(req, override) {
   return ctx;
 }
 
+// Convenience wrapper for primitives that accept an optional
+// `{ req, context }` shape and want to thread it into an audit-emit
+// `actor` field. Replaces the four near-identical `_actor()` helpers
+// that lived in api-key, cache, seeders, and notify before v0.4.29.
+//
+//   callerOpts:    operator-supplied `{ req?, context? }` (e.g. the
+//                  primitive's call-site opts bag)
+//   baseOverride:  optional seed values applied BEFORE callerOpts.context
+//                  so `context` wins. api-key seeds `{ userId }` here so
+//                  the resolved key's owner becomes the default actor
+//                  unless the operator passes their own context.userId.
+//
+// Returns the same shape as extractActorContext.
+function resolveActorWithOverride(callerOpts, baseOverride) {
+  var override = baseOverride ? Object.assign({}, baseOverride) : {};
+  if (callerOpts && callerOpts.context && typeof callerOpts.context === "object") {
+    for (var k in callerOpts.context) {
+      if (Object.prototype.hasOwnProperty.call(callerOpts.context, k)) {
+        override[k] = callerOpts.context[k];
+      }
+    }
+  }
+  return extractActorContext(callerOpts && callerOpts.req, override);
+}
+
 function resolveRoute(req) {
   if (req && typeof req.routePattern === "string" && req.routePattern.length > 0) {
     return req.routePattern;
@@ -171,8 +196,9 @@ function parseQualityList(headerValue, opts) {
 }
 
 module.exports = {
-  resolveRoute:          resolveRoute,
-  captureResponseStatus: captureResponseStatus,
-  extractActorContext:   extractActorContext,
-  parseQualityList:      parseQualityList,
+  resolveRoute:              resolveRoute,
+  captureResponseStatus:     captureResponseStatus,
+  extractActorContext:       extractActorContext,
+  resolveActorWithOverride:  resolveActorWithOverride,
+  parseQualityList:          parseQualityList,
 };

package/lib/restore-rollback.js

@@ -56,6 +56,8 @@
 var fs = require("fs");
 var path = require("path");
 var atomicFile = require("./atomic-file");
+var C = require("./constants");
+var safeJson = require("./safe-json");
 var { defineClass } = require("./framework-error");
 
 var RestoreRollbackError = defineClass("RestoreRollbackError", { alwaysPermanent: true });
@@ -199,7 +201,7 @@ function list(opts) {
     var markerPath = p + ".marker.json";
     var marker = null;
     if (fs.existsSync(markerPath)) {
-      try { marker = JSON.parse(fs.readFileSync(markerPath, "utf8")); }
+      try { marker = safeJson.parse(fs.readFileSync(markerPath, "utf8"), { maxBytes: C.BYTES.kib(64) }); }
       catch (_e) { marker = null; }
     }
     var stat;

package/lib/seeders.js

@@ -404,15 +404,7 @@ function create(opts) {
   }
 
   function _actor(callerOpts) {
-    var override = {};
-    if (callerOpts && callerOpts.context && typeof callerOpts.context === "object") {
-      for (var k in callerOpts.context) {
-        if (Object.prototype.hasOwnProperty.call(callerOpts.context, k)) {
-          override[k] = callerOpts.context[k];
-        }
-      }
-    }
-    return requestHelpers.extractActorContext(callerOpts && callerOpts.req, override);
+    return requestHelpers.resolveActorWithOverride(callerOpts);
   }
 
   function _appliedRows(db, env) {

package/lib/vault/rotate.js

@@ -56,6 +56,7 @@ var C = require("../constants");
 var cryptoField = require("../crypto-field");
 var cryptoLib = require("../crypto");
 var lazyRequire = require("../lazy-require");
+var safeJson = require("../safe-json");
 var vaultWrap = lazyRequire(function () { return require("./wrap"); });
 var { defineClass } = require("../framework-error");
 
@@ -479,7 +480,10 @@ function _rotateOverflow(db, table, oldKeys, newKeys, batchSize, progress, warni
       for (var i = 0; i < rows.length; i++) {
         var row = rows[i];
         var doc;
-        try { doc = JSON.parse(row.data); }
+        // Vault overflow rows are framework-written but read at rotate
+        // time — gate the parse via safeJson so a corrupted row can't
+        // stage a parse-bomb against the rotation worker.
+        try { doc = safeJson.parse(row.data, { maxBytes: C.BYTES.mib(16) }); }
         catch (_e) {
           warnings.push("malformed overflow JSON at " + table + "._id=" + row._id + " — left unrotated");
           continue;

package/package.json

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