@blamejs/blamejs-shop 0.2.12 → 0.2.14

package/lib/vendor/blamejs/lib/mcp.js

@@ -399,10 +399,10 @@ function serverGuard(opts) {
  * exfiltration endpoints. The framework's defense:
  *
  *   - Strip / refuse executable HTML (`<script>` / `<iframe>` /
- *     `javascript:` URLs) — composes b.guardHtml's strict profile
+ *     `javascript:` URLs) via built-in dangerous-HTML detection
  *   - Refuse known prompt-injection markers ("ignore previous
  *     instructions", "system: you are now ...", role-claim prefixes)
- *     — composes b.ai.input.classify
+ *     via a built-in injection-marker matcher
  *   - Cap text length so a tool can't blow the host's context window
  *     out from under it
  *   - Refuse content with `image_url` / `audio_url` / `resource_link`
@@ -418,7 +418,6 @@ function serverGuard(opts) {
  *     posture?:        "refuse" | "sanitize" | "audit-only",  // default "refuse"
  *     maxTextBytes?:   number,    // default 64 KiB per content block
  *     allowedHosts?:   string[],  // for image/audio/resource_link refs
- *     classifyInput?:  fn(text)→{verdict, score} | null,      // default b.ai.input.classify
  *   }
  *
  * @example

package/lib/vendor/blamejs/lib/middleware/age-gate.js

@@ -53,16 +53,20 @@ var AgeGateError = defineClass("AgeGateError", { alwaysPermanent: true });
  * Classifies the request against an operator-supplied age predicate
  * and applies COPPA / UK Children's Code / California AADC defaults
  * (no-store cache, no-referrer, X-Privacy-Posture header) for
- * below-threshold + unknown-age requests. When `requireAge` is set
- * and the request is below threshold without a parental-consent
- * record, refuses with HTTP 451. Every classification decision is
- * audited.
+ * below-threshold + unknown-age requests. `requireAge` is the hard
+ * legal floor: a request classified below threshold without a
+ * parental-consent record is refused with HTTP 451. It is evaluated
+ * within the consent classification, so it takes effect only when
+ * `consentRequired` is also set (that is what classifies a request as
+ * below-threshold); `requireAge` alone, with `consentRequired: null`,
+ * never classifies a request as below-threshold and so the 451 never
+ * fires. Every classification decision is audited.
  *
  * @opts
  *   {
  *     getAge:             function(req): number|null,  // required
- *     requireAge:         number|null,                  // 451 below this
- *     consentRequired:    number|null,                  // require consent below
+ *     requireAge:         number|null,                  // 451 floor; requires consentRequired set
+ *     consentRequired:    number|null,                  // require consent below; enables below-threshold classification
  *     hasParentalConsent: function(req): boolean,
  *     skipPaths:          string[],
  *     errorMessage:       string,

package/lib/vendor/blamejs/lib/middleware/ai-act-disclosure.js

@@ -60,7 +60,7 @@ var audit     = lazyRequire(function () { return require("../audit"); });
  *
  * @opts
  *   {
- *     kind:         "ai-interaction"|"deepfake"|"emotion-recognition"|"biometric-categorisation"|"synthetic-content",
+ *     kind:         "ai-interaction"|"ai-generated-content"|"emotion-recognition"|"biometric-categorisation"|"deep-fake"|"ai-text-public-interest",
  *     deployerName: string,
  *     policyUri:    string,
  *     mode:         "header"|"html",   // default "header"

package/lib/vendor/blamejs/lib/middleware/api-encrypt.js

@@ -250,11 +250,11 @@ function _writeRejection(res, code, body) {
  *
  * @opts
  *   {
- *     keypair:             { publicKey, secretKey, ecPublicKey, ecSecretKey },
+ *     keypair:             { publicKey, privateKey, ecPublicKey, ecPrivateKey },
  *     keypairs:            [...]            // multi-key rotation set; first = active
  *     replayWindowMs:      number,
  *     pruneIntervalMs:     number,
- *     nonceStore:          { has, add, prune },
+ *     nonceStore:          { checkAndInsert, purgeExpired, close },
  *     exemptPaths:         string[],
  *     contentTypes:        string[],         // default ["application/json"]
  *     audit:               boolean,
@@ -270,7 +270,7 @@ function _writeRejection(res, code, body) {
  * @example
  *   var b = require("@blamejs/core");
  *   var app = b.router.create();
- *   var kp = b.crypto.keypair();
+ *   var kp = b.crypto.generateEncryptionKeyPair();
  *   app.use(b.middleware.apiEncrypt({
  *     keypair:        kp,
  *     replayWindowMs: 30000,

package/lib/vendor/blamejs/lib/middleware/compose-pipeline.js

@@ -104,7 +104,7 @@ var CANONICAL_POSITIONS = Object.freeze({
 /**
  * @primitive b.middleware.composePipeline
  * @signature b.middleware.composePipeline(entries, opts?)
- * @since     0.9.44
+ * @since     0.9.43
  * @status    stable
  * @related   b.middleware.requestId, b.middleware.requireAuth, b.middleware.idempotencyKey
  *

package/lib/vendor/blamejs/lib/middleware/csp-nonce.js

@@ -8,7 +8,7 @@
  * browser refuses to execute them. This middleware closes the gap:
  *
  *   1. Generate a fresh random nonce per request (base64, default
- *      16 bytes / 22 chars).
+ *      16 bytes / 24 chars).
  *   2. Attach it to `req.cspNonce` (handler-readable) AND
  *      `res.locals.cspNonce` (template-data-readable — render.js
  *      auto-merges res.locals into template data).
@@ -233,7 +233,7 @@ function _injectNonce(cspHeader, nonce, directives, strictDynamic) {
  * Per-request CSP nonce + render integration. Constructed via
  * `b.middleware.cspNonce(opts)`; the resulting middleware has the
  * `(req, res, next)` shape shown above. Generates a fresh
- * random nonce (16 bytes / 22 chars base64 by default), attaches it
+ * random nonce (16 bytes / 24 chars base64 by default), attaches it
  * to `req.cspNonce` and `res.locals.cspNonce` (auto-merged into
  * template data), and patches the existing Content-Security-Policy
  * header to append `'nonce-XYZ'` to the configured directives

package/lib/vendor/blamejs/lib/middleware/flag-context.js

@@ -34,7 +34,7 @@ var contextMod = lazyRequire(function () { return require("../flag-evaluation-co
  * @primitive b.middleware.flagContext
  * @signature b.middleware.flagContext(opts)
  * @since     0.1.0
- * @related   b.flagClient.getBoolean
+ * @related   b.flag.create
  *
  * Extracts an OpenFeature evaluation context onto `req.flagCtx` so
  * downstream handlers and multiple flag clients read a consistent

package/lib/vendor/blamejs/lib/middleware/rate-limit.js

@@ -36,7 +36,7 @@
  *     header:          true                    // set X-RateLimit-* response headers
  *     skipPaths:       []                      // string-prefix or regex matchers
  *     scope:           'global' | 'per-route'  (default 'global')
- *     backend:         'memory' (default) | 'cluster' | { take, reset, gc? }
+ *     backend:         'memory' (default) | 'cluster' | { take, reset }
  *     algorithm:       'token-bucket' (default) | 'fixed-window'
  *                                              // memory backend only; ignored
  *                                              // for cluster backend (which is
@@ -366,7 +366,7 @@ function _resolveBackend(opts) {
  *     header:          boolean,          // default true
  *     skipPaths:       Array<string|RegExp>,
  *     scope:           "global"|"per-route",
- *     backend:         "memory"|"cluster"|{ take, reset, gc },
+ *     backend:         "memory"|"cluster"|{ take, reset },
  *     algorithm:       "token-bucket"|"fixed-window",
  *     burst:           number,
  *     refillPerSecond: number,

package/lib/vendor/blamejs/lib/middleware/require-auth.js

@@ -30,7 +30,8 @@
  *                                   when set, prefersJson()=false rejections
  *                                   produce 302 instead of 401 text/plain)
  *     prefersJson:   function     (optional override; defaults to checking
- *                                   Accept / X-Requested-With / Content-Type)
+ *                                   Accept / X-Requested-With — NOT
+ *                                   Content-Type, see the note above)
  *     errorMessage:  'Authentication required.'
  *     audit:         true         (emit auth.required.denied on reject)
  *   }

package/lib/vendor/blamejs/lib/queue-redis.js

@@ -582,6 +582,15 @@ function create(opts) {
   async function fail(jobId, errorMessage, retryDelayMs) {
     await _ensureConnected();
     var nowMs = Date.now();
+    // b.queue.consume passes the object form `{ retryDelayMs }` (matching
+    // the queue-local backend); accept it as well as a bare-number third
+    // arg. Without this the object failed the `typeof === "number"` test
+    // below and the delay was forced to 0, so the documented exponential
+    // backoff was silently discarded and a failing job re-leased
+    // immediately on the redis backend (retry storm).
+    if (retryDelayMs && typeof retryDelayMs === "object") {
+      retryDelayMs = retryDelayMs.retryDelayMs;
+    }
     if (typeof retryDelayMs !== "number" || !isFinite(retryDelayMs) || retryDelayMs < 0) {
       retryDelayMs = 0;
     }

package/lib/vendor/blamejs/lib/queue.js

@@ -17,6 +17,18 @@
  *   and `nats` are listed as deferred and surface a clear error if
  *   selected.
  *
+ *   `local` and `redis` are driven by the generic `b.queue.consume`
+ *   loop and the lifecycle below (framework-side leasing, deterministic
+ *   backoff, DLQ, and the sweep timer). `sqs` is an SQS-native adapter
+ *   with a different model: `complete` / `fail` delete or re-deliver by
+ *   the message's `receiptHandle` (returned by `lease()`, threaded back
+ *   by the caller), and DLQ + visibility-expiry are handled server-side
+ *   by the SQS queue's RedrivePolicy — so `sqs` is driven directly
+ *   (lease → handle → complete/fail), not by `b.queue.consume`, and it
+ *   does not use the framework DLQ / sweep described below. See
+ *   `lib/queue-sqs.js` for its action map and the features that require
+ *   operator wiring.
+ *
  *   Job lifecycle:
  *     enqueued (status='pending', availableAt set by delaySeconds)
  *       ↓ availableAt reached + consumer leases
@@ -271,7 +283,11 @@ function enqueue(queueName, payload, opts) {
  * through `handler(job, ctx)`. Handler resolution marks the job
  * `done`; rejection bumps the attempt counter and either re-pends
  * with deterministic exponential backoff (1s base, 5min cap, no
- * jitter) or routes to the DLQ when `attempts >= maxAttempts`.
+ * jitter) or routes to the DLQ when `attempts >= maxAttempts`. This
+ * loop drives the `local` and `redis` backends; the `sqs` backend uses
+ * SQS-native receipt-handle complete/fail and server-side redrive and
+ * is driven directly rather than by this consumer (see the module
+ * intro).
  *
  * Returns a consumer state handle whose `.cancel()` aborts the poll
  * loop immediately (without waiting for the next `pollIntervalMs`

package/lib/vendor/blamejs/lib/retry.js

@@ -187,6 +187,10 @@ function _validateBreakerOpts(name, opts) {
     throw new TypeError("retry.CircuitBreaker: successThreshold must be a positive integer, got " +
       typeof opts.successThreshold + " " + JSON.stringify(opts.successThreshold));
   }
+  if (opts.onStateChange != null && typeof opts.onStateChange !== "function") {
+    throw new TypeError("retry.CircuitBreaker: onStateChange must be a function, got " +
+      typeof opts.onStateChange);
+  }
 }
 
 // ---- Public surface ----
@@ -381,6 +385,19 @@ class CircuitBreaker {
     this.consecutiveFailures = 0;
     this.consecutiveSuccesses = 0;
     this.openedAt = 0;
+    this._stateListeners = [];
+    if (typeof merged.onStateChange === "function") this._stateListeners.push(merged.onStateChange);
+  }
+
+  // Register a state-change listener. Called with { name, from, to, at }
+  // on every transition (same payload the constructor's onStateChange
+  // opt receives). Returns this for chaining.
+  onStateChange(handler) {
+    if (typeof handler !== "function") {
+      throw new TypeError("retry.CircuitBreaker.onStateChange: handler must be a function, got " + typeof handler);
+    }
+    this._stateListeners.push(handler);
+    return this;
   }
 
   // Wrap an async function. The breaker observes outcomes and may fail-fast.
@@ -415,7 +432,16 @@ class CircuitBreaker {
   _transition(from, to) {
     if (from === to) return;
     this.state = to;
+    var at = Date.now();
     _emitEvent("breaker.state.change", 1, { name: this.name, from: from, to: to });
+    if (this._stateListeners.length > 0) {
+      var payload = { name: this.name, from: from, to: to, at: at };
+      for (var i = 0; i < this._stateListeners.length; i++) {
+        // Best-effort: a throwing listener must not derail the breaker's
+        // own state machine (the transition has already been applied).
+        try { this._stateListeners[i](payload); } catch (_e) { /* drop-silent */ }
+      }
+    }
   }
 
   _onSuccess() {

package/lib/vendor/blamejs/lib/router.js

@@ -1229,7 +1229,10 @@ function serveStatic(dir) {
     var rel = req.pathname;
     if (rel.includes("\0")) return next();
     var filePath = nodePath.resolve(nodePath.join(root, rel));
-    if (!filePath.startsWith(root)) return next();
+    // Anchor on `root + sep` (not a bare prefix) so a sibling directory
+    // that shares the root's name as a prefix — e.g. root `/srv/public`
+    // vs `/srv/public-evil` — cannot satisfy the containment check.
+    if (filePath !== root && !filePath.startsWith(root + nodePath.sep)) return next();
     if (!nodeFs.existsSync(filePath) || nodeFs.statSync(filePath).isDirectory()) return next();
 
     var ext = nodePath.extname(filePath).toLowerCase();

package/lib/vendor/blamejs/lib/safe-decompress.js

@@ -37,8 +37,9 @@
  *     - Any algorithm not in the allowlist (including operator-typo'd).
  *
  *   Refusal posture:
- *     - `safe-decompress/output-too-large`     — bomb-by-absolute-size
- *       (zlib's own `maxOutputLength` already refuses before alloc)
+ *     - `safe-decompress/decompress-failed`    — bomb-by-absolute-size
+ *       (zlib's own `maxOutputLength` refuses before alloc; the throw is
+ *       caught and surfaced under this code)
  *     - `safe-decompress/ratio-exceeded`       — expansion > `maxRatio`
  *       (zlib accepted the bytes; our post-decompress ratio check
  *       refuses, freeing the bytes immediately)

package/lib/vendor/blamejs/lib/safe-icap.js

@@ -37,8 +37,9 @@
  *       `\r\n`; intermediaries that accept bare-LF then desync against
  *       this parser).
  *     - **Status-code allowlist** — only `100` / `200` / `204` / `400`
- *       / `403` / 5xx are honored. RFC 3507 §4.3.3 enumerates these as
- *       the legal ICAP response codes; an unexpected `1xx` continuation
+ *       / `403` / `404` / `405` / `408` / 5xx are honored. RFC 3507
+ *       §4.3.3 enumerates these as the legal ICAP response codes; an
+ *       unexpected `1xx` continuation
  *       or `3xx` redirect is refused because it's a classic header-
  *       injection class (attacker smuggles `ICAP/1.0 100 X-Inject:`
  *       through a permissive proxy).

package/lib/vendor/blamejs/lib/safe-mime.js

@@ -125,7 +125,7 @@ var DEFAULT_TRANSFER_ENCODINGS = Object.freeze([
  *   maxBodyBytes:             number,     // default 25 MiB
  *   maxMessageBytes:          number,     // default 50 MiB
  *   charsetAllowlist:         string[],   // default UTF-8 / US-ASCII / common legacy 8-bit
- *   transferEncodingAllowlist: string[],  // default 7bit/8bit/binary/qp/base64
+ *   transferEncodingAllowlist: string[],  // default 7bit/8bit/quoted-printable/base64 (binary is opt-in, RFC 3030 BINARYMIME)
  *
  * @example
  *   var msg = b.safeMime.parse(messageBuffer);

package/lib/vendor/blamejs/lib/safe-smtp.js

@@ -61,7 +61,7 @@ var SafeSmtpError = defineClass("SafeSmtpError", { alwaysPermanent: true });
  * @example
  *   var body = Buffer.from("Hello world.\r\n.\r\n");
  *   b.safeSmtp.findDotTerminator(body);
- *   // → 13  (index of \r in \r\n.\r\n)
+ *   // → 12  (index of \r in the terminating \r\n.\r\n)
  *
  *   b.safeSmtp.findDotTerminator(Buffer.from("incomplete body"));
  *   // → -1

package/lib/vendor/blamejs/lib/sec-cyber.js

@@ -32,7 +32,7 @@
  *
  * Public API:
  *
- *   b.secCyber.eightKArtifact(opts) -> { artifact, deadline, audit }
+ *   b.secCyber.eightKArtifact(opts) -> { artifact, deadline, deadlineBusinessDays }
  *     opts:
  *       incidentId:        operator-supplied incident reference (string).
  *       registrant:        { name, cik, filer }

package/lib/vendor/blamejs/lib/storage.js

@@ -833,10 +833,10 @@ function _requireInit() {
 //
 // Resumable-chunked-upload primitive. Operators handling large file
 // uploads (multipart form / tus / S3-multipart-style flow) need to
-// persist incoming chunks during the upload window, then assemble
-// them into a final file when the upload completes. Without a
-// framework primitive every consumer ended up reinventing the
-// per-assembly directory layout + atomic finalize + GC of partial
+// persist incoming chunks during the upload window, then concatenate
+// them in order when the upload completes. Without a framework
+// primitive every consumer ended up reinventing the per-assembly
+// directory layout + ordered gap-checked assembly + GC of partial
 // assemblies that never completed.
 //
 // chunkScratch owns:
@@ -844,8 +844,8 @@ function _requireInit() {
 //     storage backend just like saveFile)
 //   - chunk persistence + retrieval with the framework envelope
 //   - assembly metadata tracking createdAt/totalChunks/chunkHashes
-//   - atomic concat into the final file (no consumer ever sees a
-//     half-assembled file)
+//   - ordered, gap-checked concat returning the assembled bytes for
+//     the caller to persist (the primitive does not write a final file)
 //   - GC of stale partial assemblies (operator opts in via gc())
 //
 // Backend is the same `b.storage` backend the operator already
@@ -919,10 +919,11 @@ function _validateChunkIndex(idx) {
  * @related   b.storage.saveFile, b.storage.getFileBuffer
  *
  * Resumable-chunked-upload primitive. Persists incoming upload chunks
- * during the upload window + atomically assembles them into the
- * final file on completion. Owns per-assembly directory layout,
- * envelope-encrypted chunk persistence, atomic finalize, and GC of
- * partial assemblies.
+ * during the upload window, then concatenates them in order on
+ * completion and returns the assembled bytes for the caller to persist
+ * (the primitive does not itself write a final file). Owns per-assembly
+ * directory layout, envelope-encrypted chunk persistence, ordered
+ * gap-checked assembly, and GC of partial assemblies.
  *
  * Composes existing primitives: each chunk routes through
  * `b.storage.saveFile` (same XChaCha20-Poly1305 envelope as the
@@ -974,13 +975,16 @@ function _validateChunkIndex(idx) {
  *   b.storage.init({ backend: "local", uploadDir: "./data/uploads" });
  *   var cs = b.storage.chunkScratch({ rootKeyPrefix: "uploads/scratch" });
  *
- *   // During upload — each PUT lands one chunk
- *   await cs.saveChunk({ assemblyId: "upload-abc", chunkIndex: 0, data: chunk0 });
- *   await cs.saveChunk({ assemblyId: "upload-abc", chunkIndex: 1, data: chunk1 });
- *   await cs.saveChunk({ assemblyId: "upload-abc", chunkIndex: 2, data: chunk2 });
+ *   // During upload — each PUT lands one chunk. saveChunk returns the
+ *   // chunk's sealed encryptionKey; collect them in order for assemble.
+ *   var keys = [];
+ *   keys[0] = (await cs.saveChunk({ assemblyId: "upload-abc", chunkIndex: 0, data: chunk0 })).encryptionKey;
+ *   keys[1] = (await cs.saveChunk({ assemblyId: "upload-abc", chunkIndex: 1, data: chunk1 })).encryptionKey;
+ *   keys[2] = (await cs.saveChunk({ assemblyId: "upload-abc", chunkIndex: 2, data: chunk2 })).encryptionKey;
  *
- *   // On completion — atomic assemble + cleanup
- *   var assembled = await cs.assemble({ assemblyId: "upload-abc", expectedTotal: 3 });
+ *   // On completion — concat the chunks (in order) into the assembled
+ *   // buffer, then clean up. chunkEncryptionKeys is one key per chunk.
+ *   var assembled = await cs.assemble({ assemblyId: "upload-abc", expectedTotal: 3, chunkEncryptionKeys: keys });
  *   await cs.removeAssembly("upload-abc");
  *
  *   // Periodic GC of partial uploads abandoned mid-stream

package/lib/vendor/blamejs/lib/tsa.js

@@ -183,7 +183,8 @@ function buildRequest(data, opts) {
     nonce = Buffer.isBuffer(opts.nonce) ? opts.nonce : nodeCrypto.randomBytes(8);  // allow:raw-byte-literal — RFC 3161 nonce: 64-bit random
     children.push(asn1.writeInteger(nonce));
   }
-  // certReq DEFAULT FALSE — only encode when true (the default we want).
+  // certReq DEFAULTS TRUE (RFC 3161 §2.4.1) — encode the boolean unless
+  // the caller explicitly opts out with certReq:false.
   var certReq = opts.certReq !== false;
   if (certReq) children.push(asn1.writeBoolean(true));
 

package/lib/vendor/blamejs/lib/vault/index.js

@@ -625,6 +625,7 @@ module.exports = {
   getKeysJson:           getKeysJson,
   getCurrentPassphrase:  getCurrentPassphrase,
   getMode:               getMode,
+  isInitialized:         function () { return initialized; },
   VaultError:            VaultError,
   sealPemFile:           sealPemFileModule.sealPemFile,
   SealPemFileError:      sealPemFileModule.SealPemFileError,

package/lib/vendor/blamejs/lib/vault-aad.js

@@ -35,8 +35,8 @@
  *   .isAadSealed(value) → boolean
  *
  * Per the framework's security-first stance:
- *   - Symmetric key derivation uses HKDF-SHAKE256 (matching the
- *     vault's KDF) over the vault root key concatenated with the
+ *   - Symmetric key derivation uses SHAKE256 (matching the vault's
+ *     KDF) over the vault root key concatenated with the
  *     canonicalized AAD.
  *   - AEAD: XChaCha20-Poly1305 with the AAD threaded into the tag.
  *   - 24-byte nonce, generated fresh per-seal via

package/lib/vendor/blamejs/package.json

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

package/lib/vendor/blamejs/release-notes/v0.13.23.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.13.23",
+  "date": "2026-05-28",
+  "headline": "Documentation corrected to match actual behavior across several primitives",
+  "summary": "A set of JSDoc / doc-comment corrections where the documented contract had drifted from what the code does. No behavior changes — the implementations already behaved as now documented; only the docs were wrong. The most operator-relevant is the JWT signer doc: an expiring token signed without an explicit jti receives an auto-minted 128-bit jti (so the replay-defense path has the jti it needs), which the sign-opts doc previously denied. Also corrected: did.resolve's unsupported-method error now names did:jwk (always supported); b.cose.verify is marked stable to match its stable sign sibling and the CWT / EAT / SCITT / mdoc verifiers built on it; b.linkHeader.serialize's doc now states every parameter value is double-quoted; b.auth.saml verifyResponse's documented return shape now lists inResponseTo and issuer (both always returned); and the rate-limit custom-backend contract drops a gc member the middleware never invoked.",
+  "sections": [
+    {
+      "heading": "Fixed",
+      "items": [
+        {
+          "title": "JWT signer doc now describes the auto-minted jti on expiring tokens",
+          "body": "`b.auth.jwt.sign`'s opts doc claimed that omitting `jti` adds no jti. In fact, when a token carries an `exp` and no operator-supplied `jti`, the signer auto-mints a random 128-bit `jti` so a replay-protected token always carries the identifier `verify`'s replay store requires. The doc now describes this; pass an explicit `jti` for a deterministic value. Behavior is unchanged."
+        },
+        {
+          "title": "`b.did.resolve` unsupported-method error now names did:jwk",
+          "body": "The thrown error for an unsupported DID method listed only `did:key` and `did:web`, omitting `did:jwk`, which `resolve` fully supports. The message now reads `(did:key, did:jwk, and did:web only)`."
+        },
+        {
+          "title": "`b.cose.verify` marked stable",
+          "body": "`b.cose.verify` carried `@status experimental` while its `b.cose.sign` sibling is stable and the CWT / EAT / SCITT / mdoc verifiers that depend on it are stable and shipped. The verifier is the same maturity as the rest of the COSE_Sign1 round-trip; its status now reflects that."
+        },
+        {
+          "title": "`b.linkHeader.serialize` doc matches its quoting behavior",
+          "body": "The doc said parameters are token-encoded when they fit RFC 7230 token grammar and double-quoted otherwise. The serializer always double-quotes every value (valid under RFC 8288, and required for space-separated multi-rel and media-type values). The doc now states that."
+        },
+        {
+          "title": "`b.auth.saml` verifyResponse documented return shape lists all fields",
+          "body": "The prose and the example each omitted a different field that `verifyResponse` always returns. The documented shape now lists all of `nameId`, `nameIdFormat`, `sessionIndex`, `attributes`, `audience`, `inResponseTo`, and `issuer`."
+        },
+        {
+          "title": "rate-limit custom-backend contract is `{ take, reset }`",
+          "body": "The custom-backend opts doc listed a `gc` member that the middleware never reads or invokes (the runtime contract is `take` / `reset` / `close`, and the error message already said `{ take, reset }`). The documented shape now matches; an operator-supplied `gc` was always silently ignored."
+        },
+        {
+          "title": "`b.mail.agent.create` doc no longer lists consumer as a method",
+          "body": "The created agent's method list named `consumer`, which is not a method on the returned object — the queue consumer is the sibling export `b.mail.agent.consumer`. The doc now says so."
+        }
+      ]
+    }
+  ]
+}

package/lib/vendor/blamejs/release-notes/v0.13.24.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.13.24",
+  "date": "2026-05-28",
+  "headline": "`b.guard*` docs corrected: the compliance-posture opt key, the gate API, and validate return shapes",
+  "summary": "Documentation corrections across the b.guard* family. The most consequential: the posture-selection option was documented as `compliance:` in many guards' @opts, but the working key is `compliancePosture:` — passing the documented `{ compliance: \"hipaa\" }` was silently ignored, so a compliance posture (e.g. HIPAA PII redaction) never activated. If you select a posture via the gate/validate/sanitize options, use `compliancePosture:`; `compliance:` had no effect. The guard docs now name the correct key uniformly. Also corrected: gate examples and prose that invoked the gate as a callable or via `.run` / `.inspect` (the gate is an object whose method is `.check(ctx)`), and validate() return shapes that listed `severities` / `summary` / `refusal` fields the function never returned (it returns `{ ok, issues }`).",
+  "sections": [
+    {
+      "heading": "Fixed",
+      "items": [
+        {
+          "title": "guard posture option is `compliancePosture:`, not `compliance:`",
+          "body": "Many `b.guard*` primitives documented the compliance-posture selector as `compliance: \"hipaa\"|\"pci-dss\"|\"gdpr\"|\"soc2\"` in their `@opts`, but the family resolver reads `compliancePosture:`. Passing `{ compliance: \"hipaa\" }` was accepted and silently ignored — the posture overlay (e.g. CSV `piiPolicy: \"redact\"` under HIPAA) never applied, leaving the default policy in force. The docs across the guard family now name `compliancePosture:` consistently (the key the resolver and `b.guardX.compliancePosture(name)` already used). Action: if you selected a posture with `compliance:`, switch to `compliancePosture:` — the posture was not taking effect before."
+        },
+        {
+          "title": "guard gate is an object with `.check(ctx)`, not a callable",
+          "body": "Several guards' gate `@example`s and prose invoked the gate as a function (`g({...})`), via `.run(...)`, or via `.inspect(...)`, and a few described it as \"an async function\". `b.guardX.gate(opts)` returns an object whose async method is `.check(ctx)`; the examples and prose now use `.check`, so they run as written."
+        },
+        {
+          "title": "guard validate() returns `{ ok, issues }`",
+          "body": "Several guards documented `validate()` as returning `{ ok, issues, severities }`, `{ ok, issues, summary }`, or `{ ok, issues, refusal? }`. The function returns `{ ok, issues }` (each issue carries its own `severity` / `kind`); the documented extra top-level fields were never present. The docs now state the actual shape."
+        }
+      ]
+    }
+  ]
+}

package/lib/vendor/blamejs/release-notes/v0.13.25.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.13.25",
+  "date": "2026-05-28",
+  "headline": "Agent idempotency results and orchestrator/tenant registry rows are sealed at rest",
+  "summary": "The b.agent.idempotency, b.agent.orchestrator, and b.agent.tenant primitives documented their stored rows as sealed at rest, but the values were written as plaintext JSON — a database dump could expose cached result payloads (which can carry mail-move / search data), the tenant ids that own each agent, and operator-supplied endpoint metadata. Those values are now sealed via b.cryptoField (XChaCha20-Poly1305 through the vault) before they reach the backing store and unsealed on read, when a vault is configured — which is the default in a booted app. Each ciphertext is AAD-bound to its row identity so a database-write attacker cannot copy a sealed value between rows. Reads of rows written before this release (plain JSON) continue to work unchanged, and a vault-less deployment stores rows as before. No API or call-site changes are required.",
+  "sections": [
+    {
+      "heading": "Security",
+      "items": [
+        {
+          "title": "Agent idempotency / orchestrator / tenant rows sealed at rest",
+          "body": "`b.agent.idempotency` cached result blobs, `b.agent.orchestrator` registry rows (owning tenant id + endpoint metadata), and `b.agent.tenant` registry-row metadata are now sealed via `b.cryptoField` when a vault is configured (the default in a booted app via `b.start`). The fields were previously stored as plaintext despite the docs describing them as sealed, so a DB dump exposed cached payloads, agent↔tenant ownership, and endpoint detail. Each sealed value is AAD-bound to the row identity (the idempotency key hash / the agent name / the tenant id), so a sealed value cannot be copied between rows. Rows written before this release remain readable (a non-sealed value passes through unseal), and a vault-less deployment behaves as before. No call-site changes."
+        }
+      ]
+    },
+    {
+      "heading": "Fixed",
+      "items": [
+        {
+          "title": "`b.agent.saga` run() return/throw shape documented correctly",
+          "body": "The doc said `run()` resolves to `{ status: \"failed\", failedStep, lastCompensationError }` on failure and to a bare final state. In fact it resolves to `{ status: \"completed\", sagaId, state }` on success and rejects (throws) on step failure with an error carrying `failedStep`, `cause`, `compensationCause`, and `failedCompStepName`. The docs now describe the actual contract."
+        },
+        {
+          "title": "`b.agent.idempotency` put() example uses the real option name",
+          "body": "The example passed `{ argsFingerprint: ... }`, which the function does not read; the fingerprint option is `requestFingerprint` (or `args`). The example now uses `requestFingerprint`."
+        },
+        {
+          "title": "`b.agent.tenant.derivedKey` @since corrected to 0.9.26",
+          "body": "It was tagged `@since 0.9.25`, a version before the tenant module existed; it ships in 0.9.26 alongside `b.agent.tenant.create`."
+        },
+        {
+          "title": "`b.agent.trace.injectIntoEnvelope` documented as single-argument",
+          "body": "The doc listed a second `currentSpan` argument the function ignores — it always injects the currently-active span's trace context. The doc now shows `injectIntoEnvelope(envelope)` and notes it should be called while the intended span is active."
+        }
+      ]
+    }
+  ]
+}

package/lib/vendor/blamejs/release-notes/v0.13.26.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.13.26",
+  "date": "2026-05-28",
+  "headline": "`b.cryptoField.unsealRow` nulls a sealed column on unseal failure instead of returning the forged ciphertext",
+  "summary": "When a sealed column failed to unseal — a DB-write attacker's forged `vault:<…>` payload, or a valid ciphertext copied into a different row so the AAD no longer matches — unsealRow recorded the failure on the audit chain but then kept the original attacker-crafted string in the field rather than nulling it, despite the documented contract that downstream sees 'no value'. A write-back guard discarded the intended null on the failure path. The column is now nulled on any unseal failure, so a forged or cross-row-copied value never reaches downstream code as if it were a real plaintext. Valid values round-trip unchanged and genuinely-unsealed pass-through values are still kept. This hardens every sealed-column reader, including the agent idempotency / orchestrator / tenant rows sealed in 0.13.25.",
+  "sections": [
+    {
+      "heading": "Security",
+      "items": [
+        {
+          "title": "Sealed columns are nulled on unseal failure (forged / cross-row ciphertext)",
+          "body": "`b.cryptoField.unsealRow` now nulls a sealed field when its value fails to unseal — a crafted `vault:`/`vault.aad:` payload written by a DB-write attacker, or a valid ciphertext copied to a different row (AAD mismatch). Previously the field kept the attacker-controlled string, so downstream code could read the forged ciphertext as if it were the plaintext. The audit emit (`system.crypto.unseal_failed`) is unchanged. Valid round-trips and not-actually-sealed pass-through values are unaffected. A regression test pins the forged-value, cross-row-copy, and pass-through cases."
+        }
+      ]
+    },
+    {
+      "heading": "Fixed",
+      "items": [
+        {
+          "title": "Audit checkpoint docs name the actual signature algorithm",
+          "body": "`b.audit.checkpoint` / `b.audit.verifyCheckpoints` described the anchor signature as ML-DSA-87, but the checkpoint is signed with the configured `b.auditSign` algorithm — SLH-DSA-SHAKE-256f by default (ML-DSA-87 / ML-DSA-65 are opt-in). The docs and the verify-failure reason now refer to the post-quantum signature without naming a specific algorithm the operator may not be using."
+        },
+        {
+          "title": "`b.storage.chunkScratch` example and assembly description corrected",
+          "body": "The `assemble()` example omitted the mandatory `chunkEncryptionKeys` argument (one sealed key per chunk, returned by `saveChunk`), so it would have thrown as written; it now collects and passes the keys. The prose no longer claims the primitive writes a final file with an 'atomic finalize' — `assemble()` concatenates the chunks in order and returns the assembled bytes for the caller to persist."
+        }
+      ]
+    }
+  ]
+}

package/lib/vendor/blamejs/release-notes/v0.13.27.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.13.27",
+  "date": "2026-05-28",
+  "headline": "Documentation corrected across api-encrypt, mail-crypto, mail-store, and calendar",
+  "summary": "A set of JSDoc corrections where the documented contract had drifted from the code. The most actionable: b.middleware.apiEncrypt's @opts named the keypair fields secretKey / ecSecretKey, but the middleware requires privateKey / ecPrivateKey (the shape b.crypto.generateEncryptionKeyPair returns), so a keypair built from the docs threw INVALID_KEYPAIR at construction; the same block documented a wrong custom-nonceStore interface and an example calling a non-existent b.crypto.keypair(). Also corrected: the b.mail.crypto facade and the PGP module described S/MIME sign/verify and PGP encrypt/decrypt/WKD as deferred when they ship and are live; b.mail.crypto.smime.checkCert documented a return shape whose field names did not match what it returns; and b.mailStore.create listed a destroy method it does not expose. No code behavior changed — only the docs were wrong.",
+  "sections": [
+    {
+      "heading": "Fixed",
+      "items": [
+        {
+          "title": "`b.middleware.apiEncrypt` options documented with the correct field names",
+          "body": "The `@opts` listed the keypair as `{ publicKey, secretKey, ecPublicKey, ecSecretKey }`, but the middleware requires `{ publicKey, privateKey, ecPublicKey, ecPrivateKey }` — the shape `b.crypto.generateEncryptionKeyPair()` returns — and threw `INVALID_KEYPAIR` for the documented shape. The custom `nonceStore` interface was documented as `{ has, add, prune }` but the middleware calls `{ checkAndInsert, purgeExpired, close }`, and the example called a non-existent `b.crypto.keypair()`. All three now match the implementation (`b.crypto.generateEncryptionKeyPair()`)."
+        },
+        {
+          "title": "`b.mail.crypto` S/MIME and PGP availability described accurately",
+          "body": "The `b.mail.crypto` facade said S/MIME `sign()` / `verify()` were deferred, and the PGP module's intro said in-process encrypt / decrypt and WKD discovery would 'ship in v0.10.14'. All of these are implemented and live (PGP encrypt/decrypt/WKD were promoted to the stable surface in v0.11.32; S/MIME sign/verify/verifyAll run on the `b.cms` substrate). The docs now describe them as available; the genuinely-deferred PGP v6-signature-packet support remains noted as deferred."
+        },
+        {
+          "title": "`b.mail.crypto.smime.checkCert` return shape documented correctly",
+          "body": "The doc and example described the result as `{ subjectCN, issuerCN, validFrom, validTo, keyAlg, keyBits, sigAlg }`; the function returns `{ subject, issuer, validFrom, validTo, sigAlgName, sigAlgOid, keyType, fingerprint256 }` (full DN strings, no key-size field). The documented shape now matches."
+        },
+        {
+          "title": "`b.mailStore.create` method list matches the returned handle",
+          "body": "The doc listed a `destroy` method the handle does not expose and omitted `search` / `moveMessages` / `hardExpunge` that it does. The list now reflects the actual methods."
+        },
+        {
+          "title": "Smaller doc corrections",
+          "body": "`b.calendar` fromIcal / toIcal / validate now document that they also handle Task (VTODO), Note (VJOURNAL), and Group, not just Event. `b.middleware.requireAuth`'s `prefersJson` default is documented as Accept / X-Requested-With only (Content-Type is intentionally not a signal, as the module already noted). The default CSP nonce is 24 base64 chars (16 bytes), not 22. `b.mail.bimi`'s returned `evidenceDocument` is noted as echoed from the operator-supplied option rather than pulled from the certificate."
+        }
+      ]
+    }
+  ]
+}