@suveren/gateway 0.6.2 → 0.6.4

package/node_modules/@hap/core/dist/index.js

@@ -30,7 +30,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ContentBindingError: () => ContentBindingError,
   attestationId: () => attestationId,
+  bindingAppliesTo: () => bindingAppliesTo,
   canonicalBounds: () => canonicalBounds,
   canonicalContext: () => canonicalContext,
   canonicalFrame: () => canonicalFrame,
@@ -41,6 +43,7 @@ __export(index_exports, {
   computeBoundsHash: () => computeBoundsHash,
   computeContentHash: () => computeContentHash,
   computeContextHash: () => computeContextHash,
+  computeFieldsContentHash: () => computeFieldsContentHash,
   computeFrameHash: () => computeFrameHash,
   computeIntentDisclosureHash: () => computeIntentDisclosureHash,
   computeIntentHash: () => computeIntentHash,
@@ -52,9 +55,11 @@ __export(index_exports, {
   getAllProfiles: () => getAllProfiles,
   getProfile: () => getProfile,
   intentDisclosureCanonicalBytes: () => intentDisclosureCanonicalBytes,
+  isFieldBinding: () => isFieldBinding,
   isV4Attestation: () => isV4Attestation,
   listProfiles: () => listProfiles,
   registerProfile: () => registerProfile,
+  selectBoundFields: () => selectBoundFields,
   validateBoundsParams: () => validateBoundsParams,
   validateContextParams: () => validateContextParams,
   validateFrameParams: () => validateFrameParams,
@@ -120,6 +125,89 @@ function contentCanonicalBytes(kind, content) {
 function computeContentHash(binding, content) {
   return `sha256:${sha256Hex(contentCanonicalBytes(binding.kind, content))}`;
 }
+var ContentBindingError = class extends Error {
+  code;
+  /** The offending field, when the code names one. */
+  field;
+  constructor(code, message, field) {
+    super(message);
+    this.name = "ContentBindingError";
+    this.code = code;
+    this.field = field;
+  }
+};
+function isFieldBinding(binding) {
+  return binding.version === "2" && Array.isArray(binding.fields) && binding.fields.length > 0;
+}
+function bindingAppliesTo(binding, actionType) {
+  if (!binding.appliesTo) return true;
+  return actionType !== void 0 && binding.appliesTo.includes(actionType);
+}
+function canonicalizeValue(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") {
+    const text = canonicalizeText(value);
+    return text === "" ? void 0 : text;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    const items = value.map(canonicalizeValue).filter((v) => v !== void 0);
+    return items.length > 0 ? items : void 0;
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, v] of Object.entries(value)) {
+      const c = canonicalizeValue(v);
+      if (c !== void 0) out[key] = c;
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+  }
+  return void 0;
+}
+function selectBoundFields(binding, args) {
+  const fields = binding.fields;
+  if (!fields || fields.length === 0) {
+    throw new ContentBindingError(
+      "NO_FIELDS_DECLARED",
+      'content_binding version "2" requires a non-empty `fields` list.'
+    );
+  }
+  const required = new Set(binding.required_fields ?? []);
+  for (const field of required) {
+    if (!fields.includes(field)) {
+      throw new ContentBindingError(
+        "REQUIRED_FIELD_NOT_DECLARED",
+        `content_binding requires "${field}" but does not bind it \u2014 required_fields must be a subset of fields.`,
+        field
+      );
+    }
+  }
+  const bound = {};
+  for (const field of fields) {
+    const value = canonicalizeValue(args[field]);
+    if (value === void 0) {
+      if (required.has(field)) {
+        throw new ContentBindingError(
+          "MISSING_REQUIRED_FIELD",
+          `content_binding requires "${field}", which is absent or empty in this call. Refusing rather than hashing a partial object.`,
+          field
+        );
+      }
+      continue;
+    }
+    bound[field] = value;
+  }
+  if (Object.keys(bound).length === 0) {
+    throw new ContentBindingError(
+      "EMPTY_BINDING",
+      `No declared field (${fields.join(", ")}) carried a value \u2014 the hash would commit to nothing.`
+    );
+  }
+  return bound;
+}
+function computeFieldsContentHash(binding, args) {
+  return computeContentHash(binding, selectBoundFields(binding, args));
+}
 
 // src/intent-disclosure.ts
 var import_crypto2 = require("crypto");
@@ -859,7 +947,9 @@ function resolveCumulativeFields(request, profile, executionLog, now) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ContentBindingError,
   attestationId,
+  bindingAppliesTo,
   canonicalBounds,
   canonicalContext,
   canonicalFrame,
@@ -870,6 +960,7 @@ function resolveCumulativeFields(request, profile, executionLog, now) {
   computeBoundsHash,
   computeContentHash,
   computeContextHash,
+  computeFieldsContentHash,
   computeFrameHash,
   computeIntentDisclosureHash,
   computeIntentHash,
@@ -881,9 +972,11 @@ function resolveCumulativeFields(request, profile, executionLog, now) {
   getAllProfiles,
   getProfile,
   intentDisclosureCanonicalBytes,
+  isFieldBinding,
   isV4Attestation,
   listProfiles,
   registerProfile,
+  selectBoundFields,
   validateBoundsParams,
   validateContextParams,
   validateFrameParams,

package/node_modules/@hap/core/dist/index.mjs

@@ -49,6 +49,89 @@ function contentCanonicalBytes(kind, content) {
 function computeContentHash(binding, content) {
   return `sha256:${sha256Hex(contentCanonicalBytes(binding.kind, content))}`;
 }
+var ContentBindingError = class extends Error {
+  code;
+  /** The offending field, when the code names one. */
+  field;
+  constructor(code, message, field) {
+    super(message);
+    this.name = "ContentBindingError";
+    this.code = code;
+    this.field = field;
+  }
+};
+function isFieldBinding(binding) {
+  return binding.version === "2" && Array.isArray(binding.fields) && binding.fields.length > 0;
+}
+function bindingAppliesTo(binding, actionType) {
+  if (!binding.appliesTo) return true;
+  return actionType !== void 0 && binding.appliesTo.includes(actionType);
+}
+function canonicalizeValue(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") {
+    const text = canonicalizeText(value);
+    return text === "" ? void 0 : text;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    const items = value.map(canonicalizeValue).filter((v) => v !== void 0);
+    return items.length > 0 ? items : void 0;
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, v] of Object.entries(value)) {
+      const c = canonicalizeValue(v);
+      if (c !== void 0) out[key] = c;
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+  }
+  return void 0;
+}
+function selectBoundFields(binding, args) {
+  const fields = binding.fields;
+  if (!fields || fields.length === 0) {
+    throw new ContentBindingError(
+      "NO_FIELDS_DECLARED",
+      'content_binding version "2" requires a non-empty `fields` list.'
+    );
+  }
+  const required = new Set(binding.required_fields ?? []);
+  for (const field of required) {
+    if (!fields.includes(field)) {
+      throw new ContentBindingError(
+        "REQUIRED_FIELD_NOT_DECLARED",
+        `content_binding requires "${field}" but does not bind it \u2014 required_fields must be a subset of fields.`,
+        field
+      );
+    }
+  }
+  const bound = {};
+  for (const field of fields) {
+    const value = canonicalizeValue(args[field]);
+    if (value === void 0) {
+      if (required.has(field)) {
+        throw new ContentBindingError(
+          "MISSING_REQUIRED_FIELD",
+          `content_binding requires "${field}", which is absent or empty in this call. Refusing rather than hashing a partial object.`,
+          field
+        );
+      }
+      continue;
+    }
+    bound[field] = value;
+  }
+  if (Object.keys(bound).length === 0) {
+    throw new ContentBindingError(
+      "EMPTY_BINDING",
+      `No declared field (${fields.join(", ")}) carried a value \u2014 the hash would commit to nothing.`
+    );
+  }
+  return bound;
+}
+function computeFieldsContentHash(binding, args) {
+  return computeContentHash(binding, selectBoundFields(binding, args));
+}
 
 // src/intent-disclosure.ts
 import { createHash as createHash2 } from "crypto";
@@ -787,7 +870,9 @@ function resolveCumulativeFields(request, profile, executionLog, now) {
   return errors;
 }
 export {
+  ContentBindingError,
   attestationId,
+  bindingAppliesTo,
   canonicalBounds,
   canonicalContext,
   canonicalFrame,
@@ -798,6 +883,7 @@ export {
   computeBoundsHash,
   computeContentHash,
   computeContextHash,
+  computeFieldsContentHash,
   computeFrameHash,
   computeIntentDisclosureHash,
   computeIntentHash,
@@ -809,9 +895,11 @@ export {
   getAllProfiles,
   getProfile,
   intentDisclosureCanonicalBytes,
+  isFieldBinding,
   isV4Attestation,
   listProfiles,
   registerProfile,
+  selectBoundFields,
   validateBoundsParams,
   validateContextParams,
   validateFrameParams,

package/node_modules/@hap/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanagencyp/hap-core",
-  "version": "0.8.0",
+  "version": "0.8.3",
   "description": "Core types, cryptographic primitives, and verification logic for the Human Agency Protocol",
   "license": "MIT",
   "repository": {

package/node_modules/@hap/core/src/content-binding.ts

@@ -16,6 +16,12 @@
  *    (Unicode NFC, LF line endings, trailing per-line whitespace stripped,
  *    trailing blank lines removed), taken pre-footer when `pre_footer` is set.
  *
+ * At `version:"2"` the profile also declares WHICH tool arguments are bound
+ * ({@link selectBoundFields}), so a receipt can commit to an email's recipients
+ * and not only its prose — while still omitting what the intended verifier
+ * cannot see. Every string entering the hashed object is canonicalized by the
+ * same `text` rule, so a delivered copy with CRLF endings still reproduces it.
+ *
  * Both Node and the browser produce byte-identical output: JCS relies only on
  * environment-independent primitives, and the text rule uses String.normalize +
  * plain string ops. The SHA-256 is computed with Node `crypto` here (the same
@@ -81,3 +87,165 @@ export function computeContentHash(
 ): string {
   return `sha256:${sha256Hex(contentCanonicalBytes(binding.kind, content))}`;
 }
+
+// ─── v2: binding over a declared field subset ────────────────────────────────
+
+/** Why a field binding refused. Every case is fail-closed by design. */
+export type ContentBindingErrorCode =
+  /** The profile declares version:"2" with no usable `fields` list. */
+  | 'NO_FIELDS_DECLARED'
+  /** `required_fields` names something absent from `fields`. */
+  | 'REQUIRED_FIELD_NOT_DECLARED'
+  /** A required field was absent or empty at call time. */
+  | 'MISSING_REQUIRED_FIELD'
+  /** No declared field carried a value — the hash would commit to nothing. */
+  | 'EMPTY_BINDING';
+
+/**
+ * A field binding could not be computed. ALWAYS a refusal, never a downgrade:
+ * the alternative is a receipt that verifies while proving less than it appears
+ * to, which is the failure content binding exists to prevent.
+ */
+export class ContentBindingError extends Error {
+  readonly code: ContentBindingErrorCode;
+  /** The offending field, when the code names one. */
+  readonly field?: string;
+
+  constructor(code: ContentBindingErrorCode, message: string, field?: string) {
+    super(message);
+    this.name = 'ContentBindingError';
+    this.code = code;
+    this.field = field;
+  }
+}
+
+/** True when this binding selects a declared subset (v2) rather than v1's implicit scope. */
+export function isFieldBinding(binding: ContentBinding): boolean {
+  return binding.version === '2' && Array.isArray(binding.fields) && binding.fields.length > 0;
+}
+
+/**
+ * Whether a field binding covers this action type, per the profile's `appliesTo`.
+ *
+ * Read STRICTLY — an undeclared action type is NOT covered. This differs from
+ * how bounds read the same key (there, an unknown action type enforces the
+ * bound, because an extra limit is safe). Here the two directions are not
+ * symmetric: applying a field binding to a call that carries no content refuses
+ * a legitimate action, so an unknown action type must fall outside rather than
+ * inside. Callers are expected to warn on the undeclared case — it is a
+ * manifest bug either way.
+ */
+export function bindingAppliesTo(
+  binding: ContentBinding,
+  actionType: string | undefined,
+): boolean {
+  if (!binding.appliesTo) return true;
+  return actionType !== undefined && binding.appliesTo.includes(actionType);
+}
+
+/**
+ * Canonicalize one value on its way into the bound object, or `undefined` when
+ * it carries nothing (absent / null / empty after canonicalization).
+ *
+ * Strings are run through {@link canonicalizeText} — the SAME rule `kind:"text"`
+ * uses, applied per string rather than to one field. This is not decoration:
+ * the verifier of an email holds the DELIVERED copy, whose body has CRLF line
+ * endings and transport-added trailing whitespace. JCS embeds strings verbatim,
+ * so without this the recipient could never reproduce the hash.
+ *
+ * Deliberately NOT normalized: array order (the To: header preserves what was
+ * sent, and reordering recipients is a change worth catching) and address case
+ * (the local part is case-sensitive per RFC 5321, so lowercasing would be a
+ * semantic claim this layer has no business making).
+ */
+function canonicalizeValue(value: unknown): unknown {
+  if (value === null || value === undefined) return undefined;
+  if (typeof value === 'string') {
+    const text = canonicalizeText(value);
+    return text === '' ? undefined : text;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') return value;
+  if (Array.isArray(value)) {
+    const items = value.map(canonicalizeValue).filter((v) => v !== undefined);
+    return items.length > 0 ? items : undefined;
+  }
+  if (typeof value === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [key, v] of Object.entries(value as Record<string, unknown>)) {
+      const c = canonicalizeValue(v);
+      if (c !== undefined) out[key] = c;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+  }
+  return undefined; // functions/symbols — not JSON, nothing to bind
+}
+
+/**
+ * Build the object a v2 binding hashes: exactly the declared `fields` that
+ * carry a value, canonicalized. Exported so a verifier can construct the same
+ * object from what they hold and see it before hashing.
+ *
+ * Throws {@link ContentBindingError} rather than returning a partial result —
+ * see that class for why refusing is the only safe outcome.
+ */
+export function selectBoundFields(
+  binding: ContentBinding,
+  args: Record<string, unknown>,
+): Record<string, unknown> {
+  const fields = binding.fields;
+  if (!fields || fields.length === 0) {
+    throw new ContentBindingError(
+      'NO_FIELDS_DECLARED',
+      'content_binding version "2" requires a non-empty `fields` list.',
+    );
+  }
+
+  const required = new Set(binding.required_fields ?? []);
+  for (const field of required) {
+    if (!fields.includes(field)) {
+      throw new ContentBindingError(
+        'REQUIRED_FIELD_NOT_DECLARED',
+        `content_binding requires "${field}" but does not bind it — required_fields must be a subset of fields.`,
+        field,
+      );
+    }
+  }
+
+  const bound: Record<string, unknown> = {};
+  for (const field of fields) {
+    const value = canonicalizeValue(args[field]);
+    if (value === undefined) {
+      if (required.has(field)) {
+        throw new ContentBindingError(
+          'MISSING_REQUIRED_FIELD',
+          `content_binding requires "${field}", which is absent or empty in this call. ` +
+            `Refusing rather than hashing a partial object.`,
+          field,
+        );
+      }
+      continue; // legitimately absent (an email with no cc)
+    }
+    bound[field] = value;
+  }
+
+  if (Object.keys(bound).length === 0) {
+    throw new ContentBindingError(
+      'EMPTY_BINDING',
+      `No declared field (${fields.join(', ')}) carried a value — the hash would commit to nothing.`,
+    );
+  }
+
+  return bound;
+}
+
+/**
+ * Compute a v2 field-binding hash from raw tool arguments: select the declared
+ * subset, then hash it by the declared `kind`. Convenience over
+ * {@link selectBoundFields} + {@link computeContentHash} for the common path.
+ */
+export function computeFieldsContentHash(
+  binding: ContentBinding,
+  args: Record<string, unknown>,
+): string {
+  return computeContentHash(binding, selectBoundFields(binding, args));
+}

package/node_modules/@hap/core/src/types.ts

@@ -271,22 +271,64 @@ export interface ProfileBoundsField {
  * backward compatibility). The gateway computes the hash; the SP only ever
  * receives the hash, never the content, so HAP's privacy-minimal design holds.
  *
- * The profile declares only the *policy* — whether to bind and how to
- * canonicalize. It does NOT name the tool field: that is tool-specific and is
- * resolved at runtime (the same content-field resolver the footer uses for
- * `kind:"text"`; the whole record payload for `kind:"jcs"`).
+ * At `version:"1"` the profile declares only the *policy* — whether to bind and
+ * how to canonicalize. It does NOT name the tool field: that is tool-specific
+ * and is resolved at runtime (the same content-field resolver the footer uses
+ * for `kind:"text"`; the whole record payload for `kind:"jcs"`).
+ *
+ * At `version:"2"` the profile additionally declares WHICH fields are bound (see
+ * {@link ContentBinding.fields}). Neither v1 mode is the general case: `text`
+ * binds one field and leaves everything beside it unbound, while `jcs` over the
+ * whole payload is checkable only by a party that already knows the whole
+ * payload — an email recipient holds the body, the subject and their own
+ * address, but not `bcc`. The general case is a declared subset, chosen so the
+ * intended verifier can reproduce it.
  */
 export interface ContentBinding {
   /** Canonicalization version. A verifier MUST pin the version named here. */
   version: string;
   /**
-   * - 'jcs'  → structured writes: RFC 8785 JCS over the record payload.
+   * - 'jcs'  → structured writes: RFC 8785 JCS over the record payload
+   *   (v1) or over the object built from {@link fields} (v2).
    * - 'text' → free text: NFC + LF + trailing-whitespace strip (see
    *   canonicalizeText), auto-detected content field.
    */
   kind: 'jcs' | 'text';
   /** text only: hash the content BEFORE any appended Suveren footer. */
   pre_footer?: boolean;
+
+  /**
+   * v2 only — the tool-argument keys this binding covers, and the complete
+   * statement of what a verifier must reproduce. The Gatekeeper builds an
+   * object from exactly these keys and canonicalizes it by `kind`.
+   *
+   * Adding or removing an entry changes every resulting hash, so it is a
+   * BREAKING profile change requiring a version bump, never a silent edit.
+   *
+   * Choose the subset by one rule: bind everything the approving human is
+   * shown, and nothing the intended verifier cannot see.
+   */
+  fields?: string[];
+  /**
+   * v2 only — the subset of {@link fields} whose absence is a fault rather than
+   * a fact. An absent OPTIONAL field is omitted from the hashed object (an
+   * email legitimately has no `cc`); an absent REQUIRED field means the call is
+   * not the call this profile thinks it is, and MUST refuse rather than hash a
+   * partial object that reads exactly like a complete one.
+   *
+   * MUST be a subset of `fields`. Absent → every field is optional, and only a
+   * wholly empty selection refuses.
+   */
+  required_fields?: string[];
+  /**
+   * v2 only — the action types this binding covers, using the same vocabulary
+   * as {@link ProfileBoundsField.appliesTo}. A profile gates more than its
+   * content-bearing calls: `email` also gates deletes, which carry an id and no
+   * content, and applying a field binding to those would refuse them.
+   *
+   * Absent → the binding applies to every gated action under the profile.
+   */
+  appliesTo?: string[];
 }
 
 /**
@@ -370,6 +412,44 @@ export interface AgentProfile {
   version: string;
   description: string;
 
+  /**
+   * One line on what this version changed and why it matters to the person
+   * granting authority — written for them, not for a changelog.
+   *
+   * A grant pins the profile version it was signed against, so authorities
+   * issued before a newer version keep their old terms indefinitely and
+   * nothing prompts an upgrade. A version number alone does not motivate one:
+   * "email@0.4 → 0.5" says nothing, while "binds recipients, not only the
+   * message body" says what the older grant is not protecting.
+   *
+   * Belongs on the profile because the profile is what changed; a UI cannot
+   * know why 0.5 exists. Absent → surfaces show the version alone.
+   */
+  whatsNew?: string;
+
+  /**
+   * Whether receipts under this profile may be looked up BY THEIR CONTENT — a
+   * verifier holding the content supplies its hash and learns which receipts
+   * bind it, without needing a receipt id.
+   *
+   * OFF unless declared, and that default is the point. The lookup is a
+   * confirmation oracle: given a guess at the content it says whether that
+   * content was authorized. Where the bound content has low entropy this is
+   * disclosure, not verification — guessing a message body is hopeless,
+   * guessing `production` takes a second. It is the same enumeration hazard
+   * recorded for per-field commitments, arriving from the other direction.
+   *
+   * Enable only when the bound content is unguessable enough that producing it
+   * is equivalent to already having it: prose, an artifact URL, a whole record
+   * payload. Never for a binding over a short value drawn from a small set.
+   *
+   * Why it must exist at all: most consequential actions cannot carry their
+   * receipt id. A released build was built before the receipt existed, a
+   * content-addressed artifact would change identity if the id were added, and
+   * a forwarded message has usually lost the footer that carried it.
+   */
+  receipt_lookup?: boolean;
+
   /**
    * v0.3 frame schema (deprecated, kept for backward compat).
    * Used when boundsSchema is not present.

package/node_modules/jose/dist/webapi/jwe/general/decrypt.js

@@ -21,6 +21,14 @@ export async function generalDecrypt(jwe, key, options) {
     catch {
         throw new JWEDecryptionFailed();
     }
+    if (jwe.recipients.length > 1) {
+        for (const { header } of jwe.recipients) {
+            const alg = token[0]?.alg ?? header?.alg ?? jwe.unprotected?.alg;
+            if (alg === 'dir' || alg === 'ECDH-ES') {
+                throw new JWEInvalid(`"${alg}" alg may only have a single recipient`);
+            }
+        }
+    }
     for (const recipient of jwe.recipients) {
         try {
             const flattened = {

package/node_modules/jose/dist/webapi/jwe/general/encrypt.js

@@ -125,7 +125,7 @@ export class GeneralEncrypt {
             inputs.push(input);
             checked.push(headers);
             if (headers[1] === 'dir' || headers[1] === 'ECDH-ES') {
-                throw new JWEInvalid('"dir" and "ECDH-ES" alg may only be used with a single recipient');
+                throw new JWEInvalid(`"${headers[1]}" alg may only have a single recipient`);
             }
             if (!enc) {
                 enc = headers[2];

package/node_modules/jose/dist/webapi/jwks/local.js

@@ -1,9 +1,9 @@
 import { jwkToKey } from '../lib/jwk_to_key.js';
-import { maybeJWSAlgorithm } from '../lib/jws_algorithms.js';
+import { JWS } from '../lib/jws_algorithms.js';
 import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
 import { isObject } from '../lib/type_checks.js';
 function signatureAlgorithm(alg) {
-    const entry = typeof alg === 'string' ? maybeJWSAlgorithm(alg) : undefined;
+    const entry = typeof alg === 'string' ? JWS[alg] : undefined;
     if (!entry || entry.secret) {
         throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
     }
@@ -58,7 +58,7 @@ class LocalJWKSetImpl {
     }
 }
 async function importWithAlgCache(cache, jwk, entry) {
-    const cached = cache.get(jwk) || cache.set(jwk, {}).get(jwk);
+    const cached = cache.get(jwk) || cache.set(jwk, { __proto__: null }).get(jwk);
     if (cached[entry.alg] === undefined) {
         const key = await jwkToKey(entry, { ...jwk, alg: entry.alg, ext: true });
         if (key.type !== 'public') {

package/node_modules/jose/dist/webapi/jwks/remote.js

@@ -9,7 +9,7 @@ function isCloudflareWorkers() {
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
     const NAME = 'jose';
-    const VERSION = 'v6.2.7';
+    const VERSION = 'v6.2.8';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 export const customFetch = Symbol();

package/node_modules/jose/dist/webapi/key/generate_key_pair.js

@@ -1,5 +1,5 @@
 import { JOSENotSupported } from '../util/errors.js';
-import { keyAlgorithm } from '../lib/key_algorithm.js';
+import { keyAlgorithm, unsupportedAlg, algArgument } from '../lib/key_algorithm.js';
 function getModulusLengthOption(options) {
     const modulusLength = options?.modulusLength ?? 2048;
     if (typeof modulusLength !== 'number' || modulusLength < 2048) {
@@ -8,9 +8,9 @@ function getModulusLengthOption(options) {
     return modulusLength;
 }
 export async function generateKeyPair(alg, options) {
-    const entry = keyAlgorithm(alg);
+    const entry = keyAlgorithm(alg, algArgument);
     if (entry.secret) {
-        throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+        unsupportedAlg(algArgument);
     }
     let algorithm;
     if (entry.resolve) {

package/node_modules/jose/dist/webapi/key/generate_secret.js

@@ -1,4 +1,4 @@
-import { JOSENotSupported } from '../util/errors.js';
+import { unsupportedAlg, algArgument } from '../lib/key_algorithm.js';
 export async function generateSecret(alg, options) {
     let length;
     let algorithm;
@@ -34,7 +34,7 @@ export async function generateSecret(alg, options) {
             keyUsages = ['encrypt', 'decrypt'];
             break;
         default:
-            throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+            unsupportedAlg(algArgument);
     }
     return crypto.subtle.generateKey(algorithm, options?.extractable ?? false, keyUsages);
 }

package/node_modules/jose/dist/webapi/lib/asn1.js

@@ -1,7 +1,7 @@
 import { invalidKeyInput } from './invalid_key_input.js';
 import { encodeBase64, decodeBase64 } from '../lib/base64.js';
 import { JOSENotSupported } from '../util/errors.js';
-import { keyAlgorithm } from './key_algorithm.js';
+import { keyAlgorithm, unsupportedAlg, algArgument } from './key_algorithm.js';
 import { isCryptoKey, isKeyObject } from './is_key_like.js';
 const formatPEM = (b64, descriptor) => {
     const newlined = (b64.match(/.{1,64}/g) || []).join('\n');
@@ -112,9 +112,9 @@ const parseECAlgorithmIdentifier = (state) => {
     throw new Error('Unsupported named curve');
 };
 const genericImport = async (keyFormat, keyData, alg, options) => {
-    const entry = keyAlgorithm(alg);
+    const entry = keyAlgorithm(alg, algArgument);
     if (entry.secret) {
-        throw new JOSENotSupported('Invalid or unsupported "alg" (Algorithm) value');
+        unsupportedAlg(algArgument);
     }
     const isPublic = keyFormat === 'spki';
     let algorithm;