@blamejs/core 0.15.12 → 0.15.14

package/lib/auth/oauth.js

@@ -215,11 +215,8 @@ var DEFAULT_CLOCK_SKEW_MS      = C.TIME.minutes(1);
 // OAuth 2.0 Threat Model §4.4.1.8 / §4.4.1.13.
 var PKCE_VERIFIER_BYTES        = C.BYTES.bytes(32);
 var STATE_NONCE_BYTES          = C.BYTES.bytes(16);
-// JOSE PSS salt lengths (RFC 7518 §3.5) match the hash-output size:
-// PS256/SHA-256 → 32, PS384/SHA-384 → 48, PS512/SHA-512 → 64.
-var PSS_SALT_BYTES_SHA256      = C.BYTES.bytes(32);
-var PSS_SALT_BYTES_SHA384      = C.BYTES.bytes(48);
-var PSS_SALT_BYTES_SHA512      = C.BYTES.bytes(64);
+// JOSE PSS salt lengths (RFC 7518 §3.5) now live with the shared alg table
+// in jwtExternal.algParams; _verifyParamsForAlg here is a thin wrapper.
 
 // RFC 8628 §3.4 — device_code length cap. The spec doesn't fix a max
 // length but 8 KiB comfortably accommodates any legitimate base64url
@@ -253,11 +250,12 @@ var RFC_8693_TOKEN_TYPES = Object.freeze([
 
 function _b64urlEncode(buf) { return bCrypto.toBase64Url(buf); }
 
-function _b64urlDecode(s) {
-  if (typeof s !== "string") throw new OAuthError("auth-oauth/bad-base64", "expected base64url string");
-  try { return bCrypto.fromBase64Url(s); }
-  catch (_e) { throw new OAuthError("auth-oauth/bad-base64", "segment is not valid base64url"); }
-}
+var _b64urlDecode = bCrypto.makeBase64UrlDecoder({
+  errorClass:  OAuthError,
+  code:        "auth-oauth/bad-base64",
+  typeMessage: "expected base64url string",
+  badMessage:  "segment is not valid base64url",
+});
 
 function _generateRandomToken(bytes) {
   return _b64urlEncode(generateBytes(bytes));
@@ -329,29 +327,27 @@ function _validateUrl(url, allowHttp, label) {
 // ---- JOSE alg → node:crypto verify parameters ----
 
 function _verifyParamsForAlg(alg) {
-  // Returns { hash, padding, dsaEncoding } for node:crypto.verify.
-  if (alg === "RS256") return { hash: "sha256", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
-  if (alg === "RS384") return { hash: "sha384", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
-  if (alg === "RS512") return { hash: "sha512", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
-  if (alg === "PS256") return { hash: "sha256", padding: nodeCrypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: PSS_SALT_BYTES_SHA256 };
-  if (alg === "PS384") return { hash: "sha384", padding: nodeCrypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: PSS_SALT_BYTES_SHA384 };
-  if (alg === "PS512") return { hash: "sha512", padding: nodeCrypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: PSS_SALT_BYTES_SHA512 };
-  if (alg === "ES256") return { hash: "sha256", dsaEncoding: "ieee-p1363" };
-  if (alg === "ES384") return { hash: "sha384", dsaEncoding: "ieee-p1363" };
-  if (alg === "ES512") return { hash: "sha512", dsaEncoding: "ieee-p1363" };
-  throw new OAuthError("auth-oauth/unsupported-alg",
-    "alg '" + alg + "' is not supported for ID-token verification");
+  // Returns { hash, padding, dsaEncoding } for node:crypto.verify, from the
+  // shared classical-JOSE table (jwtExternal.algParams). ID-token verification
+  // deliberately does NOT accept EdDSA — most OIDC OPs sign with RS256/ES256
+  // and the framework keeps the ID-token verify surface to the RSA/ECDSA set.
+  var params = jwtExternal.algParams(alg);
+  if (!params || alg === "EdDSA") {
+    throw new OAuthError("auth-oauth/unsupported-alg",
+      "alg '" + alg + "' is not supported for ID-token verification");
+  }
+  return params;
 }
 
 // ---- JWKS → KeyObject ----
 
 function _jwkToKey(jwk) {
   // node's createPublicKey accepts JWK directly since Node 16.
-  try { return nodeCrypto.createPublicKey({ key: jwk, format: "jwk" }); }
-  catch (e) {
-    throw new OAuthError("auth-oauth/bad-jwk",
-      "could not import JWK (kid=" + (jwk && jwk.kid) + "): " + ((e && e.message) || String(e)));
-  }
+  return bCrypto.importPublicJwk(jwk, {
+    errorClass:    OAuthError,
+    code:          "auth-oauth/bad-jwk",
+    messagePrefix: "could not import JWK (kid=" + (jwk && jwk.kid) + "): ",
+  });
 }
 
 // ---- RFC 9396 Rich Authorization Requests (RAR) ----
@@ -657,6 +653,16 @@ function _publicCnfJwk(jwk, label) {
     label + ": instanceKeyJwk.kty='" + jwk.kty + "' is not an asymmetric public JWK");
 }
 
+// Config-time check for an OPTIONAL epoch-seconds override (iat / nbf): if
+// present it must be a finite number, so a typo is caught at build time
+// rather than silently ignored by the `typeof === "number"` body guard.
+function _optionalFiniteNumber(value, label, code) {
+  if (value === undefined || value === null) return;
+  if (typeof value !== "number" || !isFinite(value)) {
+    throw new OAuthError(code, label + " must be a finite number (epoch seconds)");
+  }
+}
+
 /**
  * @primitive b.auth.oauth.buildClientAttestation
  * @signature b.auth.oauth.buildClientAttestation(opts)
@@ -700,14 +706,23 @@ function _publicCnfJwk(jwk, label) {
  */
 function buildClientAttestation(aopts) {
   aopts = aopts || {};
-  validateOpts(aopts, [
-    "clientId", "attesterPrivateKey", "instanceKeyJwk", "algorithm",
-    "expiresInSec", "nbf", "iat", "extraClaims",
-  ], "auth.oauth.buildClientAttestation");
-  validateOpts.requireNonEmptyString(aopts.clientId,
-    "buildClientAttestation: clientId", OAuthError, "auth-oauth/attestation-no-client-id");
-  validateOpts.optionalPositiveInt(aopts.expiresInSec,
-    "buildClientAttestation: expiresInSec", OAuthError, "auth-oauth/attestation-bad-expiry");
+  validateOpts.shape(aopts, {
+    clientId:     { rule: "required-string",       code: "auth-oauth/attestation-no-client-id" },
+    // KeyObject | PEM string | JWK object — typed downstream by
+    // _toAttestationPrivateKey; the shape only enforces presence.
+    attesterPrivateKey: function (v, l) {
+      if (v === undefined || v === null) {
+        throw new OAuthError("auth-oauth/attestation-no-attester-key",
+          l + " (Attester signing key) is required");
+      }
+    },
+    instanceKeyJwk: { rule: "required-object",   code: "auth-oauth/attestation-bad-cnf" },
+    algorithm:      { rule: "optional-string",   code: "auth-oauth/attestation-bad-alg" },
+    nbf:            function (v, l) { _optionalFiniteNumber(v, l, "auth-oauth/attestation-bad-nbf"); },
+    iat:            function (v, l) { _optionalFiniteNumber(v, l, "auth-oauth/attestation-bad-iat"); },
+    extraClaims:    { rule: "optional-plain-object", code: "auth-oauth/attestation-bad-extra-claims" },
+    expiresInSec: { rule: "optional-positive-int", code: "auth-oauth/attestation-bad-expiry" },
+  }, "buildClientAttestation", OAuthError, "auth-oauth/attestation-no-client-id");
   var key = _toAttestationPrivateKey(aopts.attesterPrivateKey, "buildClientAttestation");
   var alg = _resolveAttestationAlg(aopts.algorithm, key, "buildClientAttestation");
   var cnfJwk = _publicCnfJwk(aopts.instanceKeyJwk, "buildClientAttestation");
@@ -769,16 +784,23 @@ function buildClientAttestation(aopts) {
  */
 function buildClientAttestationPop(popts) {
   popts = popts || {};
-  validateOpts(popts, [
-    "instancePrivateKey", "audience", "algorithm", "challenge",
-    "jti", "iat", "expiresInSec",
-  ], "auth.oauth.buildClientAttestationPop");
-  validateOpts.requireNonEmptyString(popts.audience,
-    "buildClientAttestationPop: audience (AS issuer)", OAuthError, "auth-oauth/attestation-pop-no-aud");
-  validateOpts.optionalNonEmptyString(popts.challenge,
-    "buildClientAttestationPop: challenge", OAuthError, "auth-oauth/attestation-pop-bad-challenge");
-  validateOpts.optionalPositiveInt(popts.expiresInSec,
-    "buildClientAttestationPop: expiresInSec", OAuthError, "auth-oauth/attestation-pop-bad-expiry");
+  validateOpts.shape(popts, {
+    audience:     { rule: "required-string",       code: "auth-oauth/attestation-pop-no-aud",
+                    label: "buildClientAttestationPop: audience (AS issuer)" },
+    // KeyObject | PEM string | JWK object — typed downstream by
+    // _toAttestationPrivateKey; the shape only enforces presence.
+    instancePrivateKey: function (v, l) {
+      if (v === undefined || v === null) {
+        throw new OAuthError("auth-oauth/attestation-pop-no-instance-key",
+          l + " (instance signing key matching cnf.jwk) is required");
+      }
+    },
+    algorithm:    { rule: "optional-string",       code: "auth-oauth/attestation-pop-bad-alg" },
+    jti:          { rule: "optional-string",       code: "auth-oauth/attestation-pop-bad-jti" },
+    iat:          function (v, l) { _optionalFiniteNumber(v, l, "auth-oauth/attestation-pop-bad-iat"); },
+    challenge:    { rule: "optional-string",       code: "auth-oauth/attestation-pop-bad-challenge" },
+    expiresInSec: { rule: "optional-positive-int", code: "auth-oauth/attestation-pop-bad-expiry" },
+  }, "buildClientAttestationPop", OAuthError, "auth-oauth/attestation-pop-no-aud");
   var key = _toAttestationPrivateKey(popts.instancePrivateKey, "buildClientAttestationPop");
   var alg = _resolveAttestationAlg(popts.algorithm, key, "buildClientAttestationPop");
   var iatSec = typeof popts.iat === "number" ? popts.iat : Math.floor(Date.now() / C.TIME.seconds(1));

package/lib/auth/oid4vci.js

@@ -54,7 +54,7 @@ var lazyRequire  = require("../lazy-require");
 var validateOpts = require("../validate-opts");
 var safeJson     = require("../safe-json");
 var nodeCrypto   = require("node:crypto");
-var { generateToken, sha3Hash, timingSafeEqual } = require("../crypto");
+var { generateToken, sha3Hash, timingSafeEqual, importPublicJwk } = require("../crypto");
 // Shared JOSE defenses (CVE-2026-22817 alg/kty cross-check). Top-of-
 // file per project convention §3; no circular load — jwt-external
 // requires nothing from oid4vci.
@@ -297,11 +297,11 @@ async function _verifyProofJwt(proofJwt, expectedAud, expectedCNonce, expectedCl
     // A resolver that returns an RSA key for a proof declaring an HMAC
     // alg would otherwise be verified as an HMAC secret.
     jwtExternal._assertAlgKtyMatch(header.alg, holderKeyJwk);
-    try { keyObj = nodeCrypto.createPublicKey({ key: holderKeyJwk, format: "jwk" }); }
-    catch (e) {
-      throw new AuthError("auth-oid4vci/bad-resolved-key",
-        "credential issuance: resolveKid-returned key is not importable as a public key: " + ((e && e.message) || String(e)));
-    }
+    keyObj = importPublicJwk(holderKeyJwk, {
+      errorClass:    AuthError,
+      code:          "auth-oid4vci/bad-resolved-key",
+      messagePrefix: "credential issuance: resolveKid-returned key is not importable as a public key: ",
+    });
   } else if (!holderKeyJwk && header.x5c) {
     // RFC 7515 §4.1.6 / OID4VCI §8.2.1.1 — the wallet ships a base64 DER
     // certificate chain; the LEAF (first) cert's SPKI is the holder key.
@@ -333,11 +333,11 @@ async function _verifyProofJwt(proofJwt, expectedAud, expectedCNonce, expectedCl
     // A leaf cert holding an RSA key against a proof declaring an HMAC
     // alg would otherwise be verified as an HMAC secret.
     jwtExternal._assertAlgKtyMatch(header.alg, holderKeyJwk);
-    try { keyObj = nodeCrypto.createPublicKey({ key: holderKeyJwk, format: "jwk" }); }
-    catch (e) {
-      throw new AuthError("auth-oid4vci/bad-x5c",
-        "credential issuance: proof JWT `x5c` leaf public key is not importable: " + ((e && e.message) || String(e)));
-    }
+    keyObj = importPublicJwk(holderKeyJwk, {
+      errorClass:    AuthError,
+      code:          "auth-oid4vci/bad-x5c",
+      messagePrefix: "credential issuance: proof JWT `x5c` leaf public key is not importable: ",
+    });
   } else {
     if (!holderKeyJwk) {
       throw new AuthError("auth-oid4vci/no-jwk-in-header",
@@ -349,11 +349,11 @@ async function _verifyProofJwt(proofJwt, expectedAud, expectedCNonce, expectedCl
     // key as an HMAC secret. Routed through the shared helper so every
     // JWT verifier in the framework enforces the same check.
     jwtExternal._assertAlgKtyMatch(header.alg, holderKeyJwk);
-    try { keyObj = nodeCrypto.createPublicKey({ key: holderKeyJwk, format: "jwk" }); }
-    catch (e) {
-      throw new AuthError("auth-oid4vci/bad-jwk",
-        "credential issuance: proof JWT jwk is not parseable: " + ((e && e.message) || String(e)));
-    }
+    keyObj = importPublicJwk(holderKeyJwk, {
+      errorClass:    AuthError,
+      code:          "auth-oid4vci/bad-jwk",
+      messagePrefix: "credential issuance: proof JWT jwk is not parseable: ",
+    });
   }
 
   var signingInput = parts[0] + "." + parts[1];
@@ -428,13 +428,36 @@ async function _verifyProofJwt(proofJwt, expectedAud, expectedCNonce, expectedCl
  *   });
  */
 function create(opts) {
+  // Preserve the original object-guard's exact label + default code
+  // (distinct from the per-field "issuer.create:" label prefix below).
   validateOpts.requireObject(opts, "auth.oid4vci.issuer.create", AuthError);
-  validateOpts.requireNonEmptyString(opts.credentialIssuerUrl,
-    "issuer.create: credentialIssuerUrl", AuthError, "auth-oid4vci/no-issuer-url");
-  validateOpts.requireNonEmptyString(opts.credentialEndpoint,
-    "issuer.create: credentialEndpoint", AuthError, "auth-oid4vci/no-credential-endpoint");
-  validateOpts.requireNonEmptyString(opts.tokenEndpoint,
-    "issuer.create: tokenEndpoint", AuthError, "auth-oid4vci/no-token-endpoint");
+  validateOpts.shape(opts, {
+    credentialIssuerUrl: { rule: "required-string", code: "auth-oid4vci/no-issuer-url" },
+    credentialEndpoint:  { rule: "required-string", code: "auth-oid4vci/no-credential-endpoint" },
+    tokenEndpoint:       { rule: "required-string", code: "auth-oid4vci/no-token-endpoint" },
+    // sdJwtIssuer + supportedCredentials carry distinct bespoke checks
+    // (instance shape / non-empty map / per-credential format+vct) below;
+    // declare them here so the exhaustive contract accepts the keys —
+    // required-object validates only that they are objects, which the
+    // bespoke checks then refine.
+    sdJwtIssuer:          "required-object",
+    supportedCredentials: "required-object",
+    proofAlgorithms:      "optional-string-array",
+    // resolveKid / validateX5c carry distinct per-field codes the inline
+    // config-time guards used; the descriptor form keeps the exact code +
+    // label inside the exhaustive shape.
+    resolveKid:           { rule: "optional-function", code: "auth-oid4vci/bad-resolve-kid" },
+    validateX5c:          { rule: "optional-function", code: "auth-oid4vci/bad-validate-x5c" },
+    preAuthCodeTtlMs:     "optional-positive-finite",
+    accessTokenTtlMs:     "optional-positive-finite",
+    cNonceTtlMs:          "optional-positive-finite",
+    proofMaxAgeMs:        "optional-positive-finite",
+    accessTokenSingleUse: "optional-boolean",
+    codeStore:            "optional-plain-object",
+    accessTokenStore:     "optional-plain-object",
+    cNonceStore:          "optional-plain-object",
+    authorizationServers: "optional-string-array",
+  }, "issuer.create", AuthError);
   if (!opts.sdJwtIssuer || typeof opts.sdJwtIssuer.issue !== "function") {
     throw new AuthError("auth-oid4vci/no-sd-jwt-issuer",
       "issuer.create: sdJwtIssuer must be a b.auth.sdJwtVc.issuer instance");
@@ -464,18 +487,18 @@ function create(opts) {
     ? opts.proofAlgorithms : ["ES256", "ES384", "EdDSA"];
 
   // Optional kid-resolver for kid-only proofs (EUDI-Wallet attested-key
-  // flow). Config-time throw if supplied but not a function. Absent →
-  // kid-only proofs keep the clear refusal (back-compat).
-  var resolveKid = validateOpts.optionalFunction(opts.resolveKid,
-    "issuer.create: resolveKid", AuthError, "auth-oid4vci/bad-resolve-kid");
+  // flow). Validated by the shape above (config-time throw if supplied
+  // but not a function). Absent → kid-only proofs keep the clear refusal
+  // (back-compat).
+  var resolveKid = opts.resolveKid;
 
   // Optional x5c chain-trust policy for x5c proofs (RFC 7515 §4.1.6 /
-  // OID4VCI §8.2.1.1). Config-time throw if supplied but not a function.
-  // Absent → the leaf-cert SPKI binds at the same self-asserted trust
-  // level as an inline `jwk` (the proof signature binds the key); chain
-  // anchoring beyond that is the operator's to enforce via this callback.
-  var validateX5c = validateOpts.optionalFunction(opts.validateX5c,
-    "issuer.create: validateX5c", AuthError, "auth-oid4vci/bad-validate-x5c");
+  // OID4VCI §8.2.1.1). Validated by the shape above (config-time throw if
+  // supplied but not a function). Absent → the leaf-cert SPKI binds at the
+  // same self-asserted trust level as an inline `jwk` (the proof signature
+  // binds the key); chain anchoring beyond that is the operator's to
+  // enforce via this callback.
+  var validateX5c = opts.validateX5c;
 
   var preAuthTtl = opts.preAuthCodeTtlMs || DEFAULT_PRE_AUTH_TTL_MS;
   var accessTokenTtl = opts.accessTokenTtlMs || DEFAULT_ACCESS_TOKEN_TTL;

package/lib/auth/oid4vp.js

@@ -52,6 +52,7 @@
 
 var lazyRequire  = require("../lazy-require");
 var validateOpts = require("../validate-opts");
+var boundedMap   = require("../bounded-map");
 var { generateToken } = require("../crypto");
 var { AuthError } = require("../framework-error");
 
@@ -90,10 +91,10 @@ function _validateDcql(dcql) {
       throw new AuthError("auth-oid4vp/no-credential-id",
         "DCQL: credentials[" + i + "].id is required");
     }
-    if (seenIds.has(cred.id)) {
+    boundedMap.requireAbsentMember(seenIds, cred.id, function () {
       throw new AuthError("auth-oid4vp/duplicate-id",
         "DCQL: credentials[" + i + "].id \"" + cred.id + "\" duplicated");
-    }
+    });
     seenIds.add(cred.id);
     if (typeof cred.format !== "string" || cred.format.length === 0) {
       throw new AuthError("auth-oid4vp/no-format",

package/lib/auth/openid-federation.js

@@ -58,6 +58,7 @@ var lazyRequire  = require("../lazy-require");
 var validateOpts = require("../validate-opts");
 var safeJson     = require("../safe-json");
 var nodeCrypto   = require("node:crypto");
+var bCrypto      = require("../crypto");
 var C            = require("../constants");
 // Shared JOSE defenses (CVE-2026-22817 alg/kty cross-check +
 // CVE-2026-23552 constant-time iss compare). Top-of-file per project
@@ -195,12 +196,11 @@ function verifyEntityStatement(jwt, jwks, vopts) {
   // same check.
   jwtExternal._assertAlgKtyMatch(parsed.header.alg, key);
 
-  var keyObj;
-  try { keyObj = nodeCrypto.createPublicKey({ key: key, format: "jwk" }); }
-  catch (e) {
-    throw new AuthError("auth-openid-federation/bad-jwk",
-      "verifyEntityStatement: JWK is not parseable: " + ((e && e.message) || String(e)));
-  }
+  var keyObj = bCrypto.importPublicJwk(key, {
+    errorClass:    AuthError,
+    code:          "auth-openid-federation/bad-jwk",
+    messagePrefix: "verifyEntityStatement: JWK is not parseable: ",
+  });
 
   var hash = _hashByAlg(parsed.header.alg);
   var verifyOpts = { key: keyObj };

package/lib/auth/passkey.js

@@ -325,7 +325,7 @@ function _b64urlExtInput(value, name, maxBytes) {
     }
     if (typeof maxBytes === "number") {
       var decoded = Buffer.from(value, "base64url");
-      if (decoded.length > maxBytes) {
+      if (safeBuffer.byteLengthOf(decoded) > maxBytes) {
         throw new AuthError("auth-passkey/extension-input-too-large",
           name + " decoded length " + decoded.length + " exceeds " + maxBytes + " bytes");
       }
@@ -333,14 +333,14 @@ function _b64urlExtInput(value, name, maxBytes) {
     return value;
   }
   if (Buffer.isBuffer(value)) {
-    if (typeof maxBytes === "number" && value.length > maxBytes) {
+    if (typeof maxBytes === "number" && safeBuffer.byteLengthOf(value) > maxBytes) {
       throw new AuthError("auth-passkey/extension-input-too-large",
         name + " length " + value.length + " exceeds " + maxBytes + " bytes");
     }
     return value.toString("base64url");
   }
   if (value instanceof Uint8Array) {
-    if (typeof maxBytes === "number" && value.length > maxBytes) {
+    if (typeof maxBytes === "number" && safeBuffer.byteLengthOf(value) > maxBytes) {
       throw new AuthError("auth-passkey/extension-input-too-large",
         name + " length " + value.length + " exceeds " + maxBytes + " bytes");
     }
@@ -385,7 +385,7 @@ function _largeBlobExt(args) {
   var SUPPORT = { preferred: 1, required: 1 };
   var modes = 0;
   if (args.support !== undefined) {
-    if (!SUPPORT[args.support]) {
+    if (!Object.prototype.hasOwnProperty.call(SUPPORT, args.support)) {
       throw new AuthError("auth-passkey/bad-largeblob-support",
         "extensions.largeBlob support must be 'preferred' or 'required'");
     }

package/lib/auth/password.js

@@ -282,7 +282,7 @@ function policy(opts) {
   // Apply named profile FIRST, then operator opts on top so the
   // operator can override profile defaults per-field.
   if (typeof opts.profile === "string" && opts.profile.length > 0) {
-    if (!POLICY_PROFILES[opts.profile]) {
+    if (!Object.prototype.hasOwnProperty.call(POLICY_PROFILES, opts.profile)) {
       throw new AuthError("auth-password/bad-policy",
         "policy.profile must be one of " + Object.keys(POLICY_PROFILES).join("/") +
         ", got " + JSON.stringify(opts.profile));
@@ -421,7 +421,13 @@ function policy(opts) {
       var sha1Full = hibpSha1.sha1Hex(plaintext).toUpperCase();
       var prefix = sha1Full.slice(0, 5);
       var suffix = sha1Full.slice(5);
-      var url = p.hibpEndpoint.replace(/\/+$/, "") + "/range/" + prefix;
+      // Strip trailing slashes with a linear backward scan rather than
+      // /\/+$/ — the `$`-after-greedy-`+` regex is O(n^2) in V8 on a value
+      // that is a long run of '/' (the engine retries from every offset).
+      // Byte-identical result, unconditionally linear.
+      var endEp = p.hibpEndpoint.length;
+      while (endEp > 0 && p.hibpEndpoint.charCodeAt(endEp - 1) === 0x2f) { endEp -= 1; }
+      var url = p.hibpEndpoint.slice(0, endEp) + "/range/" + prefix;
       var resp;
       try {
         resp = await httpClient.request({

package/lib/auth/saml.js

@@ -170,7 +170,7 @@ function _verifyXmldsig(envelope, signatureNode, certPem) {
   }
   var sigMethodNode = _findChild(signedInfo, "SignatureMethod");
   var sigAlgo = sigMethodNode && _attr(sigMethodNode, "Algorithm");
-  if (!SUPPORTED_SIG[sigAlgo]) {
+  if (!Object.prototype.hasOwnProperty.call(SUPPORTED_SIG, sigAlgo)) {
     throw new AuthError("auth-saml/unsupported-sig-alg",
       "Unsupported SignatureMethod: " + sigAlgo);
   }
@@ -184,7 +184,7 @@ function _verifyXmldsig(envelope, signatureNode, certPem) {
   var refId = refUri.substring(1);
   var digestMethodNode = _findChild(refNode, "DigestMethod");
   var digestAlgo = digestMethodNode && _attr(digestMethodNode, "Algorithm");
-  if (!SUPPORTED_DIGEST[digestAlgo]) {
+  if (!Object.prototype.hasOwnProperty.call(SUPPORTED_DIGEST, digestAlgo)) {
     throw new AuthError("auth-saml/unsupported-digest",
       "Unsupported DigestMethod: " + digestAlgo);
   }
@@ -332,13 +332,18 @@ function _verifyXmldsig(envelope, signatureNode, certPem) {
  *   });
  */
 function create(opts) {
-  validateOpts.requireObject(opts, "auth.saml.sp.create", AuthError);
-  validateOpts.requireNonEmptyString(opts.entityId, "entityId", AuthError, "auth-saml/no-entity-id");
-  validateOpts.requireNonEmptyString(opts.assertionConsumerServiceUrl, "assertionConsumerServiceUrl",
-    AuthError, "auth-saml/no-acs");
-  validateOpts.requireNonEmptyString(opts.idpEntityId, "idpEntityId", AuthError, "auth-saml/no-idp-entity-id");
-  validateOpts.requireNonEmptyString(opts.idpSsoUrl, "idpSsoUrl", AuthError, "auth-saml/no-idp-sso");
-  validateOpts.requireNonEmptyString(opts.idpCertPem, "idpCertPem", AuthError, "auth-saml/no-idp-cert");
+  validateOpts.shape(opts, {
+    entityId:                    { rule: "required-string", label: "entityId",                    code: "auth-saml/no-entity-id" },
+    assertionConsumerServiceUrl: { rule: "required-string", label: "assertionConsumerServiceUrl", code: "auth-saml/no-acs" },
+    idpEntityId:                 { rule: "required-string", label: "idpEntityId",                 code: "auth-saml/no-idp-entity-id" },
+    idpSsoUrl:                   { rule: "required-string", label: "idpSsoUrl",                    code: "auth-saml/no-idp-sso" },
+    idpCertPem:                  { rule: "required-string", label: "idpCertPem",                   code: "auth-saml/no-idp-cert" },
+    audience:                    "optional-string",
+    clockSkewSec:                "optional-non-negative",
+    nameIdFormat:                "optional-string",
+    singleLogoutServiceUrl:      "optional-string",
+    idpSloUrl:                   "optional-string",
+  }, "auth.saml.sp.create", AuthError);
 
   var audience = opts.audience || opts.entityId;
   var clockSkewSec = typeof opts.clockSkewSec === "number" ? opts.clockSkewSec : 60;             // allow:raw-time-literal — clock-skew default
@@ -740,26 +745,46 @@ function create(opts) {
       var cNotOnOrAfter = _attr(conditions, "NotOnOrAfter");
       if (cNotBefore) {
         var cnb = Date.parse(cNotBefore) / 1000;                                                // ms→s
-        if (isFinite(cnb) && cnb > nowSec + clockSkewSec) {
+        // Fail CLOSED on a present-but-unparseable bound (mirrors the Bearer
+        // SCD path at line ~708) instead of skipping the window via isFinite().
+        if (!isFinite(cnb)) {
+          throw new AuthError("auth-saml/conditions-bad-timestamp",
+            "Conditions NotBefore is present but unparseable");
+        }
+        if (cnb > nowSec + clockSkewSec) {
           throw new AuthError("auth-saml/conditions-not-yet-valid",
             "Conditions NotBefore is in the future");
         }
       }
       if (cNotOnOrAfter) {
         var cnoa = Date.parse(cNotOnOrAfter) / 1000;                                            // ms→s
-        if (isFinite(cnoa) && cnoa < nowSec - clockSkewSec) {
+        if (!isFinite(cnoa)) {
+          throw new AuthError("auth-saml/conditions-bad-timestamp",
+            "Conditions NotOnOrAfter is present but unparseable");
+        }
+        if (cnoa < nowSec - clockSkewSec) {
           throw new AuthError("auth-saml/conditions-expired",
             "Conditions NotOnOrAfter has passed");
         }
       }
-      var ar = _findChild(conditions, "AudienceRestriction", SAML_NS.assertion);
-      if (ar) {
-        var audiences = _findAllChildren(ar, "Audience", SAML_NS.assertion).map(_textContent);
-        if (audiences.indexOf(audience) === -1) {
-          throw new AuthError("auth-saml/wrong-audience",
-            "Audience \"" + audience + "\" not in assertion's AudienceRestriction (got " +
-            JSON.stringify(audiences) + ")");
-        }
+    }
+    // Audience binding — a signed assertion is bound to THIS SP via
+    // AudienceRestriction. A missing Conditions or AudienceRestriction means
+    // it is not bound here (audience-confusion: an assertion minted for another
+    // SP). Fail closed when an audience is configured; opt out only via
+    // vopts.requireAudienceRestriction === false.
+    if (audience && vopts.requireAudienceRestriction !== false) {
+      var ar = conditions && _findChild(conditions, "AudienceRestriction", SAML_NS.assertion);
+      if (!ar) {
+        throw new AuthError("auth-saml/no-audience-restriction",
+          "verifyResponse: assertion has no AudienceRestriction binding it to \"" +
+          audience + "\" (audience-confusion defense; set requireAudienceRestriction:false to opt out)");
+      }
+      var audiences = _findAllChildren(ar, "Audience", SAML_NS.assertion).map(_textContent);
+      if (audiences.indexOf(audience) === -1) {
+        throw new AuthError("auth-saml/wrong-audience",
+          "Audience \"" + audience + "\" not in assertion's AudienceRestriction (got " +
+          JSON.stringify(audiences) + ")");
       }
     }
 
@@ -973,6 +998,25 @@ function create(opts) {
    *     idpVerifyAlg: "ml-dsa-65",
    *   });
    */
+  // _extractRedirectSignature(queryString) — split a SAML HTTP-Redirect
+  // binding query string, pulling the URL-decoded `Signature=` value out and
+  // collecting the remaining (signed) portion in order. Shared by
+  // parseLogoutRequest / parseLogoutResponse so the two cannot drift on which
+  // bytes the signature covers — a drift would be a signature-bypass.
+  function _extractRedirectSignature(queryString) {
+    var parts = queryString.split("&");
+    var sigValue = null;
+    var signedPortion = [];
+    for (var i = 0; i < parts.length; i += 1) {
+      if (parts[i].indexOf("Signature=") === 0) {
+        sigValue = decodeURIComponent(parts[i].slice("Signature=".length));
+      } else {
+        signedPortion.push(parts[i]);
+      }
+    }
+    return { sigValue: sigValue, signedPortion: signedPortion };
+  }
+
   function parseLogoutRequest(samlRequestB64, vopts) {
     vopts = vopts || {};
     if (typeof samlRequestB64 !== "string" || samlRequestB64.length === 0) {
@@ -998,16 +1042,9 @@ function create(opts) {
         throw new AuthError("auth-saml/bad-verify-alg",
           "parseLogoutRequest: idpVerifyAlg must be 'ml-dsa-65' / 'ml-dsa-87' / 'ed25519'");
       }
-      var parts = vopts.queryString.split("&");
-      var sigValue = null;
-      var signedPortion = [];
-      for (var i = 0; i < parts.length; i += 1) {
-        if (parts[i].indexOf("Signature=") === 0) {
-          sigValue = decodeURIComponent(parts[i].slice("Signature=".length));
-        } else {
-          signedPortion.push(parts[i]);
-        }
-      }
+      var sig = _extractRedirectSignature(vopts.queryString);
+      var sigValue = sig.sigValue;
+      var signedPortion = sig.signedPortion;
       if (!sigValue) {
         throw new AuthError("auth-saml/no-signature",
           "parseLogoutRequest: queryString lacks Signature parameter");
@@ -1193,16 +1230,9 @@ function create(opts) {
         throw new AuthError("auth-saml/bad-verify-alg",
           "parseLogoutResponse: idpVerifyAlg must be 'ml-dsa-65' / 'ml-dsa-87' / 'ed25519'");
       }
-      var parts = vopts.queryString.split("&");
-      var sigValue = null;
-      var signedPortion = [];
-      for (var i = 0; i < parts.length; i += 1) {
-        if (parts[i].indexOf("Signature=") === 0) {
-          sigValue = decodeURIComponent(parts[i].slice("Signature=".length));
-        } else {
-          signedPortion.push(parts[i]);
-        }
-      }
+      var sig = _extractRedirectSignature(vopts.queryString);
+      var sigValue = sig.sigValue;
+      var signedPortion = sig.signedPortion;
       if (!sigValue) {
         throw new AuthError("auth-saml/no-signature",
           "parseLogoutResponse: queryString lacks Signature parameter");
@@ -1887,7 +1917,7 @@ function _verifyEmbeddedXmlDsig(xml, idpVerifyKey, idpVerifyAlg, expectedRootLoc
   // Allow either sha3-512 (framework default) or the SHA-2 family.
   var digestAlgName;
   if (digestUri === "http://www.w3.org/2007/05/xmldsig-more#sha3-512") digestAlgName = "sha3-512";
-  else if (SUPPORTED_DIGEST[digestUri]) digestAlgName = SUPPORTED_DIGEST[digestUri];
+  else if (Object.prototype.hasOwnProperty.call(SUPPORTED_DIGEST, digestUri)) digestAlgName = SUPPORTED_DIGEST[digestUri];
   else {
     throw new AuthError("auth-saml/unsupported-digest",
       "_verifyEmbeddedXmlDsig: DigestMethod " + digestUri + " not supported");

package/lib/auth/sd-jwt-vc-holder.js

@@ -144,21 +144,9 @@ function create(opts) {
   var algorithm = _resolveHolderAlg(opts.holderKey, opts.algorithm);
   var auditOn = opts.auditOn !== false;
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditOn) return;
-    try {
-      audit().safeEmit({
-        action:   action,
-        outcome:  outcome,
-        metadata: metadata || {},
-      });
-    } catch (_e) { /* drop-silent */ }
-  }
+  var _emitAudit = audit().namespaced(null, { audit: auditOn });
 
-  function _emitMetric(verb) {
-    try { observability().safeEvent("auth.sdJwtVc.holder." + verb, 1, {}); }
-    catch (_e) { /* drop-silent */ }
-  }
+  var _emitMetric = observability().namespaced("auth.sdJwtVc.holder");
 
   async function store(spec) {
     if (!spec || typeof spec !== "object") {

package/lib/auth/sd-jwt-vc-issuer.js

@@ -104,21 +104,9 @@ function create(opts) {
     keysRotated:  0,
   };
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditOn) return;
-    try {
-      audit().safeEmit({
-        action:   action,
-        outcome:  outcome,
-        metadata: metadata || {},
-      });
-    } catch (_e) { /* drop-silent */ }
-  }
+  var _emitAudit = audit().namespaced(null, { audit: auditOn });
 
-  function _emitMetric(verb) {
-    try { observability().safeEvent("auth.sdJwtVc.issuer." + verb, 1, {}); }
-    catch (_e) { /* drop-silent */ }
-  }
+  var _emitMetric = observability().namespaced("auth.sdJwtVc.issuer");
 
   async function issue(spec) {
     if (!spec || typeof spec !== "object") {