@blamejs/blamejs-shop 0.1.29 → 0.1.31

package/lib/vendor/MANIFEST.json

@@ -3,8 +3,8 @@
   "_about": "blamejs.shop vendors a single framework — blamejs — which itself bundles every server-side crypto/identity dependency. The transitive packages blamejs ships are surfaced in its own MANIFEST.json at lib/vendor/blamejs/lib/vendor/MANIFEST.json — Trivy / Grype rely on that nested data for CVE attribution.",
   "packages": {
     "blamejs": {
-      "version": "0.12.63",
-      "tag": "v0.12.63",
+      "version": "0.12.69",
+      "tag": "v0.12.69",
       "license": "Apache-2.0",
       "author": "blamejs contributors",
       "source": "https://github.com/blamejs/blamejs",

package/lib/vendor/blamejs/CHANGELOG.md

@@ -8,6 +8,16 @@ upgrading across more than a few patches at a time.
 
 ## v0.12.x
 
+- v0.12.69 (2026-05-26) — **`b.middleware.botGuard` no longer blocks browsers that omit Sec-Fetch-Mode.** b.middleware.botGuard treated a missing Sec-Fetch-Mode header as a bot signal and returned 403 Forbidden, which refused legitimate browsers on any origin where the browser does not emit Fetch Metadata: every plain-HTTP non-localhost origin (Umbrel apps, LAN and *.local reverse-proxy deployments) and Safari before 16.4 even over HTTPS. Browsers only send Sec-Fetch-* in a secure context, so its absence is normal there — not a bot. Sec-Fetch-Mode is now advisory only: it never blocks, and it sets req.suspectedBot in mode:"tag" only on a secure-context HTML GET where a modern browser would have sent it. Drive-by bots are still blocked by the missing-Accept-Language and User-Agent heuristics. No configuration change is needed; if you had widened skipPaths or disabled bot-guard to work around this, you can revert that. **Fixed:** *`b.middleware.botGuard` no longer 403s browsers over plain HTTP or older Safari* — A missing `Sec-Fetch-Mode` was a blocking heuristic, but browsers omit Fetch Metadata outside a secure context (every plain-HTTP non-localhost origin — Umbrel, LAN, `*.local` proxies) and Safari < 16.4 omits it even over HTTPS. Those legitimate browsers were refused with `403 Forbidden`. `Sec-Fetch-Mode` is now advisory: it never blocks, and only sets `req.suspectedBot` in `mode: "tag"` on a secure-context HTML GET. The `Accept-Language` and User-Agent heuristics (which catch the same bots) are unchanged. **Detectors:** *reserved-hostname trailing-dot detector recognizes regex strips* — The codebase-patterns gate that requires stripping the RFC 1034 trailing root-zone dot before a reserved-hostname comparison now also recognizes end-anchored regex strips (`.replace(/\.$/, …)`), not only the `charAt` / `while`-loop forms.
+
+- v0.12.68 (2026-05-26) — **`b.jwk` — RFC 7638 JWK thumbprint.** Compute the RFC 7638 thumbprint of a JSON Web Key — the canonical base64url(SHA-256(canonical-JSON)) identifier used to name a key (DPoP jkt bindings, ACME account-key thumbprints, DBSC session pins, kid derivation). b.jwk.thumbprint(jwk) returns the digest; b.jwk.canonicalize(jwk) returns the exact JSON that is hashed — only the key-type's required members, member names in lexicographic order, no whitespace, so the same key always yields the same thumbprint regardless of how its JWK was serialized. The standard key types are supported (EC, RSA, oct, OKP per RFC 8037) plus AKP, the IANA key type Node uses for ML-DSA / SLH-DSA post-quantum public keys; SHA-256 is the default, with hash: "sha384" | "sha512" for RFC 9278 thumbprint-with-hash. Verified against the RFC 7638 §3.1 worked example. b.auth.dpop, b.acme, and b.dbsc now compute their thumbprints through this primitive. **Added:** *`b.jwk.thumbprint` / `b.jwk.canonicalize`* — RFC 7638 JWK thumbprint. `thumbprint(jwk, opts)` returns `base64url(hash(canonical-JSON))` — only the key-type's required members feed the hash, so optional fields (`kid`, `use`, `alg`, …) never change the result. `canonicalize(jwk)` returns the canonical JSON string itself. Supports EC / RSA / oct / OKP and the AKP post-quantum key type; SHA-256 default, `hash` selects SHA-384 / SHA-512. Throws `JwkError` on an invalid key or unknown hash. **Changed:** *DPoP, ACME, and DBSC compose `b.jwk`* — `b.auth.dpop` (the `jkt` proof-key thumbprint), `b.acme` (the RFC 8555 account-key authorization), and `b.dbsc` (the session-pin thumbprint) now compute RFC 7638 thumbprints through `b.jwk` instead of carrying their own implementations. Behavior is unchanged — DPoP still refuses symmetric key types, and each surface keeps its own error codes.
+
+- v0.12.66 (2026-05-26) — **`b.uriTemplate` — RFC 6570 URI Template expansion.** Expand RFC 6570 URI Templates — the {var} syntax that OpenAPI links, HAL _links, and hypermedia API clients use to turn a template plus a set of variables into a concrete URI. The full Level 4 grammar is supported: every operator ({+var} reserved, {#var} fragment, {.var} label, {/var} path, {;var} path-style parameters, {?var} query, {&var} query continuation), the {var:3} prefix modifier, and the {var*} explode modifier for lists and associative arrays. b.uriTemplate.expand(template, vars) returns the expanded string; b.uriTemplate.compile(template) parses once for templates applied to many variable sets. A malformed template (unclosed expression, reserved operator, non-numeric prefix, unmatched brace) throws UriTemplateError. Verified against the official uritemplate-test conformance suite (all 135 spec, extended, and negative cases). **Added:** *`b.uriTemplate.expand` / `b.uriTemplate.compile`* — RFC 6570 URI Template expansion, full Level 4. `expand(template, vars)` substitutes variables into a template and returns the URI; `compile(template)` returns a reusable `{ expand }` for repeated use. Variable values may be strings, numbers, booleans, arrays (lists), or plain objects (associative arrays); undefined, null, and empty list/map variables are omitted. All eight operators, the `:N` prefix modifier, and the `*` explode modifier follow §3.2, including reserved-set encoding for `{+var}` / `{#var}`. Composes naturally with `b.hal`, `b.linkHeader`, and `b.openapi` link objects. A malformed template throws `UriTemplateError`.
+
+- v0.12.65 (2026-05-26) — **`b.base32` — RFC 4648 Base32 encode / decode.** Encode and decode RFC 4648 Base32 — the case-insensitive alphabet behind TOTP / 2FA secrets, DNSSEC NSEC3 hashes, and human-transcribable identifiers. Both RFC 4648 variants are supported: the standard alphabet (the default) and the extended-hex alphabet. b.base32.encode pads to an 8-character boundary by default (pass padding: false for the bare form TOTP key URIs use); b.base32.decode is strict by default but accepts the real-world shapes humans produce — lower-case, embedded spaces and dashes, missing padding — under loose: true. Verified against the RFC 4648 §10 test vectors for both alphabets. The TOTP primitive now composes this codec instead of carrying its own Base32 implementation. **Added:** *`b.base32.encode` / `b.base32.decode`* — RFC 4648 Base32 codec. `encode(buf, opts)` takes a Buffer or Uint8Array and returns a Base32 string, padded to an 8-character boundary unless `padding: false`; `decode(str, opts)` returns a Buffer. The `variant` option selects the standard (`"rfc4648"`, default) or extended-hex (`"rfc4648-hex"`) alphabet. Decoding is strict by default — any character outside the alphabet throws `Base32Error` — and `loose: true` up-cases the input and ignores embedded spaces, dashes, and missing padding, which is how copied TOTP keys and hand-typed codes arrive. **Changed:** *TOTP composes `b.base32`* — `b.auth.totp` now encodes and decodes its secrets through `b.base32` rather than a private Base32 implementation. Behavior is unchanged — secrets are still emitted unpadded and parsed leniently (case-insensitive, ignoring spaces and dashes).
+
+- v0.12.64 (2026-05-25) — **`b.jsonSchema` — JSON Schema 2020-12 validation.** Validate JSON against a JSON Schema 2020-12 document — the dialect OpenAPI 3.1 adopted and the most widely implemented schema language. b.jsonSchema.compile(schema) returns a reusable validator; b.jsonSchema.validate(schema, instance) compiles and runs in one call, returning { valid, errors } where each error names the failing instance location, keyword, and schema path. The full 2020-12 vocabulary is supported: every applicator (allOf / anyOf / oneOf / not / if-then-else, properties / patternProperties / additionalProperties / prefixItems / items / contains), the annotation-aware unevaluatedProperties / unevaluatedItems, every assertion keyword, and reference resolution ($ref / $anchor / $dynamicRef / $dynamicAnchor / $defs / $id base URIs). format is an annotation by default (opt in to assertion with assertFormat). External references resolve through an operator-supplied schema map — never a network fetch. Verified against the official JSON-Schema-Test-Suite (1292 of 1295 draft2020-12 cases; the remainder need the bundled dialect metaschema or $vocabulary selection, both opt-in). This is the standards-track counterpart to the fluent b.safeSchema builder and the portable b.jtd. **Added:** *`b.jsonSchema` — JSON Schema 2020-12* — `compile(schema, opts)` returns `{ validate, isValid }`; `validate(schema, instance, opts)` and `isValid(schema, instance, opts)` compile and run in one call. `validate` returns `{ valid, errors }`, each error a `{ instancePath, keyword, schemaPath, message }`. The full 2020-12 vocabulary is implemented — applicators, annotation-aware `unevaluatedProperties` / `unevaluatedItems`, every assertion keyword, and `$ref` / `$anchor` / `$dynamicRef` / `$dynamicAnchor` / `$defs` / `$id` resolution. `format` is an annotation by default (`assertFormat: true` to assert). External references resolve through `opts.schemas` (a URI→schema map), never a network fetch. Reach for it when the schema is an existing JSON Schema document (an API contract, OpenAPI component, or config schema); `b.safeSchema` remains the fluent in-process builder and `b.jtd` the portable codegen-friendly option. Validating a schema document against the dialect metaschema requires supplying that metaschema via `opts.schemas`, and `$vocabulary`-based keyword selection is not honored (every standard keyword always asserts).
+
 - v0.12.63 (2026-05-25) — **`b.cloudEvents` gains the JSON event format, batch, and the HTTP binding.** b.cloudEvents grows beyond wrap / parse into a full CloudEvents 1.0.2 surface. b.cloudEvents.validate / isValid check an envelope against the spec without throwing (the non-throwing companion to parse). toJSON / fromJSON serialize and parse the JSON event format, and toJSONBatch / fromJSONBatch handle the JSON batch format; untrusted bodies parse through the framework's bounded, prototype-pollution-safe JSON reader. The new http.* binding speaks both content modes the spec defines — binary mode spreads context attributes across percent-encoded ce-* headers with the data in the body, structured mode carries the whole event as application/cloudevents+json — plus the batch mode, and http.decode auto-detects the incoming mode from Content-Type exactly as a conformant receiver does. Verified against the spec's normative example events. **Added:** *`b.cloudEvents` JSON event format, batch, and HTTP binding* — `validate` / `isValid` report spec violations without throwing (the non-throwing companion to `parse`). `toJSON` / `fromJSON` and `toJSONBatch` / `fromJSONBatch` serialize and parse the JSON event and batch formats over the existing envelope shape. `http.encodeBinary` / `http.encodeStructured` / `http.encodeBatch` render the three HTTP content modes — binary spreads attributes across percent-encoded `ce-*` headers, structured and batched carry the event(s) as `application/cloudevents+json` / `application/cloudevents-batch+json` — and `http.decode` parses a request back into an envelope (or array) by auto-detecting the mode from `Content-Type`. `b.jtd` or `b.safeSchema` still validate the event's `data` payload. **Fixed:** *`b.csp.build` accepts `fenced-frame-src` and `webrtc`* — The CSP3 `fenced-frame-src` directive — which the default security-headers policy emits to block `<fencedframe>` embeds — was missing from the builder's recognized-directive set, so the default policy could not round-trip through `b.csp.build` (it threw `csp/unknown-directive`). Both `fenced-frame-src` and the CSP3 `webrtc` directive are now recognized.
 
 - 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.

package/lib/vendor/blamejs/README.md

@@ -71,6 +71,7 @@ The framework bundles the surface a typical Node app reaches for. Every primitiv
 
 - **Passwords** — Argon2id + policy primitive (`b.auth.password`); NIST 800-63B / PCI-DSS 4.0 / HIPAA-AAL2 profiles; HaveIBeenPwned k-anonymity breach check; length / context / dictionary / complexity rules; rotation + history
 - **Multi-factor + WebAuthn** — passkeys (WebAuthn), TOTP, JWT (PQ-default)
+- **JWK thumbprint** — RFC 7638 `base64url(SHA-256(canonical-JSON))` key identifier (`b.jwk.thumbprint` / `canonicalize`): EC / RSA / oct / OKP + the AKP post-quantum key type, SHA-256/384/512; the canonical key name behind DPoP `jkt`, ACME account keys, and DBSC session pins
 - **OAuth / OIDC RP** — `b.auth.oauth`
   - RP-Initiated / Front-Channel / Back-Channel Logout 1.0 (`parseFrontchannelLogoutRequest` + `verifyBackchannelLogoutToken` with jti-replay defense)
   - RFC 9207 AS Issuer Identifier validation on callbacks (`parseCallback` — refuses iss mismatch + OP `error=` redirect)
@@ -99,7 +100,10 @@ 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)
+- **URI Templates** — RFC 6570 expansion (`b.uriTemplate.expand` / `compile`): full Level 4 — every operator, the `:N` prefix and `*` explode modifiers — turning `{/path}{?q*}` plus variables into a concrete URI; validated against the official uritemplate-test suite. The `{var}` syntax behind OpenAPI links and HAL `_links`
 - **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
+- **JSON Schema 2020-12** — the OpenAPI 3.1 dialect (`b.jsonSchema.compile` / `validate` / `isValid`): full vocabulary including every applicator, annotation-aware `unevaluatedProperties` / `unevaluatedItems`, and `$ref` / `$dynamicRef` / `$anchor` / `$id` resolution (external refs via an operator-supplied schema map, never a network fetch); `format` is an annotation unless `assertFormat` is set; returns located `{ valid, errors }`. Validated against the official JSON-Schema-Test-Suite. Standards-track counterpart to `b.safeSchema` and `b.jtd`
+- **Base32** — RFC 4648 codec (`b.base32.encode` / `decode`): standard + extended-hex alphabets, padded or bare, strict or lenient decode (case-insensitive, ignoring spaces / dashes for copied TOTP keys); validated against the RFC 4648 §10 vectors. The codec behind `b.auth.totp` secrets
 - **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/lib/vendor/blamejs/api-snapshot.json

@@ -1,7 +1,7 @@
 {
   "version": 1,
-  "frameworkVersion": "0.12.63",
-  "createdAt": "2026-05-26T04:30:08.809Z",
+  "frameworkVersion": "0.12.69",
+  "createdAt": "2026-05-26T14:58:13.295Z",
   "exports": {
     "a2a": {
       "type": "object",
@@ -4781,6 +4781,36 @@
         }
       }
     },
+    "base32": {
+      "type": "object",
+      "members": {
+        "ALPHABETS": {
+          "type": "object",
+          "members": {
+            "rfc4648": {
+              "type": "primitive",
+              "valueType": "string"
+            },
+            "rfc4648-hex": {
+              "type": "primitive",
+              "valueType": "string"
+            }
+          }
+        },
+        "Base32Error": {
+          "type": "function",
+          "arity": 4
+        },
+        "decode": {
+          "type": "function",
+          "arity": 2
+        },
+        "encode": {
+          "type": "function",
+          "arity": 2
+        }
+      }
+    },
     "bootGates": {
       "type": "object",
       "members": {
@@ -37108,6 +37138,31 @@
         }
       }
     },
+    "jsonSchema": {
+      "type": "object",
+      "members": {
+        "DIALECT": {
+          "type": "primitive",
+          "valueType": "string"
+        },
+        "JsonSchemaError": {
+          "type": "function",
+          "arity": 4
+        },
+        "compile": {
+          "type": "function",
+          "arity": 2
+        },
+        "isValid": {
+          "type": "function",
+          "arity": 3
+        },
+        "validate": {
+          "type": "function",
+          "arity": 3
+        }
+      }
+    },
     "jtd": {
       "type": "object",
       "members": {
@@ -37125,6 +37180,48 @@
         }
       }
     },
+    "jwk": {
+      "type": "object",
+      "members": {
+        "JwkError": {
+          "type": "function",
+          "arity": 4
+        },
+        "REQUIRED": {
+          "type": "object",
+          "members": {
+            "AKP": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "EC": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "OKP": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "RSA": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "oct": {
+              "type": "instance",
+              "ctorName": "Array"
+            }
+          }
+        },
+        "canonicalize": {
+          "type": "function",
+          "arity": 1
+        },
+        "thumbprint": {
+          "type": "function",
+          "arity": 2
+        }
+      }
+    },
     "keychain": {
       "type": "object",
       "members": {
@@ -49338,6 +49435,23 @@
         }
       }
     },
+    "uriTemplate": {
+      "type": "object",
+      "members": {
+        "UriTemplateError": {
+          "type": "function",
+          "arity": 4
+        },
+        "compile": {
+          "type": "function",
+          "arity": 1
+        },
+        "expand": {
+          "type": "function",
+          "arity": 2
+        }
+      }
+    },
     "uuid": {
       "type": "object",
       "members": {

package/lib/vendor/blamejs/index.js

@@ -403,6 +403,10 @@ 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 jsonSchema = require("./lib/json-schema");
+var base32 = require("./lib/base32");
+var uriTemplate = require("./lib/uri-template");
+var jwk = require("./lib/jwk");
 var standardWebhooks = require("./lib/standard-webhooks");
 var lro = require("./lib/lro");
 var jsonApi = require("./lib/jsonapi");
@@ -427,6 +431,10 @@ module.exports = {
   jsonMergePatch:   jsonMergePatch,
   jsonPath:         jsonPath,
   jtd:              jtd,
+  jsonSchema:       jsonSchema,
+  base32:           base32,
+  uriTemplate:      uriTemplate,
+  jwk:              jwk,
   standardWebhooks: standardWebhooks,
   lro:              lro,
   jsonApi:          jsonApi,

package/lib/vendor/blamejs/lib/acme.js

@@ -45,6 +45,7 @@ var nodeCrypto = require("node:crypto");
 
 var C = require("./constants");
 var asn1 = require("./asn1-der");
+var jwk = require("./jwk");
 var safeUrl = require("./safe-url");
 var safeJson = require("./safe-json");
 var validateOpts = require("./validate-opts");
@@ -114,8 +115,7 @@ function _publicJwkFromKeyObject(keyObject) {
 
 function _jwkThumbprint(publicJwk) {
   // RFC 7638 §3 — base64url(SHA-256(canonical JSON of required members)).
-  var canon = JSON.stringify({ crv: publicJwk.crv, kty: publicJwk.kty, x: publicJwk.x, y: publicJwk.y });
-  return _b64u(nodeCrypto.createHash("sha256").update(canon).digest());
+  return jwk.thumbprint(publicJwk);
 }
 
 function _signJws(privateKey, protectedHeader, payload) {

package/lib/vendor/blamejs/lib/auth/dpop.js

@@ -28,6 +28,7 @@
 
 var nodeCrypto = require("node:crypto");
 var bCrypto = require("../crypto");
+var jwk = require("../jwk");
 var safeJson = require("../safe-json");
 var safeUrl = require("../safe-url");
 var validateOpts = require("../validate-opts");
@@ -84,52 +85,21 @@ function _b64urlDecode(s) {
   }
 }
 
-// Canonical JWK per RFC 7638 — keys present in lexicographic order,
-// only the kty-defined "required" members. Used for thumbprint.
-function _canonicalJwk(jwk) {
-  if (!jwk || typeof jwk !== "object") {
-    throw new AuthError("auth-dpop/bad-jwk", "jwk must be an object");
-  }
-  if (typeof jwk.kty !== "string" || jwk.kty.length === 0) {
-    throw new AuthError("auth-dpop/bad-jwk", "jwk.kty is required");
-  }
-  if (jwk.kty === "EC") {
-    if (typeof jwk.crv !== "string" || typeof jwk.x !== "string" || typeof jwk.y !== "string") {
-      throw new AuthError("auth-dpop/bad-jwk", "EC jwk requires crv, x, y");
-    }
-    return JSON.stringify({ crv: jwk.crv, kty: "EC", x: jwk.x, y: jwk.y });
+// Asymmetric key types DPoP accepts (its proof model relies on a
+// signature, so symmetric "oct" keys are refused). AKP is the IANA key
+// type for ML-DSA / SLH-DSA PQC public keys.
+var DPOP_KTY = { EC: 1, OKP: 1, RSA: 1, AKP: 1 };
+
+function thumbprint(key) {
+  if (!key || typeof key !== "object" || typeof key.kty !== "string" || key.kty.length === 0) {
+    throw new AuthError("auth-dpop/bad-jwk", "jwk must be an object with a kty");
   }
-  if (jwk.kty === "OKP") {
-    if (typeof jwk.crv !== "string" || typeof jwk.x !== "string") {
-      throw new AuthError("auth-dpop/bad-jwk", "OKP jwk requires crv, x");
-    }
-    return JSON.stringify({ crv: jwk.crv, kty: "OKP", x: jwk.x });
+  if (!DPOP_KTY[key.kty]) {
+    throw new AuthError("auth-dpop/refused-kty", "jwk.kty='" + key.kty + "' is not allowed (DPoP requires asymmetric kty)");
   }
-  if (jwk.kty === "RSA") {
-    if (typeof jwk.e !== "string" || typeof jwk.n !== "string") {
-      throw new AuthError("auth-dpop/bad-jwk", "RSA jwk requires e, n");
-    }
-    return JSON.stringify({ e: jwk.e, kty: "RSA", n: jwk.n });
-  }
-  if (jwk.kty === "AKP") {
-    // PQC asymmetric key package (draft-ietf-cose-cnsa-pqc / IANA AKP
-    // registry). Node:crypto exports ML-DSA / SLH-DSA public keys with
-    // kty=AKP, alg=<algId>, pub=<base64url public bytes>.
-    if (typeof jwk.alg !== "string" || typeof jwk.pub !== "string") {
-      throw new AuthError("auth-dpop/bad-jwk", "AKP jwk requires alg, pub");
-    }
-    return JSON.stringify({ alg: jwk.alg, kty: "AKP", pub: jwk.pub });
-  }
-  // Symmetric keys (oct) and any other kty are refused outright — DPoP's
-  // proof model requires asymmetric.
-  throw new AuthError("auth-dpop/refused-kty",
-    "jwk.kty='" + jwk.kty + "' is not allowed (DPoP requires asymmetric kty)");
-}
-
-function thumbprint(jwk) {
-  var canonical = _canonicalJwk(jwk);
-  var hash = nodeCrypto.createHash("sha256").update(canonical, "utf8").digest();
-  return _b64urlEncode(hash);
+  // The RFC 7638 thumbprint itself is computed by b.jwk.
+  try { return jwk.thumbprint(key); }
+  catch (e) { throw new AuthError("auth-dpop/bad-jwk", (e && e.message) || "invalid jwk"); }
 }
 
 function _sha256B64Url(input) {

package/lib/vendor/blamejs/lib/base32.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * @module b.base32
+ * @nav    Data
+ * @title  Base32
+ *
+ * @intro
+ *   Encode and decode <a href="https://www.rfc-editor.org/rfc/rfc4648">RFC
+ *   4648</a> Base32 — the case-insensitive, digit-light alphabet used for
+ *   TOTP / 2FA secrets, DNSSEC NSEC3 hashes, and human-transcribable
+ *   identifiers. Both RFC 4648 variants are supported: the standard
+ *   alphabet (<code>variant: "rfc4648"</code>, default) and the
+ *   extended-hex alphabet (<code>variant: "rfc4648-hex"</code>, which sorts
+ *   in the same order as the underlying bytes).
+ *
+ *   <code>encode</code> pads to an 8-character boundary with
+ *   <code>=</code> by default (pass <code>padding: false</code> for the
+ *   bare form TOTP key URIs use). <code>decode</code> is strict by default
+ *   — it rejects any character outside the alphabet — but
+ *   <code>loose: true</code> accepts the real-world shapes humans produce:
+ *   lower-case input, embedded spaces and dashes, and missing padding.
+ *
+ * @card
+ *   RFC 4648 Base32 encode / decode (standard + extended-hex alphabets,
+ *   padded or bare, strict or lenient) — the codec behind TOTP secrets and
+ *   transcribable identifiers.
+ */
+
+var { defineClass } = require("./framework-error");
+
+var Base32Error = defineClass("Base32Error", { alwaysPermanent: true });
+
+var ALPHABETS = {
+  "rfc4648": "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  "rfc4648-hex": "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+};
+// Reverse lookups per variant: char-code → 5-bit value.
+var LOOKUPS = {};
+Object.keys(ALPHABETS).forEach(function (v) {
+  var map = {};
+  for (var i = 0; i < ALPHABETS[v].length; i++) map[ALPHABETS[v].charAt(i)] = i;
+  LOOKUPS[v] = map;
+});
+
+var GROUP = 8;                                              // allow:raw-byte-literal — Base32 emits 8 chars per 5 input bytes (RFC 4648 §6)
+var BITS = 5;                                               // 5 bits per Base32 symbol
+
+function _alphabet(variant) {
+  var a = ALPHABETS[variant || "rfc4648"];
+  if (!a) throw new Base32Error("base32/bad-variant", "base32: variant must be 'rfc4648' or 'rfc4648-hex'");
+  return a;
+}
+
+/**
+ * @primitive  b.base32.encode
+ * @signature  b.base32.encode(input, opts?)
+ * @since      0.12.65
+ * @status     stable
+ * @related    b.base32.decode
+ *
+ * Encode a Buffer (or Uint8Array) to an RFC 4648 Base32 string. Output is
+ * padded to an 8-character boundary with <code>=</code> unless
+ * <code>padding: false</code>. The empty input encodes to the empty string.
+ *
+ * @opts
+ *   variant:   "rfc4648" | "rfc4648-hex",   // default: "rfc4648"
+ *   padding:   boolean,                      // default: true
+ *
+ * @example
+ *   b.base32.encode(Buffer.from("foobar"));
+ *   // → "MFRGGZDFMZTWQ===="
+ */
+function encode(input, opts) {
+  opts = opts || {};
+  var buf;
+  if (Buffer.isBuffer(input)) buf = input;
+  else if (input instanceof Uint8Array) buf = Buffer.from(input);
+  else throw new Base32Error("base32/bad-input", "base32.encode: input must be a Buffer or Uint8Array");
+  var alphabet = _alphabet(opts.variant);
+  var pad = opts.padding !== false;
+
+  var out = "";
+  var value = 0, bits = 0;
+  for (var i = 0; i < buf.length; i++) {
+    value = (value << 8) | buf[i];                          // allow:raw-byte-literal — shift in one input byte
+    bits += 8;                                              // allow:raw-byte-literal — eight bits per input byte
+    while (bits >= BITS) {
+      out += alphabet.charAt((value >>> (bits - BITS)) & 31);   // allow:raw-byte-literal — low 5 bits mask (2^5 - 1)
+      bits -= BITS;
+    }
+  }
+  if (bits > 0) out += alphabet.charAt((value << (BITS - bits)) & 31);   // allow:raw-byte-literal — final partial group, low 5 bits
+  if (pad) while (out.length % GROUP !== 0) out += "=";
+  return out;
+}
+
+/**
+ * @primitive  b.base32.decode
+ * @signature  b.base32.decode(str, opts?)
+ * @since      0.12.65
+ * @status     stable
+ * @related    b.base32.encode
+ *
+ * Decode an RFC 4648 Base32 string to a Buffer. Strict by default: any
+ * character outside the variant's alphabet (other than trailing
+ * <code>=</code> padding) throws <code>Base32Error</code>. With
+ * <code>loose: true</code> the decoder up-cases the input and ignores
+ * embedded spaces and dashes (and missing padding) — the shapes TOTP keys
+ * and hand-typed codes take.
+ *
+ * @opts
+ *   variant:   "rfc4648" | "rfc4648-hex",   // default: "rfc4648"
+ *   loose:     boolean,                      // default: false
+ *
+ * @example
+ *   b.base32.decode("MFRGGZDFMZTWQ====").toString();
+ *   // → "foobar"
+ */
+function decode(str, opts) {
+  opts = opts || {};
+  if (typeof str !== "string") throw new Base32Error("base32/bad-input", "base32.decode: input must be a string");
+  _alphabet(opts.variant);
+  var lookup = LOOKUPS[opts.variant || "rfc4648"];
+  var loose = opts.loose === true;
+
+  var bytes = [];
+  var value = 0, bits = 0;
+  var inPad = false;   // once "=" padding starts, only more "=" may follow
+  for (var i = 0; i < str.length; i++) {
+    var ch = str.charAt(i);
+    if (ch === "=") { inPad = true; continue; }             // trailing padding
+    if (loose && (ch === " " || ch === "-")) continue;      // ignore separators
+    // A data character after padding is malformed in either mode — the "="
+    // run must be trailing (rejects "M=Y======" / "MZXW=6YTB").
+    if (inPad) throw new Base32Error("base32/bad-char", "base32.decode: data character '" + ch + "' after padding at index " + i);
+    if (loose) ch = ch.toUpperCase();
+    var idx = lookup[ch];
+    if (idx === undefined) throw new Base32Error("base32/bad-char", "base32.decode: invalid Base32 character '" + str.charAt(i) + "' at index " + i);
+    value = (value << BITS) | idx;
+    bits += BITS;
+    if (bits >= 8) {                                        // allow:raw-byte-literal — emit a full output byte
+      bytes.push((value >>> (bits - 8)) & 0xff);            // allow:raw-byte-literal — eight-bit output byte mask
+      bits -= 8;                                            // allow:raw-byte-literal — consumed eight bits
+    }
+  }
+  return Buffer.from(bytes);
+}
+
+module.exports = {
+  encode:      encode,
+  decode:      decode,
+  ALPHABETS:   ALPHABETS,
+  Base32Error: Base32Error,
+};

package/lib/vendor/blamejs/lib/dbsc.js

@@ -36,7 +36,7 @@ var nodeCrypto    = require("node:crypto");
 var validateOpts  = require("./validate-opts");
 var safeJson      = require("./safe-json");
 var bCrypto       = require("./crypto");
-var canonicalJson = require("./canonical-json");
+var jwk           = require("./jwk");
 var jwtExternal   = require("./auth/jwt-external");
 var C             = require("./constants");
 var { defineClass } = require("./framework-error");
@@ -272,23 +272,10 @@ function _trimLeadingZeros(buf) {
   return buf.slice(i);
 }
 
-function _jwkThumbprint(jwk) {
-  // RFC 7638 canonical thumbprint: alphabetic key-name ordering + no
-  // whitespace + SHA-256 + base64url. For EC P-256 the required keys
-  // are { crv, kty, x, y }.
-  var members;
-  if (jwk.kty === "EC") {
-    members = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y };
-  } else if (jwk.kty === "RSA") {
-    members = { e: jwk.e, kty: jwk.kty, n: jwk.n };
-  } else {
-    throw new DbscError("dbsc/bad-jwk-kty",
-      "jwkThumbprint: unsupported kty " + jwk.kty);
-  }
-  var canonical = canonicalJson.stringify(members);
-  return bCrypto.toBase64Url(
-    nodeCrypto.createHash("sha256").update(Buffer.from(canonical, "utf8")).digest()
-  );
+function _jwkThumbprint(key) {
+  // RFC 7638 thumbprint (base64url(SHA-256(canonical JWK))) via b.jwk.
+  try { return jwk.thumbprint(key); }
+  catch (e) { throw new DbscError("dbsc/bad-jwk-kty", "jwkThumbprint: " + ((e && e.message) || "invalid jwk")); }
 }
 
 module.exports = {