unjwt 0.7.0 → 0.7.2

package/dist/_chunks/index.d.mts

@@ -27,8 +27,12 @@ type JWKLookupFunctionHeader = {
 *
 * Returning a `string` is meaningful for JWE only (PBES2 password); for JWS
 * a string return is encoded to bytes and used as a raw symmetric key.
+*
+* The optional `TReturn` generic lets callers who always hand back a specific
+* key shape (e.g. a `JWK_EC_Public<"ES256">`) preserve that narrowing all the
+* way into the `verify` / `decrypt` key resolution path.
 */
-type JWKLookupFunction = (header: JWKLookupFunctionHeader, token: string) => CryptoKey | JWK | JWKSet | string | Uint8Array<ArrayBuffer> | Promise<CryptoKey | JWK | JWKSet | string | Uint8Array<ArrayBuffer>>;
+type JWKLookupFunction<TReturn = CryptoKey | JWK | JWKSet | string | Uint8Array<ArrayBuffer>> = (header: JWKLookupFunctionHeader, token: string) => TReturn | Promise<TReturn>;
 /**
 * Interface for custom JWK import cache implementations.
 *
@@ -62,7 +66,12 @@ type GenerateKeyAlgorithm = Exclude<JWKAlgorithm, "none" | "dir" | JWK_PBES2>;
 interface GenerateKeyOptions {
   /** Key usages for the generated key(s). Note: For composite keys (CBC), default usages are applied separately. */
   keyUsage?: KeyUsage[];
-  /** Mark the key(s) as extractable. Defaults to true. */
+  /**
+  * Mark the key(s) as extractable. Defaults to true. Ignored when `toJWK` is set —
+  * the JWK output requires exporting the intermediate key. For long-lived asymmetric
+  * private keys that should never leave the runtime, prefer `false` (and omit `toJWK`):
+  * the key still signs/decrypts but its material cannot be exported.
+  */
   extractable?: boolean;
   /** RSA modulus length. Defaults to 2048. */
   modulusLength?: number;
@@ -77,25 +86,10 @@ interface GenerateKeyOptions {
   */
   toJWK?: boolean;
 }
-type GenerateKeyReturnJWK<TAlg extends GenerateKeyAlgorithm> = TAlg extends JWK_Asymmetric_Algorithm ? TAlg extends JWK_RSA_SIGN | JWK_RSA_PSS | JWK_RSA_ENC ? {
-  privateKey: JWK_RSA_Private;
-  publicKey: JWK_RSA_Public;
-} : TAlg extends JWK_ECDSA ? {
-  privateKey: JWK_EC_Private;
-  publicKey: JWK_EC_Public;
-} : TAlg extends JWK_ECDH_ES ? {
-  privateKey: JWK_EC_Private;
-  publicKey: JWK_EC_Public;
-} | {
-  privateKey: JWK_OKP_Private;
-  publicKey: JWK_OKP_Public;
-} : TAlg extends JWK_OKP_SIGN ? {
-  privateKey: JWK_OKP_Private;
-  publicKey: JWK_OKP_Public;
-} : never : TAlg extends JWK_AES_CBC_HMAC | JWK_Symmetric_Algorithm ? JWK_oct : never;
+type GenerateKeyReturnJWK<TAlg extends GenerateKeyAlgorithm> = TAlg extends JWK_Asymmetric_Algorithm ? JWK_Pair<TAlg> : TAlg extends JWK_AES_CBC_HMAC | JWK_Symmetric_Algorithm ? JWK_oct<TAlg> : never;
 type GenerateKeyReturnCrypto<TAlg extends GenerateKeyAlgorithm> = TAlg extends JWK_AES_CBC_HMAC ? Uint8Array<ArrayBuffer> : TAlg extends JWK_Asymmetric_Algorithm ? CryptoKeyPair : CryptoKey;
 type GenerateKeyReturn<TAlg extends GenerateKeyAlgorithm, TOptions extends GenerateKeyOptions> = TOptions["toJWK"] extends true ? GenerateKeyReturnJWK<TAlg> : GenerateKeyReturnCrypto<TAlg>;
-type GenerateJWKOptions = Omit<GenerateKeyOptions, "toJWK">;
+type GenerateJWKOptions = Omit<GenerateKeyOptions, "toJWK" | "extractable">;
 type GenerateJWKReturn<TAlg extends GenerateKeyAlgorithm> = GenerateKeyReturnJWK<TAlg>;
 /** Options for the deriveKeyFromPassword function. */
 interface DeriveKeyOptions {
@@ -105,7 +99,7 @@ interface DeriveKeyOptions {
   iterations: number;
   /** Key usages for the derived key. Defaults to ["wrapKey", "unwrapKey"]. */
   keyUsage?: KeyUsage[];
-  /** Mark the derived key as extractable. Defaults to false. */
+  /** Mark the derived key as extractable. Defaults to false. Ignored when `toJWK` is set — the JWK output requires exporting the derived key. */
   extractable?: boolean;
   /**
   * Export the derived key as JWK_oct. When `true`, returns the derived key in
@@ -114,12 +108,38 @@ interface DeriveKeyOptions {
   */
   toJWK?: boolean;
 }
-type DeriveKeyReturn<TOptions extends DeriveKeyOptions> = TOptions["toJWK"] extends true ? JWK_oct : TOptions["toJWK"] extends object ? JWK_oct : CryptoKey;
+/** PBES2 → AES-KW alg that ends up stamped on the derived JWK's `alg`. */
+type DerivedJWKAlg<TAlg extends JWK_PBES2> = TAlg extends "PBES2-HS256+A128KW" ? "A128KW" : TAlg extends "PBES2-HS384+A192KW" ? "A192KW" : TAlg extends "PBES2-HS512+A256KW" ? "A256KW" : JWK_AES_KW;
+type DeriveKeyReturn<TOptions extends DeriveKeyOptions, TAlg extends JWK_PBES2 = JWK_PBES2> = TOptions["toJWK"] extends true ? JWK_oct<DerivedJWKAlg<TAlg>> : TOptions["toJWK"] extends object ? JWK_oct<DerivedJWKAlg<TAlg>> : CryptoKey;
 type KeyManagementAlgorithm = JWK_RSA_ENC | JWK_AES_KW | JWK_AES_GCM | JWK_AES_GCM_KW | JWK_PBES2 | JWK_ECDH_ES | "dir";
 type ContentEncryptionAlgorithm = JWK_AES_GCM | JWK_AES_CBC_HMAC;
+/**
+* Keys admissible as the `wrappingKey` argument of {@link wrapKey}, narrowed
+* by the key management algorithm. Mirrors the runtime branches in
+* `jwk.wrapKey` and the inference in `inferJWEAllowedAlgorithms`.
+*
+* - `dir` accepts any symmetric JWK (the key _is_ the CEK).
+* - AES-GCMKW tolerates a JWK whose `alg` is the bare `A*GCM` counterpart —
+*   matches the `jweAlgsFromOctJWK` aliasing rule.
+*/
+type WrappingKeyFor<A extends KeyManagementAlgorithm> = A extends JWK_RSA_ENC ? CryptoKey | JWK_RSA_Public<A> : A extends JWK_ECDH_ES ? CryptoKey | JWK_EC_Public<A> | JWK_OKP_Public<A> : A extends JWK_PBES2 ? string | Uint8Array<ArrayBuffer> | JWK_oct<A> : A extends JWK_AES_KW ? CryptoKey | JWK_oct<A> : A extends JWK_AES_GCM_KW ? CryptoKey | JWK_oct<A | `A${"128" | "192" | "256"}GCM`> : A extends "dir" ? CryptoKey | JWK_oct | Uint8Array<ArrayBuffer> : never;
+/**
+* Keys admissible as the `unwrappingKey` argument of {@link unwrapKey}.
+* The private-side counterpart of {@link WrappingKeyFor} — symmetric branches
+* are identical; asymmetric branches use the `_Private` variants.
+*/
+type UnwrappingKeyFor<A extends KeyManagementAlgorithm> = A extends JWK_RSA_ENC ? CryptoKey | JWK_RSA_Private<A> : A extends JWK_ECDH_ES ? CryptoKey | JWK_EC_Private<A> | JWK_OKP_Private<A> : A extends JWK_PBES2 ? string | Uint8Array<ArrayBuffer> | JWK_oct<A> : A extends JWK_AES_KW ? CryptoKey | JWK_oct<A> : A extends JWK_AES_GCM_KW ? CryptoKey | JWK_oct<A | `A${"128" | "192" | "256"}GCM`> : A extends "dir" ? CryptoKey | JWK_oct | Uint8Array<ArrayBuffer> : never;
 /** Options for the wrapKey function. */
 interface WrapKeyOptions {
-  /** Initialization Vector for AES-GCMKW. Generated if not provided. */
+  /**
+  * Initialization Vector for AES-GCMKW. A fresh random IV is generated when
+  * not provided — production code should always omit this option.
+  *
+  * **Never reuse an IV and never derive it from external input.** A single
+  * IV reused under the same wrapping key breaks AES-GCM entirely (plaintext
+  * recovery and forgery). Provided only for tests and reproduction of known
+  * vectors in security research.
+  */
   iv?: Uint8Array<ArrayBuffer>;
   /** PBES2 Salt value (p2s). Required for PBES2 algorithms. */
   p2s?: Uint8Array<ArrayBuffer>;
@@ -211,8 +231,15 @@ interface UnwrapKeyOptions {
 * Copyright (c) 2018 Filip Skokan.
 * LICENSE: https://github.com/panva/jose/blob/v6.0.10/LICENSE.md
 */
-/** Generic JSON Web Key Parameters. */
-interface JWKParameters {
+/**
+* Generic JSON Web Key Parameters.
+*
+* The `Alg` type parameter constrains the JWK's `alg` field. Each concrete JWK
+* interface below tightens `Alg` to the algorithm family admissible for that key
+* type — e.g. a `JWK_oct<JWK_HMAC>` can only hold `"HS256" | "HS384" | "HS512"`
+* in `alg`.
+*/
+interface JWKParameters<Alg extends string = string> {
   /** JWK "kty" (Key Type) Parameter */
   kty: string;
   /**
@@ -220,7 +247,7 @@ interface JWKParameters {
   *
   * @see {@link https://github.com/panva/jose/issues/210 Algorithm Key Requirements}
   */
-  alg?: string;
+  alg?: Alg;
   /** JWK "key_ops" (Key Operations) Parameter */
   key_ops?: KeyUsage[];
   /** JWK "ext" (Extractable) Parameter */
@@ -245,7 +272,7 @@ interface JWKParameters {
   enc?: ContentEncryptionAlgorithm;
 }
 /** Public EC JSON Web Keys */
-interface JWK_EC_Public extends JWKParameters {
+interface JWK_EC_Public<Alg extends JWK_ECDSA | JWK_ECDH_ES | (string & {}) = string> extends JWKParameters<Alg> {
   /** EC JWK "kty" (Key Type) Parameter */
   kty: "EC";
   /** EC JWK "crv" (Curve) Parameter */
@@ -256,14 +283,14 @@ interface JWK_EC_Public extends JWKParameters {
   y: string;
 }
 /** Private EC JSON Web Keys */
-interface JWK_EC_Private extends JWK_EC_Public {
+interface JWK_EC_Private<Alg extends JWK_ECDSA | JWK_ECDH_ES | (string & {}) = string> extends JWK_EC_Public<Alg> {
   /** EC JWK "d" (ECC Private Key) Parameter */
   d: string;
 }
 /** EC JSON Web Keys */
-type JWK_EC = JWK_EC_Public | JWK_EC_Private;
+type JWK_EC<Alg extends JWK_ECDSA | JWK_ECDH_ES | (string & {}) = string> = JWK_EC_Public<Alg> | JWK_EC_Private<Alg>;
 /** Public RSA JSON Web Keys */
-interface JWK_RSA_Public extends JWKParameters {
+interface JWK_RSA_Public<Alg extends JWK_RSA_SIGN | JWK_RSA_PSS | JWK_RSA_ENC | (string & {}) = string> extends JWKParameters<Alg> {
   /** RSA JWK "kty" (Key Type) Parameter */
   kty: "RSA";
   /** RSA JWK "e" (Exponent) Parameter */
@@ -273,7 +300,7 @@ interface JWK_RSA_Public extends JWKParameters {
   oth?: RsaOtherPrimesInfo[];
 }
 /** Private RSA JSON Web Keys */
-interface JWK_RSA_Private extends JWK_RSA_Public {
+interface JWK_RSA_Private<Alg extends JWK_RSA_SIGN | JWK_RSA_PSS | JWK_RSA_ENC | (string & {}) = string> extends JWK_RSA_Public<Alg> {
   /** RSA JWK "d" (Private Exponent) Parameter */
   d: string;
   /** RSA JWK "dp" (First Factor CRT Exponent) Parameter */
@@ -288,9 +315,9 @@ interface JWK_RSA_Private extends JWK_RSA_Public {
   qi: string;
 }
 /** RSA JSON Web Keys */
-type JWK_RSA = JWK_RSA_Public | JWK_RSA_Private;
+type JWK_RSA<Alg extends JWK_RSA_SIGN | JWK_RSA_PSS | JWK_RSA_ENC | (string & {}) = string> = JWK_RSA_Public<Alg> | JWK_RSA_Private<Alg>;
 /** Public ED JSON Web Keys */
-interface JWK_OKP_Public extends JWKParameters {
+interface JWK_OKP_Public<Alg extends JWK_OKP_SIGN | JWK_ECDH_ES | (string & {}) = string> extends JWKParameters<Alg> {
   /** ED JWK "kty" (Key Type) Parameter */
   kty: "OKP";
   /** ED JWK "crv" (Curve) Parameter */
@@ -299,48 +326,78 @@ interface JWK_OKP_Public extends JWKParameters {
   x: string;
 }
 /** Private ED JSON Web Keys */
-interface JWK_OKP_Private extends JWK_OKP_Public {
+interface JWK_OKP_Private<Alg extends JWK_OKP_SIGN | JWK_ECDH_ES | (string & {}) = string> extends JWK_OKP_Public<Alg> {
   /** ED JWK "d" (Private Key) Parameter */
   d: string;
 }
 /** OKP JSON Web Keys */
-type JWK_OKP = JWK_OKP_Public | JWK_OKP_Private;
+type JWK_OKP<Alg extends JWK_OKP_SIGN | JWK_ECDH_ES | (string & {}) = string> = JWK_OKP_Public<Alg> | JWK_OKP_Private<Alg>;
 /** oct JSON Web Keys */
-interface JWK_oct extends JWKParameters {
+interface JWK_oct<Alg extends JWK_HMAC | JWK_AES_KW | JWK_AES_GCM | JWK_AES_GCM_KW | JWK_AES_CBC_HMAC | JWK_PBES2 | "dir" | (string & {}) = string> extends JWKParameters<Alg> {
   /** Oct JWK "k" (Key Value) Parameter */
   k: string;
 }
 /** Symmetric JSON Web Keys */
-type JWK_Symmetric = JWK_oct;
+type JWK_Symmetric<Alg extends JWK_HMAC | JWK_AES_KW | JWK_AES_GCM | JWK_AES_GCM_KW | JWK_AES_CBC_HMAC | JWK_PBES2 | "dir" | (string & {}) = string> = JWK_oct<Alg>;
 /** Asymmetric JSON Web Keys */
-type JWK_Asymmetric = JWK_RSA | JWK_EC | JWK_OKP;
+type JWK_Asymmetric<Alg extends string = string> = JWK_RSA<Alg> | JWK_EC<Alg> | JWK_OKP<Alg>;
 /** Public JSON Web Keys */
-type JWK_Public = JWK_RSA_Public | JWK_EC_Public | JWK_OKP_Public;
+type JWK_Public<Alg extends string = string> = JWK_RSA_Public<Alg> | JWK_EC_Public<Alg> | JWK_OKP_Public<Alg>;
 /** Private JSON Web Keys */
-type JWK_Private = JWK_RSA_Private | JWK_EC_Private | JWK_OKP_Private;
+type JWK_Private<Alg extends string = string> = JWK_RSA_Private<Alg> | JWK_EC_Private<Alg> | JWK_OKP_Private<Alg>;
 /**
 * JSON Web Key ({@link https://www.rfc-editor.org/rfc/rfc7517 JWK}). "RSA", "EC", "OKP" and "oct" key types are supported.
 */
-type JWK = JWK_oct | JWK_RSA | JWK_EC | JWK_OKP;
+type JWK<Alg extends string = string> = JWK_oct<Alg> | JWK_RSA<Alg> | JWK_EC<Alg> | JWK_OKP<Alg>;
 /**
-* A pair of public and private JSON Web Keys.
+* A pair of public and private JSON Web Keys, narrowed by `Alg` when that
+* uniquely identifies the key family:
+*
+* - `JWK_Pair<"RS256">` → RSA pair only
+* - `JWK_Pair<"ES256">` → EC pair only
+* - `JWK_Pair<"ECDH-ES+A256KW">` → EC pair **or** OKP pair (curve decides at runtime)
+* - `JWK_Pair<"Ed25519">` / `JWK_Pair<"EdDSA">` → OKP pair only
+*
+* The final branch is a generic fallback (`Alg = string`, or any custom /
+* forward-compat algorithm that doesn't match a known family) — it yields
+* the permissive three-branch union.
 */
-type JWK_Pair = {
-  publicKey: JWK_RSA_Public;
-  privateKey: JWK_RSA_Private;
+type JWK_Pair<Alg extends string = string> = Alg extends JWK_RSA_SIGN | JWK_RSA_PSS | JWK_RSA_ENC ? {
+  publicKey: JWK_RSA_Public<Alg>;
+  privateKey: JWK_RSA_Private<Alg>;
+} : Alg extends JWK_ECDSA ? {
+  publicKey: JWK_EC_Public<Alg>;
+  privateKey: JWK_EC_Private<Alg>;
+} : Alg extends JWK_ECDH_ES ? {
+  publicKey: JWK_EC_Public<Alg>;
+  privateKey: JWK_EC_Private<Alg>;
 } | {
-  publicKey: JWK_EC_Public;
-  privateKey: JWK_EC_Private;
+  publicKey: JWK_OKP_Public<Alg>;
+  privateKey: JWK_OKP_Private<Alg>;
+} : Alg extends JWK_OKP_SIGN ? {
+  publicKey: JWK_OKP_Public<Alg>;
+  privateKey: JWK_OKP_Private<Alg>;
+} : {
+  publicKey: JWK_RSA_Public<Alg>;
+  privateKey: JWK_RSA_Private<Alg>;
 } | {
-  publicKey: JWK_OKP_Public;
-  privateKey: JWK_OKP_Private;
+  publicKey: JWK_EC_Public<Alg>;
+  privateKey: JWK_EC_Private<Alg>;
+} | {
+  publicKey: JWK_OKP_Public<Alg>;
+  privateKey: JWK_OKP_Private<Alg>;
 };
 /**
 * JSON Web Key Set ({@link https://www.rfc-editor.org/rfc/rfc7517 JWK Set}). "RSA", "EC" and "oct" key types are supported.
+*
+* The optional `T` generic preserves the precise key tuple when constructed
+* in TS — e.g. `JWKSet<[JWK_oct<"HS256">, JWK_EC_Public<"ES256">]>` — while the
+* default `JWK[]` keeps the permissive behavior expected for JWKS fetched from
+* external sources (runtime trials each candidate).
 */
-interface JWKSet {
+interface JWKSet<T extends readonly JWK[] = JWK[]> {
   /** JWK Set "keys" Parameter */
-  keys: JWK[];
+  keys: T;
   [parameter: string]: unknown;
 }
 /** JWK Key Algorithms */
@@ -512,6 +569,32 @@ declare function isJWTError(error: unknown): error is JWTError;
 type StrictOmit<T, K extends keyof T | (string & {}) | (number & {}) | (symbol & {})> = { [P in keyof T as P extends K ? never : P]: T[P] };
 /** JWS Signing Algorithm Identifier. */
 type JWSAlgorithm = JWK_HMAC | JWK_RSA_SIGN | JWK_RSA_PSS | JWK_ECDSA | JWK_OKP_SIGN;
+/**
+* Asymmetric private JWKs admissible as a signing key. RSA keys carry a
+* signing `alg` (RS* or PS*); EC keys carry an ECDSA alg; OKP keys carry an Ed
+* signing alg.
+*/
+type JWSAsymmetricPrivateJWK = JWK_RSA_Private<JWK_RSA_SIGN | JWK_RSA_PSS> | JWK_EC_Private<JWK_ECDSA> | JWK_OKP_Private<JWK_OKP_SIGN>;
+/**
+* Asymmetric public JWKs admissible as a verification key. RSA keys carry a
+* signing `alg` (RS* or PS*); EC keys carry an ECDSA alg; OKP keys carry an Ed
+* signing alg.
+*/
+type JWSAsymmetricPublicJWK = JWK_RSA_Public<JWK_RSA_SIGN | JWK_RSA_PSS> | JWK_EC_Public<JWK_ECDSA> | JWK_OKP_Public<JWK_OKP_SIGN>;
+/**
+* JWKs admissible as the `key` argument of {@link sign}. HMAC oct keys carry a
+* {@link JWK_HMAC} alg; asymmetric private keys carry their family's signing alg.
+* A JWK whose `alg` points at a non-signing family (e.g. `"RSA-OAEP"`) is
+* rejected at the type level.
+*/
+type JWSSignJWK = JWK_oct<JWK_HMAC> | JWSAsymmetricPrivateJWK;
+/**
+* JWKs admissible as a `key` for {@link verify}. HMAC oct keys carry a
+* {@link JWK_HMAC} alg; asymmetric public keys carry their family's signing alg.
+* A JWK whose `alg` points at a non-signing family (e.g. `"RSA-OAEP"`) is
+* rejected at the type level.
+*/
+type JWSVerifyJWK = JWK_oct<JWK_HMAC> | JWSAsymmetricPublicJWK;
 /** Recognized JWS Header Parameters, any other Header Members may also be present. */
 interface JWSHeaderParameters extends JoseHeaderParameters {
   /** JWS "alg" (Algorithm) Header Parameter */
@@ -584,7 +667,12 @@ interface JWSVerifyResult<T extends JOSEPayload = JOSEPayload> {
 }
 /** Options for JWS verification */
 interface JWSVerifyOptions extends JWTClaimValidationOptions {
-  /** List of allowed algorithms. If provided, the JWS `alg` must be in this list. */
+  /**
+  * List of allowed algorithms. If provided, the JWS `alg` must be in this list.
+  * When omitted, the allowlist is inferred from the key's shape — keys without
+  * usable metadata (raw `Uint8Array`/string, alg-less JWKs, lookup functions)
+  * cannot be inferred and require this option explicitly.
+  */
   algorithms?: JWSAlgorithm[];
   /** If true, forces the payload to be returned as a Uint8Array, otherwise type is inferred. */
   forceUint8Array?: boolean;
@@ -635,7 +723,7 @@ type JWSGeneralSignature = Pick<JWSFlattenedSerialization, "protected" | "header
 */
 interface JWSMultiSigner {
   /** Signing key (JWK-first; `alg` inferred from `key.alg`). */
-  key: JWK;
+  key: JWSSignJWK;
   /**
   * Extra per-signer JWS Protected Header parameters (RFC 7515 §7.2.1).
   * `alg` is always derived from the JWK and cannot be set here. `b64`
@@ -710,6 +798,33 @@ type JWSMultiVerifyOutcome<T extends JOSEPayload = JOSEPayload> = {
   protectedHeader?: JWSProtectedHeader;
   signerHeader?: JWSHeaderParameters;
 };
+/**
+* Algorithms admissible on an `oct` JWK used for JWE key management. Mirrors
+* the runtime aliasing table in `jweAlgsFromOctJWK` — HMAC algs intentionally
+* excluded (they don't resolve to any JWE `alg`).
+*/
+type _JWEOctAlg = JWK_AES_KW | JWK_AES_GCM | JWK_AES_GCM_KW | JWK_AES_CBC_HMAC | JWK_PBES2 | "dir";
+/**
+* Asymmetric public JWKs admissible for JWE encryption. RSA keys carry an
+* RSA-OAEP alg; EC/OKP keys carry an ECDH-ES alg.
+*/
+type JWEAsymmetricPublicJWK = JWK_RSA_Public<JWK_RSA_ENC> | JWK_EC_Public<JWK_ECDH_ES> | JWK_OKP_Public<JWK_ECDH_ES>;
+/**
+* Asymmetric private JWKs admissible for JWE decryption. RSA keys carry an
+* RSA-OAEP alg; EC/OKP keys carry an ECDH-ES alg.
+*/
+type JWEAsymmetricPrivateJWK = JWK_RSA_Private<JWK_RSA_ENC> | JWK_EC_Private<JWK_ECDH_ES> | JWK_OKP_Private<JWK_ECDH_ES>;
+/**
+* JWKs admissible as the `key` argument of {@link encrypt}. A JWK whose `alg`
+* points at a non-JWE family (e.g. `"HS256"`, `"RS256"`) is rejected at the
+* type level.
+*/
+type JWEEncryptJWK = JWK_oct<_JWEOctAlg> | JWEAsymmetricPublicJWK;
+/**
+* JWKs admissible as a `key` for {@link decrypt}. A JWK whose `alg` points at
+* a non-JWE family (e.g. `"HS256"`, `"RS256"`) is rejected at the type level.
+*/
+type JWEDecryptJWK = JWK_oct<_JWEOctAlg> | JWEAsymmetricPrivateJWK;
 /** Recognized JWE Header Parameters, any other Header Members may also be present. */
 interface JWEHeaderParameters extends JoseHeaderParameters {
   /**
@@ -852,7 +967,12 @@ interface JWEEncryptOptions {
 * JWE (JSON Web Encryption) decryption options
 */
 interface JWEDecryptOptions extends JWTClaimValidationOptions {
-  /** A list of allowed JWE "alg" (Algorithm) Header Parameter values for key management. */
+  /**
+  * A list of allowed JWE "alg" (Algorithm) Header Parameter values for key management.
+  * When omitted, the allowlist is inferred from the key's shape — password strings
+  * and raw `Uint8Array` keys infer the PBES2 family plus `dir`; lookup functions
+  * cannot be inferred and require this option explicitly.
+  */
   algorithms?: KeyManagementAlgorithm[];
   /** A list of allowed JWE "enc" (Encryption Algorithm) Header Parameter values for content encryption. */
   encryptionAlgorithms?: ContentEncryptionAlgorithm[];
@@ -946,7 +1066,7 @@ interface JWEGeneralRecipient {
 */
 interface JWEMultiRecipient {
   /** Recipient key (JWK-first; `alg` inferred if absent from JWK). */
-  key: JWK;
+  key: JWEEncryptJWK;
   /**
   * Extra per-recipient JWE Unprotected Header parameters (RFC 7516 §7.2.1).
   * Excludes fields the library writes automatically: `alg`, `enc`, `iv`,
@@ -1019,4 +1139,4 @@ type ExpiresIn = Duration;
 type NotBeforeIn = Duration;
 /** Duration for `maxTokenAge` validation on {@link verify} / {@link decrypt}. */
 type MaxTokenAge = Duration;
-export { JWKAlgorithm as $, JWSSignOptions as A, JWK_RSA_Public as At, JWTClaimValidationOptions as B, JWSMultiSignOptions as C, JWK_Pair as Ct, JWSMultiVerifyOutcome as D, JWK_RSA_ENC as Dt, JWSMultiVerifyOptions as E, JWK_RSA as Et, JWTErrorCauseMap as F, KeyManagementAlgorithm as Ft, DeriveKeyOptions as G, JoseHeaderParameters as H, JWTErrorCode as I, UnwrapKeyOptions as It, GenerateJWKReturn as J, DeriveKeyReturn as K, isJWTError as L, WrapKeyOptions as Lt, JWSVerifyResult as M, JWK_Symmetric as Mt, StrictOmit as N, JWK_Symmetric_Algorithm as Nt, JWSMultiVerifyResult as O, JWK_RSA_PSS as Ot, JWTError as P, JWK_oct as Pt, JWK as Q, JOSEPayload as R, WrapKeyResult as Rt, JWSHeaderParameters as S, JWK_PBES2 as St, JWSMultiVerifyAllOptions as T, JWK_Public as Tt, CompositeKey as U, JWTClaims as V, ContentEncryptionAlgorithm as W, GenerateKeyOptions as X, GenerateKeyAlgorithm as Y, GenerateKeyReturn as Z, JWEProtectedHeader as _, JWK_HMAC as _t, JWEDecryptOptions as a, JWKSet as at, JWSGeneralSerialization as b, JWK_OKP_Public as bt, JWEFlattenedSerialization as c, JWK_AES_GCM_KW as ct, JWEHeaderParameters as d, JWK_Asymmetric_Algorithm as dt, JWKCacheAdapter as et, JWEKeyManagementHeaderParameters as f, JWK_EC as ft, JWEMultiRecipient as g, JWK_EC_Public as gt, JWEMultiEncryptOptions as h, JWK_EC_Private as ht, NotBeforeIn as i, JWKParameters as it, JWSVerifyOptions as j, JWK_RSA_SIGN as jt, JWSProtectedHeader as k, JWK_RSA_Private as kt, JWEGeneralRecipient as l, JWK_AES_KW as lt, JWEMultiDecryptResult as m, JWK_ECDSA as mt, ExpiresIn as n, JWKLookupFunctionHeader as nt, JWEDecryptResult as o, JWK_AES_CBC_HMAC as ot, JWEMultiDecryptOptions as p, JWK_ECDH_ES as pt, GenerateJWKOptions as q, MaxTokenAge as r, JWKPEMAlgorithm as rt, JWEEncryptOptions as s, JWK_AES_GCM as st, Duration as t, JWKLookupFunction as tt, JWEGeneralSerialization as u, JWK_Asymmetric as ut, JWSAlgorithm as v, JWK_OKP as vt, JWSMultiSigner as w, JWK_Private as wt, JWSGeneralSignature as x, JWK_OKP_SIGN as xt, JWSFlattenedSerialization as y, JWK_OKP_Private as yt, JWT as z };
+export { CompositeKey, ContentEncryptionAlgorithm, DeriveKeyOptions, DeriveKeyReturn, Duration, ExpiresIn, GenerateJWKOptions, GenerateJWKReturn, GenerateKeyAlgorithm, GenerateKeyOptions, GenerateKeyReturn, JOSEPayload, JWEAsymmetricPrivateJWK, JWEAsymmetricPublicJWK, JWEDecryptJWK, JWEDecryptOptions, JWEDecryptResult, JWEEncryptJWK, JWEEncryptOptions, JWEFlattenedSerialization, JWEGeneralRecipient, JWEGeneralSerialization, JWEHeaderParameters, JWEKeyManagementHeaderParameters, JWEMultiDecryptOptions, JWEMultiDecryptResult, JWEMultiEncryptOptions, JWEMultiRecipient, JWEProtectedHeader, JWK, JWKAlgorithm, JWKCacheAdapter, JWKLookupFunction, JWKLookupFunctionHeader, JWKPEMAlgorithm, JWKParameters, JWKSet, JWK_AES_CBC_HMAC, JWK_AES_GCM, JWK_AES_GCM_KW, JWK_AES_KW, JWK_Asymmetric, JWK_Asymmetric_Algorithm, JWK_EC, JWK_ECDH_ES, JWK_ECDSA, JWK_EC_Private, JWK_EC_Public, JWK_HMAC, JWK_OKP, JWK_OKP_Private, JWK_OKP_Public, JWK_OKP_SIGN, JWK_PBES2, JWK_Pair, JWK_Private, JWK_Public, JWK_RSA, JWK_RSA_ENC, JWK_RSA_PSS, JWK_RSA_Private, JWK_RSA_Public, JWK_RSA_SIGN, JWK_Symmetric, JWK_Symmetric_Algorithm, JWK_oct, JWSAlgorithm, JWSAsymmetricPrivateJWK, JWSAsymmetricPublicJWK, JWSFlattenedSerialization, JWSGeneralSerialization, JWSGeneralSignature, JWSHeaderParameters, JWSMultiSignOptions, JWSMultiSigner, JWSMultiVerifyAllOptions, JWSMultiVerifyOptions, JWSMultiVerifyOutcome, JWSMultiVerifyResult, JWSProtectedHeader, JWSSignJWK, JWSSignOptions, JWSVerifyJWK, JWSVerifyOptions, JWSVerifyResult, JWT, JWTClaimValidationOptions, JWTClaims, JWTError, JWTErrorCauseMap, JWTErrorCode, JoseHeaderParameters, KeyManagementAlgorithm, MaxTokenAge, NotBeforeIn, StrictOmit, UnwrapKeyOptions, UnwrappingKeyFor, WrapKeyOptions, WrapKeyResult, WrappingKeyFor, isJWTError };

package/dist/_chunks/jwe.d.mts

@@ -1,4 +1,4 @@
-import { Ft as KeyManagementAlgorithm, Mt as JWK_Symmetric, Q as JWK, R as JOSEPayload, W as ContentEncryptionAlgorithm, a as JWEDecryptOptions, at as JWKSet, c as JWEFlattenedSerialization, g as JWEMultiRecipient, h as JWEMultiEncryptOptions, m as JWEMultiDecryptResult, o as JWEDecryptResult, p as JWEMultiDecryptOptions, s as JWEEncryptOptions, tt as JWKLookupFunction, u as JWEGeneralSerialization, wt as JWK_Private } from "./index.mjs";
+import { ContentEncryptionAlgorithm, JOSEPayload, JWEDecryptJWK, JWEDecryptOptions, JWEDecryptResult, JWEEncryptJWK, JWEEncryptOptions, JWEFlattenedSerialization, JWEGeneralSerialization, JWEMultiDecryptOptions, JWEMultiDecryptResult, JWEMultiEncryptOptions, JWEMultiRecipient, JWKLookupFunction, JWKSet, KeyManagementAlgorithm } from "./index.mjs";
 /**
 * Encrypt a payload to multiple recipients using JWE General JSON Serialization
 * (RFC 7516 §7.2.1).
@@ -29,7 +29,7 @@ declare function encryptMulti(payload: JOSEPayload, recipients: JWEMultiRecipien
 *
 * For compact (string) tokens, use {@link decrypt}.
 */
-declare function decryptMulti<T extends JOSEPayload = JOSEPayload>(jwe: JWEGeneralSerialization | JWEFlattenedSerialization, keyOrLookup: CryptoKey | JWKSet | JWK_Private | JWK_Symmetric | string | Uint8Array<ArrayBuffer> | JWKLookupFunction, options?: JWEMultiDecryptOptions): Promise<JWEMultiDecryptResult<T>>;
+declare function decryptMulti<T extends JOSEPayload = JOSEPayload>(jwe: JWEGeneralSerialization | JWEFlattenedSerialization, keyOrLookup: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWKLookupFunction, options?: JWEMultiDecryptOptions): Promise<JWEMultiDecryptResult<T>>;
 /**
 * Convert a {@link JWEGeneralSerialization} with exactly one recipient into
 * the {@link JWEFlattenedSerialization} form (RFC 7516 §7.2.2). Throws
@@ -53,8 +53,10 @@ declare function generalToFlattened(jwe: JWEGeneralSerialization): JWEFlattenedS
 * @param options JWE encryption options, including `alg` (key management algorithm) and `enc` (content encryption algorithm).
 * @returns A Promise resolving to the JWE Compact Serialization string.
 */
-declare function encrypt(payload: JOSEPayload, key: JWK | string | Uint8Array<ArrayBuffer>, options?: JWEEncryptOptions): Promise<string>;
-declare function encrypt(payload: JOSEPayload, key: CryptoKey | JWK_Symmetric | Uint8Array<ArrayBuffer>, options: JWEEncryptOptions & {
+declare function encrypt(payload: JOSEPayload, key: JWEEncryptJWK | string | Uint8Array<ArrayBuffer>, options?: JWEEncryptOptions): Promise<string>;
+declare function encrypt(payload: JOSEPayload, key: CryptoKey | Extract<JWEEncryptJWK, {
+  kty: "oct";
+}> | Uint8Array<ArrayBuffer>, options: JWEEncryptOptions & {
   alg: "dir";
   enc: ContentEncryptionAlgorithm;
 }): Promise<string>;
@@ -62,7 +64,7 @@ declare function encrypt(payload: JOSEPayload, key: CryptoKey, options: JWEEncry
   alg: KeyManagementAlgorithm;
   enc: ContentEncryptionAlgorithm;
 }): Promise<string>;
-declare function encrypt(payload: JOSEPayload, key: CryptoKey | JWK | string | Uint8Array<ArrayBuffer>, options: JWEEncryptOptions & {
+declare function encrypt(payload: JOSEPayload, key: CryptoKey | JWEEncryptJWK | string | Uint8Array<ArrayBuffer>, options: JWEEncryptOptions & {
   alg: KeyManagementAlgorithm;
   enc: ContentEncryptionAlgorithm;
 }): Promise<string>;
@@ -75,8 +77,8 @@ declare function encrypt(payload: JOSEPayload, key: CryptoKey | JWK | string | U
 * @returns A Promise resolving to an object containing the decrypted plaintext, protected header, CEK, and AAD.
 * @throws If JWE is invalid, decryption fails, or options are not met.
 */
-declare function decrypt<T extends JOSEPayload>(jwe: string, key: CryptoKey | JWKSet | JWK_Private | JWK_Symmetric | string | Uint8Array<ArrayBuffer> | JWKLookupFunction, options?: JWEDecryptOptions): Promise<JWEDecryptResult<T>>;
-declare function decrypt(jwe: string, key: CryptoKey | JWKSet | JWK_Private | JWK_Symmetric | string | Uint8Array<ArrayBuffer> | JWKLookupFunction, options: JWEDecryptOptions & {
+declare function decrypt<T extends JOSEPayload>(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWKLookupFunction, options?: JWEDecryptOptions): Promise<JWEDecryptResult<T>>;
+declare function decrypt(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWKLookupFunction, options: JWEDecryptOptions & {
   forceUint8Array: true;
 }): Promise<JWEDecryptResult<Uint8Array<ArrayBuffer>>>;
-export { generalToFlattened as a, encryptMulti as i, encrypt as n, decryptMulti as r, decrypt as t };
+export { decrypt, decryptMulti, encrypt, encryptMulti, generalToFlattened };

package/dist/_chunks/jwe.mjs

@@ -1,7 +1,7 @@
-import { D as JWTError, S as validateCriticalHeadersJWE, b as getPlaintextBytes, f as applyTypCtyDefaults, h as computeJwtTimeClaims, i as isCryptoKey, o as isJWK, s as isJWKSet, y as decodePayloadFromBytes } from "./utils.mjs";
-import { a as base64UrlEncode, i as base64UrlDecode, s as textEncoder, t as secureRandomBytes, u as sanitizeObjectCopy } from "./libs/unsecure.mjs";
-import { C as generateIV, S as generateCEK, _ as unwrapKey, b as decrypt$1, h as importKey, p as getJWKsFromSet, x as encrypt$1, y as encryptKey } from "./jwk.mjs";
-import { i as checkAlgAllowed, l as validateJwtClaimsIfJsonPayload, o as decodeProtectedHeader, r as buildJWKSetFilter, s as parseEphemeralKey, t as JWE_ALG_CTX } from "./_internal.mjs";
+import { JWTError, applyTypCtyDefaults, computeJwtTimeClaims, decodePayloadFromBytes, getPlaintextBytes, isCryptoKey, isJWK, isJWKSet, validateCriticalHeadersJWE } from "./utils.mjs";
+import { base64UrlDecode, base64UrlEncode, sanitizeObjectCopy, secureRandomBytes, textEncoder } from "./libs/unsecure.mjs";
+import { decrypt as decrypt$1, encrypt as encrypt$1, encryptKey, generateCEK, generateIV, getJWKsFromSet, importKey, unwrapKey } from "./jwk.mjs";
+import { JWE_ALG_CTX, buildJWKSetFilter, checkAlgAllowed, decodeProtectedHeader, parseEphemeralKey, validateJwtClaimsIfJsonPayload } from "./_internal.mjs";
 const DIRECT_ALGS = /* @__PURE__ */ new Set(["dir", "ECDH-ES"]);
 async function encryptMulti(payload, recipients, options = {}) {
 	if (!Array.isArray(recipients) || recipients.length === 0) throw new JWTError("encryptMulti requires at least one recipient.", "ERR_JWE_INVALID");
@@ -404,4 +404,4 @@ function _buildJWEHeader(alg, enc, key, userHeader, keyManagementParams, payload
 	header.enc = enc;
 	return applyTypCtyDefaults(header, payload);
 }
-export { generalToFlattened as a, encryptMulti as i, encrypt as n, decryptMulti as r, decrypt as t };
+export { decrypt, decryptMulti, encrypt, encryptMulti, generalToFlattened };

package/dist/_chunks/jwk.mjs

@@ -1,5 +1,5 @@
-import { D as JWTError, a as isCryptoKeyPair, i as isCryptoKey, n as concatUint8Arrays, o as isJWK, r as isAsymmetricJWK, s as isJWKSet, t as assertCryptoKey } from "./utils.mjs";
-import { a as base64UrlEncode, i as base64UrlDecode, n as base64Decode, r as base64Encode, s as textEncoder, t as secureRandomBytes, u as sanitizeObjectCopy } from "./libs/unsecure.mjs";
+import { JWTError, assertCryptoKey, concatUint8Arrays, isAsymmetricJWK, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet } from "./utils.mjs";
+import { base64Decode, base64Encode, base64UrlDecode, base64UrlEncode, sanitizeObjectCopy, secureRandomBytes, textEncoder } from "./libs/unsecure.mjs";
 async function sign(alg, key, data) {
 	checkSigCryptoKey(key, alg, "sign");
 	const signature = await crypto.subtle.sign(subtleAlgorithm(alg, key.algorithm), key, data);
@@ -151,6 +151,16 @@ function checkCEKLength(cek, expected) {
 	const actual = cek.byteLength << 3;
 	if (actual !== expected) throw new Error(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
 }
+function assertOctKeyLength(bytes, alg) {
+	if (!alg) return;
+	if (alg === "HS256" || alg === "HS384" || alg === "HS512") {
+		const minBytes = Number.parseInt(alg.slice(2), 10) >> 3;
+		if (bytes.length < minBytes) throw new JWTError(`${alg} requires a key of at least ${minBytes} bytes (got ${bytes.length})`, "ERR_JWK_INVALID");
+		return;
+	}
+	const exactBits = /^A(128|192|256)(GCM)?KW$/.test(alg) ? Number.parseInt(alg.slice(1, 4), 10) : CEK_BIT_LENGTHS[alg];
+	if (exactBits !== void 0 && bytes.length << 3 !== exactBits) throw new JWTError(`${alg} requires a key of exactly ${exactBits >> 3} bytes (got ${bytes.length})`, "ERR_JWK_INVALID");
+}
 function checkAESCryptoKey(key, alg, usage) {
 	switch (alg) {
 		case "A128GCM":
@@ -1011,7 +1021,7 @@ const getSPKI = (x509) => {
 };
 async function generateKey(alg, options = {}) {
 	const exportToJWK = options.toJWK !== void 0 && options.toJWK !== false;
-	const defaultExtractable = options.extractable !== false;
+	const defaultExtractable = exportToJWK || options.extractable !== false;
 	if (alg === "A128CBC-HS256" || alg === "A192CBC-HS384" || alg === "A256CBC-HS512") {
 		const keyBytes = secureRandomBytes(bitLengthCEK(alg) >> 3);
 		if (exportToJWK) return keyToJWK(keyBytes);
@@ -1039,7 +1049,7 @@ async function generateKey(alg, options = {}) {
 	return key;
 }
 async function generateJWK(alg, options) {
-	const { keyUsage, extractable, modulusLength, publicExponent, namedCurve, ...jwkParams } = options ?? {};
+	const { keyUsage, modulusLength, publicExponent, namedCurve, ...jwkParams } = options ?? {};
 	const kid = typeof jwkParams.kid === "string" ? jwkParams.kid : crypto.randomUUID();
 	const extraParams = {
 		...jwkParams,
@@ -1047,7 +1057,6 @@ async function generateJWK(alg, options) {
 	};
 	const result = await generateKey(alg, {
 		keyUsage,
-		extractable,
 		modulusLength,
 		publicExponent,
 		namedCurve,
@@ -1089,12 +1098,11 @@ async function deriveKeyFromPassword(password, alg, options) {
 	return derivedKey;
 }
 async function deriveJWKFromPassword(password, alg, options) {
-	const { salt, iterations, keyUsage, extractable, ...jwkParams } = options;
+	const { salt, iterations, keyUsage, ...jwkParams } = options;
 	const result = await deriveKeyFromPassword(password, alg, {
 		salt,
 		iterations,
 		keyUsage,
-		extractable,
 		toJWK: true
 	});
 	return Object.keys(jwkParams).length > 0 ? {
@@ -1131,9 +1139,16 @@ async function importKey(key, algOrOptions) {
 	}
 	if (isJWK(key)) if ("k" in key && typeof key.k === "string") {
 		const rawBytes = base64UrlDecode(key.k, { returnAs: "uint8array" });
+		assertOctKeyLength(rawBytes, key.alg || alg);
 		if (typeof algOrOptions === "object" && algOrOptions.asCryptoKey) {
 			const { algorithm, usage, extractable = false } = algOrOptions;
 			if (!algorithm || !usage) throw new JWTError("asCryptoKey option requires `algorithm` and `usage` to be provided.", "ERR_JWK_INVALID");
+			if (typeof algorithm === "object" && algorithm.name === "HMAC") {
+				const hash = algorithm.hash;
+				const hashName = typeof hash === "string" ? hash : hash?.name;
+				const minBytes = Number.parseInt(hashName?.slice(-3) ?? "", 10) / 8;
+				if (minBytes && rawBytes.length < minBytes) throw new JWTError(`HMAC with ${hashName} requires a key of at least ${minBytes} bytes (got ${rawBytes.length})`, "ERR_JWK_INVALID");
+			}
 			return crypto.subtle.importKey("raw", rawBytes, algorithm, extractable, usage);
 		}
 		return rawBytes;
@@ -1310,7 +1325,7 @@ async function unwrapKey(alg, wrappedKey, unwrappingKey, options = {}) {
 	return await crypto.subtle.importKey("raw", unwrappedCekBytes, options.unwrappedKeyAlgorithm || { name: "AES-GCM" }, defaultExtractable, options.keyUsage || ["encrypt", "decrypt"]);
 }
 async function importPEM(pem, alg, options) {
-	const extractable = options?.extractable !== false;
+	const extractable = true;
 	const pemType = options?.pemType ?? inferPEMType(pem);
 	if (!pemType) throw new JWTError("Cannot infer PEM type from the input; pass \"options.pemType\" explicitly.", "ERR_JWK_INVALID");
 	let cryptoKey;
@@ -1622,4 +1637,4 @@ function inferAesImportAlgorithm(enc, cekLengthBytes) {
 		length: bitLength
 	};
 }
-export { generateIV as C, generateCEK as S, verify as T, unwrapKey as _, deriveKeyFromPassword as a, decrypt as b, exportPEM as c, generateKey as d, getJWKFromSet as f, importPEM as g, importKey as h, deriveJWKFromPassword as i, exportToPEM as l, importFromPEM as m, clearJWKCache as n, deriveSharedSecret as o, getJWKsFromSet as p, configureJWKCache as r, exportKey as s, WeakMapJWKCache as t, generateJWK as u, wrapKey as v, sign as w, encrypt as x, encryptKey as y };
+export { WeakMapJWKCache, assertOctKeyLength, clearJWKCache, configureJWKCache, decrypt, deriveJWKFromPassword, deriveKeyFromPassword, deriveSharedSecret, encrypt, encryptKey, exportKey, exportPEM, exportToPEM, generateCEK, generateIV, generateJWK, generateKey, getJWKFromSet, getJWKsFromSet, importFromPEM, importKey, importPEM, sign, unwrapKey, verify, wrapKey };

package/dist/_chunks/jws.d.mts

@@ -1,4 +1,4 @@
-import { A as JWSSignOptions, C as JWSMultiSignOptions, D as JWSMultiVerifyOutcome, E as JWSMultiVerifyOptions, M as JWSVerifyResult, Mt as JWK_Symmetric, O as JWSMultiVerifyResult, R as JOSEPayload, T as JWSMultiVerifyAllOptions, Tt as JWK_Public, at as JWKSet, b as JWSGeneralSerialization, j as JWSVerifyOptions, tt as JWKLookupFunction, v as JWSAlgorithm, w as JWSMultiSigner, wt as JWK_Private, y as JWSFlattenedSerialization } from "./index.mjs";
+import { JOSEPayload, JWKLookupFunction, JWKSet, JWSAlgorithm, JWSFlattenedSerialization, JWSGeneralSerialization, JWSMultiSignOptions, JWSMultiSigner, JWSMultiVerifyAllOptions, JWSMultiVerifyOptions, JWSMultiVerifyOutcome, JWSMultiVerifyResult, JWSSignJWK, JWSSignOptions, JWSVerifyJWK, JWSVerifyOptions, JWSVerifyResult } from "./index.mjs";
 /**
 * Sign a payload with multiple signers using JWS General JSON Serialization
 * (RFC 7515 §7.2.1).
@@ -30,7 +30,7 @@ declare function signMulti(payload: JOSEPayload, signers: JWSMultiSigner[], opti
 *
 * For compact (string) tokens, use {@link verify}.
 */
-declare function verifyMulti<T extends JOSEPayload = JOSEPayload>(jws: JWSGeneralSerialization | JWSFlattenedSerialization, keyOrLookup: CryptoKey | JWKSet | JWK_Public | JWK_Symmetric | Uint8Array<ArrayBuffer> | JWKLookupFunction, options?: JWSMultiVerifyOptions): Promise<JWSMultiVerifyResult<T>>;
+declare function verifyMulti<T extends JOSEPayload = JOSEPayload>(jws: JWSGeneralSerialization | JWSFlattenedSerialization, keyOrLookup: CryptoKey | JWKSet | JWSVerifyJWK | Uint8Array<ArrayBuffer> | JWKLookupFunction, options?: JWSMultiVerifyOptions): Promise<JWSMultiVerifyResult<T>>;
 /**
 * Verify every signature in a JWS independently and return a per-signature
 * outcome array — the caller applies their own policy (all-must-verify,
@@ -91,7 +91,7 @@ declare function generalToFlattenedJWS(jws: JWSGeneralSerialization): JWSFlatten
 * @param options Signing options, including the algorithm (`alg`) and protected header parameters.
 * @returns A Promise resolving to the JWS Compact Serialization string.
 */
-declare function sign(payload: JOSEPayload, key: JWK_Symmetric | JWK_Private, options?: JWSSignOptions): Promise<string>;
+declare function sign(payload: JOSEPayload, key: JWSSignJWK, options?: JWSSignOptions): Promise<string>;
 declare function sign(payload: JOSEPayload, key: CryptoKey | Uint8Array<ArrayBuffer>, options: JWSSignOptions & {
   alg: JWSAlgorithm;
 }): Promise<string>;
@@ -104,8 +104,8 @@ declare function sign(payload: JOSEPayload, key: CryptoKey | Uint8Array<ArrayBuf
 * @returns A Promise resolving to an object containing the verified payload and protected header.
 * @throws If the JWS is invalid, signature verification fails, or options are not met.
 */
-declare function verify<T extends JOSEPayload>(jws: string, key: CryptoKey | JWKSet | JWK_Public | JWK_Symmetric | Uint8Array<ArrayBuffer> | JWKLookupFunction, options?: JWSVerifyOptions): Promise<JWSVerifyResult<T>>;
-declare function verify(jws: string, key: CryptoKey | JWKSet | JWK_Public | JWK_Symmetric | Uint8Array<ArrayBuffer> | JWKLookupFunction, options: JWSVerifyOptions & {
+declare function verify<T extends JOSEPayload>(jws: string, key: CryptoKey | JWKSet | JWSVerifyJWK | Uint8Array<ArrayBuffer> | JWKLookupFunction, options?: JWSVerifyOptions): Promise<JWSVerifyResult<T>>;
+declare function verify(jws: string, key: CryptoKey | JWKSet | JWSVerifyJWK | Uint8Array<ArrayBuffer> | JWKLookupFunction, options: JWSVerifyOptions & {
   forceUint8Array: true;
 }): Promise<JWSVerifyResult<Uint8Array<ArrayBuffer>>>;
-export { verifyMulti as a, signMulti as i, verify as n, verifyMultiAll as o, generalToFlattenedJWS as r, sign as t };
+export { generalToFlattenedJWS, sign, signMulti, verify, verifyMulti, verifyMultiAll };

package/dist/_chunks/jws.mjs

@@ -1,7 +1,7 @@
-import { C as validateCriticalHeadersJWS, D as JWTError, b as getPlaintextBytes, f as applyTypCtyDefaults, h as computeJwtTimeClaims, o as isJWK, s as isJWKSet } from "./utils.mjs";
-import { a as base64UrlEncode, i as base64UrlDecode, o as textDecoder, s as textEncoder, u as sanitizeObjectCopy } from "./libs/unsecure.mjs";
-import { T as verify$1, h as importKey, p as getJWKsFromSet, w as sign$1 } from "./jwk.mjs";
-import { a as decodeJWSPayload, c as resolveSigningKey, i as checkAlgAllowed, l as validateJwtClaimsIfJsonPayload, n as JWS_ALG_CTX, o as decodeProtectedHeader, r as buildJWKSetFilter } from "./_internal.mjs";
+import { JWTError, applyTypCtyDefaults, computeJwtTimeClaims, getPlaintextBytes, isJWK, isJWKSet, validateCriticalHeadersJWS } from "./utils.mjs";
+import { base64UrlDecode, base64UrlEncode, sanitizeObjectCopy, textDecoder, textEncoder } from "./libs/unsecure.mjs";
+import { getJWKsFromSet, importKey, sign as sign$1, verify as verify$1 } from "./jwk.mjs";
+import { JWS_ALG_CTX, buildJWKSetFilter, checkAlgAllowed, decodeJWSPayload, decodeProtectedHeader, resolveSigningKey, validateJwtClaimsIfJsonPayload } from "./_internal.mjs";
 async function signMulti(payload, signers, options = {}) {
 	if (!Array.isArray(signers) || signers.length === 0) throw new JWTError("signMulti requires at least one signer.", "ERR_JWS_INVALID");
 	const resolvedAlgs = signers.map((s, i) => _resolveSignerAlg(s.key, i));
@@ -346,4 +346,4 @@ function _buildJWSHeader(alg, key, userHeader, payload) {
 	if (header.b64 === true) delete header.b64;
 	return header;
 }
-export { verifyMulti as a, signMulti as i, verify as n, verifyMultiAll as o, generalToFlattenedJWS as r, sign as t };
+export { generalToFlattenedJWS, sign, signMulti, verify, verifyMulti, verifyMultiAll };