@blamejs/core 0.14.9 → 0.14.11

package/lib/crypto-field.js

@@ -235,6 +235,74 @@ function _computeDerivedHash(spec, tableMode, ns, normalized) {
   return sha3Hash(vault.getDerivedHashSalt().toString("hex") + ns + normalized);
 }
 
+/**
+ * @primitive b.cryptoField.computeNamespacedHash
+ * @signature b.cryptoField.computeNamespacedHash(ns, value, opts?)
+ * @since     0.14.10
+ * @compliance gdpr, hipaa
+ * @related   b.cryptoField.computeDerived, b.cryptoField.lookupHash
+ *
+ * Computes a namespaced indexed-lookup digest of `value` for a
+ * pseudo-field that is NOT backed by a registered derived-hash column
+ * (e.g. the sealed-token FTS index in `b.mailStore.fts`). The caller
+ * supplies the full namespace string directly — there is no schema
+ * lookup — so the same keyed/salted hash machinery that protects
+ * registered derived hashes also covers ad-hoc indexed tokens. This is
+ * the canonical entry point: hand-rolling
+ * `sha3Hash(vault.getDerivedHashSalt() + ns + value)` at a call site
+ * bypasses the keyed-MAC mode (`hmac-shake256` off
+ * `vault.getDerivedHashMacKey`) and the per-deployment salt policy.
+ *
+ * `opts.mode` selects the digest:
+ *   - `"salted-sha3"` (default): SHA3-512 over `<salt-hex> + ns + value`
+ *     (deterministic per deployment; byte-identical to the legacy
+ *     hand-rolled scheme).
+ *   - `"hmac-shake256"`: SHAKE256(`<vault MAC key> || ns + value`) — a
+ *     keyed MAC so an attacker who recovers the salt alone cannot
+ *     correlate two low-entropy plaintexts.
+ *
+ * `opts.truncateBytes` truncates the hex digest to that many BYTES
+ * (the hex string is sliced to `truncateBytes * 2` characters). Throws
+ * (config-time / entry-point tier) on an unknown `mode` or a
+ * non-positive-integer `truncateBytes` so an operator catches the typo
+ * at boot rather than silently indexing under a malformed digest.
+ *
+ * @opts
+ *   mode:          string,   // "salted-sha3" (default) | "hmac-shake256"
+ *   truncateBytes: number,   // optional; positive integer byte width to slice to
+ *
+ * @example
+ *   var ns = "bj-mail_messages-body:fts:";
+ *   var h = b.cryptoField.computeNamespacedHash(ns, "kubernetes", {
+ *     mode: "hmac-shake256", truncateBytes: 8
+ *   });
+ *   /^[0-9a-f]{16}$/.test(h);   // → true
+ *
+ *   // Default mode is byte-identical to the legacy salted-sha3 hash.
+ *   b.cryptoField.computeNamespacedHash(ns, "kubernetes").length;   // → 128
+ */
+function computeNamespacedHash(ns, value, opts) {
+  opts = opts || {};
+  var mode = opts.mode || "salted-sha3";
+  if (mode !== "salted-sha3" && mode !== "hmac-shake256") {
+    throw new Error("computeNamespacedHash: opts.mode must be 'salted-sha3' " +
+      "(default) or 'hmac-shake256', got " + JSON.stringify(mode));
+  }
+  var truncateBytes = opts.truncateBytes;
+  if (truncateBytes !== undefined) {
+    if (typeof truncateBytes !== "number" || !isFinite(truncateBytes) ||
+        truncateBytes <= 0 || Math.floor(truncateBytes) !== truncateBytes) {
+      throw new Error("computeNamespacedHash: opts.truncateBytes must be a " +
+        "positive integer (bytes), got " + JSON.stringify(truncateBytes));
+    }
+  }
+  var hex = _computeDerivedHash({ mode: mode }, mode, ns, String(value));
+  if (truncateBytes !== undefined) {
+    return hex.slice(0, truncateBytes * 2);
+  }
+  return hex;
+}
+
 /**
  * @primitive b.cryptoField.getSchema
  * @signature b.cryptoField.getSchema(table)
@@ -1046,6 +1114,7 @@ module.exports = {
   applyPosture:     applyPosture,
   getActivePosture: getActivePosture,
   computeDerived:   computeDerived,
+  computeNamespacedHash: computeNamespacedHash,
   lookupHash:       lookupHash,
   clearForTest:     clearForTest,
   declareColumnResidency: declareColumnResidency,

package/lib/framework-error.js

@@ -412,6 +412,20 @@ var McpError              = defineClass("McpError",              { alwaysPermane
 // input shape, classifier-result-shape errors, oversized input bypass.
 // Permanent — caller-shape errors.
 var AiInputError          = defineClass("AiInputError",          { alwaysPermanent: true });
+// AiOutputError covers LLM output-handling violations raised by
+// b.ai.output.sanitize / b.ai.output.redact: malformed input shape
+// (non-string), oversized output bypass (exceeds maxBytes cap), bad
+// maxBytes opt, unknown redaction entity. Permanent — caller-shape
+// errors that retry will not recover. OWASP LLM05:2025 (Improper
+// Output Handling) + LLM02:2025 (Sensitive Information Disclosure).
+var AiOutputError         = defineClass("AiOutputError",         { alwaysPermanent: true });
+// AiPromptError covers LLM prompt-assembly violations raised by
+// b.ai.prompt.template: malformed segment shape (non-string system /
+// context / user), bad maxBytes / nonceBytes opt, oversized assembled
+// prompt. Permanent — caller-shape errors that retry will not recover.
+// OWASP LLM01:2025 (Prompt Injection — indirect / data-plane injection
+// from untrusted context).
+var AiPromptError         = defineClass("AiPromptError",         { alwaysPermanent: true });
 // A2aError covers A2A (Agent-to-Agent) protocol violations: signed-
 // agent-card signature mismatch, expired card, unknown card id,
 // malformed card shape, signature-algorithm allowlist drift.
@@ -691,6 +705,8 @@ module.exports = {
   SseError:               SseError,
   McpError:               McpError,
   AiInputError:           AiInputError,
+  AiOutputError:          AiOutputError,
+  AiPromptError:          AiPromptError,
   A2aError:               A2aError,
   GraphqlFederationError: GraphqlFederationError,
   Fda21Cfr11Error:        Fda21Cfr11Error,

package/lib/mail-store-fts.js

@@ -54,10 +54,23 @@
  *   nothing readable; search works against ciphertext.
  */
 
-var bCrypto      = require("./crypto");
-var vault        = require("./vault");
+var cryptoField  = require("./crypto-field");
 var C            = require("./constants");
 
+// Sealed-token FTS on-disk format version. Bumped when the token-hash
+// transform changes so the mail-store reindex path can detect a stale
+// index and rebuild it from the sealed messages table. v1 was the
+// legacy salted-sha3-truncated hand-roll; v2 is the keyed
+// hmac-shake256 digest computed via cryptoField.computeNamespacedHash.
+var FTS_FORMAT_VERSION = 2;
+
+// Per-token hash width, in bytes. 8 bytes -> 16 hex chars. Full 64-char
+// SHA3 / SHAKE digest is overkill for the FTS hash space, and the
+// shorter token compresses the FTS5 row 4x without observable collision
+// risk at corpus sizes the framework targets (<= 10^9 unique tokens,
+// where 64-bit collision space leaves the birthday bound > 10^9).
+var FTS_HASH_BYTES = 8;
+
 // Stopwords are dropped before hashing — they'd dominate every row's
 // token set without adding query selectivity. Kept conservative to
 // stay locale-neutral for v1.
@@ -154,26 +167,29 @@ function tokenize(text) {
   return out;
 }
 
-// Hash one token using the same scheme cryptoField uses for derived-
-// hash mirrors: `sha3Hash(vaultSalt + namespace + token)`. The
+// Hash one token through the canonical cryptoField primitive
+// (computeNamespacedHash) so the FTS index inherits the keyed-MAC
+// digest used for derived-hash mirrors on sealed columns. The
 // namespace is per-table, per-field, per-purpose ("fts") so that
-// rotating an operator's vault salt invalidates every FTS row in
-// the same step as every sealed column. Returns a 16-char hex prefix
-// — full 64-char SHA3 is overkill for FTS hash space, and shorter
-// tokens compress the FTS5 row 4x without observable collision risk
-// at corpus sizes the framework targets (≤ 10^9 unique tokens, where
-// 64-bit collision space leaves the birthday bound > 10^9).
+// rotating an operator's vault key invalidates every FTS row in the
+// same step as every sealed column. Returns a 16-char hex prefix
+// (FTS_HASH_BYTES bytes) — full 64-char digest is overkill for the
+// FTS hash space, and shorter tokens compress the FTS5 row 4x without
+// observable collision risk at corpus sizes the framework targets
+// (<= 10^9 unique tokens, where 64-bit collision space leaves the
+// birthday bound > 10^9).
 /**
  * @primitive b.mailStore.fts.hashToken
  * @signature b.mailStore.fts.hashToken(table, field, token)
  * @since     0.11.25
  * @status    stable
  *
- * Vault-salted hash of one token under the (table, field) namespace.
- * The same scheme `b.cryptoField.computeDerived` uses for derived-
- * hash mirrors on sealed columns — rotating the vault salt
- * invalidates every FTS hash in step with every sealed-column hash.
- * Returns a 16-char hex prefix.
+ * Keyed hash of one token under the (table, field) namespace. Routes
+ * through `b.cryptoField.computeNamespacedHash` in `hmac-shake256`
+ * mode — the same keyed-MAC machinery that protects sealed-column
+ * derived hashes — so rotating the vault key invalidates every FTS
+ * hash in step with every sealed-column hash. Returns a 16-char hex
+ * prefix.
  *
  * @example
  *   var h = b.mailStore.fts.hashToken("mail_messages", "body", "kubernetes");
@@ -185,9 +201,10 @@ function hashToken(table, field, token) {
   // fields are pseudo-fields (no sealed-column registration), so the
   // canonical fallback path is always the right answer here.
   var ns = "bj-" + table + "-" + field + ":fts:";
-  var salt = vault.getDerivedHashSalt();
-  var saltHex = (salt && typeof salt.toString === "function") ? salt.toString("hex") : "";
-  return bCrypto.sha3Hash(saltHex + ns + token).slice(0, 16);                                          // 16-char hex prefix length, not bytes
+  return cryptoField.computeNamespacedHash(ns, token, {
+    mode:          "hmac-shake256",
+    truncateBytes: FTS_HASH_BYTES,
+  });
 }
 
 // Hash a token array → space-separated string suitable for FTS5
@@ -391,4 +408,9 @@ module.exports = {
   MAX_TOKEN_LEN:       MAX_TOKEN_LEN,
   MAX_TOKENS_PER_FIELD: MAX_TOKENS_PER_FIELD,
   FTS_FIELDS:          FTS_FIELDS,
+  FTS_HASH_BYTES:      FTS_HASH_BYTES,
+  // On-disk format marker — the mail-store reindex path stamps this
+  // into `<prefix>_meta` once a full rebuild completes; a stale/missing
+  // marker triggers a rebuild from the sealed messages table.
+  FTS_FORMAT_VERSION:  FTS_FORMAT_VERSION,
 };

package/lib/mail-store.js

@@ -60,6 +60,7 @@
 var C = require("./constants");
 var bCrypto = require("./crypto");
 var cryptoField = require("./crypto-field");
+var vault = require("./vault");
 var safeMime = require("./safe-mime");
 var safeSql = require("./safe-sql");
 var guardMessageId = require("./guard-message-id");
@@ -72,6 +73,14 @@ var DEFAULT_TABLE_PREFIX = "blamejs_mail";
 var DEFAULT_MAX_MESSAGE_BYTES = C.BYTES.mib(50);
 var DEFAULT_MAX_BODY_BYTES    = C.BYTES.mib(25);
 
+// `<prefix>_meta` marker key carrying the FTS on-disk format version.
+// The reindex path writes a `'rebuilding'` sentinel BEFORE clearing the
+// index and the final format-version string only AFTER every row is
+// reinserted, so a partial / interrupted rebuild is never marked
+// complete and never queried as a finished index.
+var FTS_FORMAT_META_KEY = "fts_format";
+var FTS_REBUILDING_SENTINEL = "rebuilding";
+
 // Standard IMAP4rev2 default folders + JMAP role mapping.
 var DEFAULT_FOLDERS = Object.freeze([
   { name: "INBOX",   role: "inbox" },
@@ -129,6 +138,7 @@ function create(opts) {
   var qFlags   = safeSql.quoteIdentifier(prefix + "_flags",     "sqlite");
   var qQuota   = safeSql.quoteIdentifier(prefix + "_quota",     "sqlite");
   var qFts     = safeSql.quoteIdentifier(prefix + "_messages_fts", "sqlite");
+  var qMeta    = safeSql.quoteIdentifier(prefix + "_meta",      "sqlite");
   var messagesTable = prefix + "_messages";
 
   var maxMessageBytes = opts.maxMessageBytes !== undefined ? opts.maxMessageBytes : DEFAULT_MAX_MESSAGE_BYTES;
@@ -150,7 +160,7 @@ function create(opts) {
   });
 
   if (doInit) {
-    _ensureSchema(db, qMsgs, qFolders, qFlags, qQuota, qFts);
+    _ensureSchema(db, qMsgs, qFolders, qFlags, qQuota, qFts, qMeta);
     _ensureDefaultFolders(db, qFolders);
   }
 
@@ -207,6 +217,150 @@ function create(opts) {
     "INSERT INTO " + qFts + " (objectid, subject_toks, addr_toks, body_toks) VALUES (?, ?, ?, ?)");
   var stmtDeleteFts        = db.prepare("DELETE FROM " + qFts + " WHERE objectid = ?");
 
+  // `<prefix>_meta` marker read — used by the reindex gate at create()
+  // AND by every FTS query path (search) to refuse a half-built index.
+  // Guarded behind a closure so a store opened with init:false against a
+  // pre-format-version database (no _meta table) reads as "no marker"
+  // instead of throwing.
+  function _readFtsMarker() {
+    try {
+      var row = db.prepare("SELECT value FROM " + qMeta + " WHERE key = ?")
+        .get(FTS_FORMAT_META_KEY);
+      return row ? row.value : null;
+    } catch (_e) {
+      // _meta table absent (init:false against a legacy store) — treat
+      // as no marker so the FTS query path falls back rather than
+      // querying a possibly-stale index as if it were current.
+      return null;
+    }
+  }
+  // The FTS index is queryable only when the on-disk marker equals the
+  // current format version. A `'rebuilding'` sentinel or any other
+  // value (stale format, missing marker) means the index is non-final;
+  // search() falls back to the modseq cursor rather than returning
+  // partial / mixed-scheme FTS hits.
+  var CURRENT_FTS_FMT = String(mailStoreFts.FTS_FORMAT_VERSION);
+  function _ftsIndexUsable() {
+    return _readFtsMarker() === CURRENT_FTS_FMT;
+  }
+
+  // Reindex-on-upgrade. Runs once at create() (when doInit) AFTER the
+  // schema is ensured. Rebuilds the sealed-token FTS index from the
+  // canonical (sealed) messages table whenever the on-disk format
+  // marker is missing or stale — the token-hash transform changed, so
+  // every previously-indexed row hashes to a different value and the
+  // old rows are unsearchable under the new scheme.
+  //
+  // Data-safety contract:
+  //   - A `'rebuilding'` sentinel is written BEFORE the DELETE, so an
+  //     interrupted rebuild leaves a non-final marker; search() refuses
+  //     the index until a later create() completes the rebuild.
+  //   - The DELETE + every reinsert run inside an explicit
+  //     BEGIN/COMMIT/ROLLBACK (ordinary SQLite — works on node:sqlite
+  //     and b.db alike; neither exposes a usable `.transaction(fn)()`
+  //     for this shape). A throw inside the insert loop rolls the whole
+  //     rebuild back, leaving the OLD index intact + queryable... except
+  //     the marker still reads as non-final, so search falls back until
+  //     the next successful create() — the index is never silently
+  //     half-built.
+  //   - The final format-version marker is written ONLY after every row
+  //     reinserts and the COMMIT lands.
+  function _reindexFts() {
+    var fmt = _readFtsMarker();
+    if (fmt === CURRENT_FTS_FMT) return { reindexed: false, reason: "current" };
+
+    // Count existing FTS rows AFTER the early-return so the common
+    // already-current path pays nothing for the scan.
+    var ftsCountRow = db.prepare("SELECT COUNT(*) AS n FROM " + qFts).get();
+    var ftsCount = (ftsCountRow && ftsCountRow.n) || 0;
+    var msgCountRow = db.prepare("SELECT COUNT(*) AS n FROM " + qMsgs).get();
+    var msgCount = (msgCountRow && msgCountRow.n) || 0;
+
+    // Fresh store — no marker AND nothing indexed AND no messages to
+    // index. Just stamp the current format; there is nothing to rebuild.
+    if (fmt === null && ftsCount === 0 && msgCount === 0) {
+      _writeFtsMarker(CURRENT_FTS_FMT);
+      return { reindexed: false, reason: "fresh" };
+    }
+
+    // Reindex unseals EVERY message row — a runtime dependency on the
+    // vault that a bare create() otherwise wouldn't have. Fail loud at
+    // boot (entry-point tier) rather than silently leaving a stale,
+    // wrong-scheme index searchable: an operator who constructs the
+    // store before vault.init() must see the misordering immediately.
+    if (!vault.isInitialized()) {
+      throw new MailStoreError("mail-store/fts-reindex-vault-uninitialized",
+        "mailStore.create: FTS index format is stale (marker=" +
+        JSON.stringify(fmt) + ", current=" + CURRENT_FTS_FMT + ") and a " +
+        "reindex from the sealed messages table requires the vault - call " +
+        "b.vault.init(...) BEFORE b.mailStore.create(...). Refusing to leave " +
+        "a stale, wrong-scheme search index queryable.");
+    }
+
+    // Sentinel BEFORE any destructive work — a crash between here and
+    // the final marker leaves the index marked non-final.
+    _writeFtsMarker(FTS_REBUILDING_SENTINEL);
+
+    // BEGIN IMMEDIATE takes the write lock up front so the message
+    // snapshot, the FTS delete, and the reinsert are one isolated window.
+    // The snapshot is read INSIDE the lock: a concurrent writer in another
+    // process cannot append a message between the snapshot and the delete
+    // (which would otherwise drop that row's freshly-inserted FTS entry
+    // without re-adding it, silently losing it from search).
+    var allRows;
+    db.prepare("BEGIN IMMEDIATE").run();
+    try {
+      allRows = db.prepare("SELECT * FROM " + qMsgs).all();
+      db.prepare("DELETE FROM " + qFts).run();
+      for (var i = 0; i < allRows.length; i += 1) {
+        // unsealRow returns the DB column names (subject / from_addr /
+        // to_addrs / body_text); map them into the FTS param shape
+        // (subject / from / to / body) rowFromMessage expects.
+        var clear = cryptoField.unsealRow(messagesTable, allRows[i]);
+        var ftsRow = mailStoreFts.rowFromMessage(messagesTable, {
+          objectid: clear.objectid,
+          subject:  clear.subject   || "",
+          from:     clear.from_addr || "",
+          to:       clear.to_addrs  || "",
+          body:     clear.body_text || "",
+        });
+        stmtInsertFts.run(ftsRow.objectid, ftsRow.subject_toks,
+          ftsRow.addr_toks, ftsRow.body_toks);
+      }
+      db.prepare("COMMIT").run();
+    } catch (e) {
+      // Roll the partial rebuild back — the OLD index rows are restored
+      // (the DELETE is undone), so the prior scheme stays intact and
+      // queryable. The marker still reads as the sentinel, so search()
+      // falls back until a later create() completes the rebuild: a
+      // retriable, never-silently-half-built state.
+      try { db.prepare("ROLLBACK").run(); } catch (_re) { /* best-effort */ }
+      throw new MailStoreError("mail-store/fts-reindex-failed",
+        "mailStore.create: FTS reindex from the sealed messages table " +
+        "failed and was rolled back (the prior index is intact); retry " +
+        "after resolving: " + ((e && e.message) || String(e)));
+    }
+
+    // Full rebuild committed — stamp the current format LAST so the
+    // index only reads as final once every row is present.
+    _writeFtsMarker(CURRENT_FTS_FMT);
+    return { reindexed: true, rows: allRows.length };
+  }
+
+  function _writeFtsMarker(value) {
+    db.prepare(
+      "INSERT INTO " + qMeta + " (key, value) VALUES (?, ?) " +
+      "ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    ).run(FTS_FORMAT_META_KEY, value);
+  }
+
+  // Wire the reindex into create() AFTER schema bootstrap. A fresh store
+  // (no marker, 0 FTS rows, 0 messages) just stamps the format; a store
+  // carrying an old-format index rebuilds from the sealed rows.
+  if (doInit) {
+    _reindexFts();
+  }
+
   return {
     appendMessage:    function (folderName, rawBytes, appendOpts) {
       // Wrap canonical row insert + FTS row insert in a single backend
@@ -277,6 +431,27 @@ function create(opts) {
       var limit = f.limit || 100;
       if (limit > 1000) limit = 1000;                                                                  // query row cap, not bytes
 
+      // The FTS index is queryable only when the on-disk format marker
+      // is current. A `'rebuilding'` sentinel (mid-rebuild / interrupted
+      // rebuild) or a stale/missing marker means the index is non-final
+      // — fall back to the bare modseq cursor rather than returning
+      // partial or wrong-scheme FTS hits. Returning a subset of the true
+      // matches as if it were complete is the corruption hazard the
+      // reindex sentinel exists to prevent.
+      if (!_ftsIndexUsable()) {
+        var nonFinal = stmtQueryByModseq.all(folder.id, sinceModseq, limit);
+        return {
+          rows: nonFinal.map(function (r) {
+            return {
+              objectid: r.objectid, modseq: r.modseq, sizeBytes: r.size_bytes,
+              internalDate: r.internal_date, legalHold: r.legal_hold === 1,
+            };
+          }),
+          nextModseq: nonFinal.length > 0 ? nonFinal[nonFinal.length - 1].modseq : sinceModseq,
+          ftsUnavailable: true,
+        };
+      }
+
       var matchClauses = [];
       function addMatch(filterKey, term) {
         if (!term) return;
@@ -834,7 +1009,7 @@ function _normalizeMsgId(s) {
 
 // ---- Schema bootstrap ----------------------------------------------------
 
-function _ensureSchema(db, qMsgs, qFolders, qFlags, qQuota, qFts) {
+function _ensureSchema(db, qMsgs, qFolders, qFlags, qQuota, qFts, qMeta) {
   // Folders table — created first since messages reference folder_id.
   db.prepare(
     "CREATE TABLE IF NOT EXISTS " + qFolders + " (" +
@@ -910,6 +1085,17 @@ function _ensureSchema(db, qMsgs, qFolders, qFlags, qQuota, qFts) {
   // tokens on whitespace exactly — hashes are ASCII-hex-only, so no
   // Unicode case-fold runs at MATCH time.
   db.prepare(mailStoreFts.createSql(qFts)).run();
+
+  // Per-prefix key/value metadata table. Holds the FTS on-disk format
+  // marker (`fts_format`) so the reindex path can detect a stale index
+  // and rebuild it. Scoped per table-prefix (NOT PRAGMA user_version,
+  // which is db-global and would collide across stores sharing one
+  // sqlite file).
+  db.prepare(
+    "CREATE TABLE IF NOT EXISTS " + qMeta + " (" +
+    "key TEXT PRIMARY KEY, " +
+    "value TEXT)"
+  ).run();
 }
 
 function _ensureDefaultFolders(db, qFolders) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.14.9",
+  "version": "0.14.11",
   "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:1e3ccafc-71e3-4207-a3d7-5672ad58b137",
+  "serialNumber": "urn:uuid:51d93d1b-aac7-4b5a-b94b-b60595c0eba0",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-05-31T04:50:32.275Z",
+    "timestamp": "2026-05-31T14:46:52.063Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.14.9",
+      "bom-ref": "@blamejs/core@0.14.11",
       "type": "application",
       "name": "blamejs",
-      "version": "0.14.9",
+      "version": "0.14.11",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.14.9",
+      "purl": "pkg:npm/%40blamejs/core@0.14.11",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.14.9",
+      "ref": "@blamejs/core@0.14.11",
       "dependsOn": []
     }
   ]