@cmts-dev/carmentis-sdk-core 1.4.2 → 1.7.3

package/dist/crypto/CryptoSchemeFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CryptoSchemeFactory.d.ts","sourceRoot":"","sources":["../../src/crypto/CryptoSchemeFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,gBAAgB,EAChB,sBAAsB,EACtB,4BAA4B,EAC5B,2BAA2B,EAC9B,MAAM,wDAAwD,CAAC;AAEhE,OAAO,EAAC,iBAAiB,EAAE,yBAAyB,EAA0B,MAAM,uBAAuB,CAAC;AAG5G,OAAO,EAAC,kCAAkC,EAAC,MAAM,0CAA0C,CAAC;AAC5F,OAAO,EAAC,qBAAqB,EAAC,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AAChC,OAAO,EAAC,0CAA0C,EAAC,MAAM,kDAAkD,CAAC;AAC5G,OAAO,EACH,4BAA4B,EAC5B,2BAA2B,EAC9B,MAAM,uEAAuE,CAAC;AAI/E,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAC,eAAe,EAAC,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAC,mBAAmB,EAAC,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AAQhE,qBAAa,mBAAmB;IAC5B,MAAM,CAAC,yBAAyB,CAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAI,mBAAmB;IAS3F,MAAM,CAAC,uCAAuC,CAAE,GAAG,EAAE,qBAAqB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,UAAU,EAAG,MAAM,EAAE,UAAU,GAAI,mBAAmB;IAa3K;;;;;;;OAOG;IACH,MAAM,CAAC,qBAAqB,CACxB,QAAQ,EAAE,MAAM,EAChB,aAAa,GAAE,0CAA8F,EAC7G,2BAA2B,GAAE,2BAAqE,GACnG,sBAAsB;IASzB,sBAAsB,CAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAK,gBAAgB;IAMrF,uCAAuC,CAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAI,gBAAgB;IAMnH,wBAAwB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,kBAAkB,CAAC;WAIzF,wBAAwB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,kBAAkB,CAAC;WAShG,yBAAyB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,2BAA2B,CAAC;WAO1G,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAO9H;;;;;;OAMG;IACH,4BAA4B,CAAC,2BAA2B,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,sBAAsB;IAI9H,MAAM,CAAC,4BAA4B,CAAC,2BAA2B,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,sBAAsB;IASrI,MAAM,CAAC,kCAAkC,CAAC,2BAA2B,EAAE,MAAM,GAAG,4BAA4B;IAO5G,MAAM,CAAC,uBAAuB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,iBAAiB;IAQtF,MAAM,CAAC,8BAA8B,IAAI,iBAAiB;IAI1D,MAAM,CAAC,kBAAkB,IAAI,kCAAkC;IAI/D,MAAM,CAAC,gBAAgB;IAIvB,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,eAAe;CAQ7E"}
+{"version":3,"file":"CryptoSchemeFactory.d.ts","sourceRoot":"","sources":["../../src/crypto/CryptoSchemeFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,gBAAgB,EAChB,sBAAsB,EACtB,4BAA4B,EAC5B,2BAA2B,EAC9B,MAAM,wDAAwD,CAAC;AAEhE,OAAO,EAAC,iBAAiB,EAAE,yBAAyB,EAA0B,MAAM,uBAAuB,CAAC;AAG5G,OAAO,EAAC,kCAAkC,EAAC,MAAM,0CAA0C,CAAC;AAC5F,OAAO,EAAC,qBAAqB,EAAC,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AAChC,OAAO,EAAC,0CAA0C,EAAC,MAAM,kDAAkD,CAAC;AAC5G,OAAO,EACH,4BAA4B,EAC5B,2BAA2B,EAC9B,MAAM,uEAAuE,CAAC;AAI/E,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAC,eAAe,EAAC,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAC,mBAAmB,EAAC,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AAUhE,qBAAa,mBAAmB;IAC5B,MAAM,CAAC,yBAAyB,CAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAI,mBAAmB;IAS3F,MAAM,CAAC,uCAAuC,CAAE,GAAG,EAAE,qBAAqB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,UAAU,EAAG,MAAM,EAAE,UAAU,GAAI,mBAAmB;IAa3K;;;;;;;OAOG;IACH,MAAM,CAAC,qBAAqB,CACxB,QAAQ,EAAE,MAAM,EAChB,aAAa,GAAE,0CAA8F,EAC7G,2BAA2B,GAAE,2BAAqE,GACnG,sBAAsB;IASzB,sBAAsB,CAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAK,gBAAgB;IAMrF,uCAAuC,CAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAI,gBAAgB;IAMnH,wBAAwB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,kBAAkB,CAAC;WAIzF,wBAAwB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,kBAAkB,CAAC;WAUhG,yBAAyB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,2BAA2B,CAAC;WAO1G,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAO9H;;;;;;OAMG;IACH,4BAA4B,CAAC,2BAA2B,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,sBAAsB;IAI9H,MAAM,CAAC,4BAA4B,CAAC,2BAA2B,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,sBAAsB;IASrI,MAAM,CAAC,kCAAkC,CAAC,2BAA2B,EAAE,MAAM,GAAG,4BAA4B;IAO5G,MAAM,CAAC,uBAAuB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,iBAAiB;IAQtF,MAAM,CAAC,8BAA8B,IAAI,iBAAiB;IAI1D,MAAM,CAAC,kBAAkB,IAAI,kCAAkC;IAI/D,MAAM,CAAC,gBAAgB;IAIvB,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,eAAe;CAQ7E"}

package/dist/crypto/encoder/signature/dckf/DckfSignatureDecoder.d.ts

@@ -6,6 +6,7 @@ export declare class DckfSignatureDecoder implements ISignatureDecodeHandler {
     static getAcceptedSchemeTags(): string[][];
     isAcceptingPublicKeyDecodingRequest(encodedPublicKey: string): Promise<boolean>;
     isAcceptingPrivateKeyDecodingRequest(encodedPrivateKey: string): Promise<boolean>;
+    private didJwkToJwk;
     decodePublicKey(encodedPublicKey: string): Promise<PublicSignatureKey>;
     decodePrivateKey(encodedPrivateKey: string): Promise<PrivateSignatureKey>;
     private getKeyParts;

package/dist/crypto/encoder/signature/dckf/DckfSignatureDecoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DckfSignatureDecoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/dckf/DckfSignatureDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAwBzE,qBAAa,oBAAqB,YAAW,uBAAuB;IAChE,SAAS,CAAC,YAAY,iGAAsC;IAE5D,MAAM,CAAC,qBAAqB;IAQtB,mCAAmC,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK/E,oCAAoC,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKjF,eAAe,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA4BtE,gBAAgB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA4B/E,OAAO,CAAC,WAAW;CAmCtB"}
+{"version":3,"file":"DckfSignatureDecoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/dckf/DckfSignatureDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AA4BzE,qBAAa,oBAAqB,YAAW,uBAAuB;IAChE,SAAS,CAAC,YAAY,iGAAsC;IAE5D,MAAM,CAAC,qBAAqB;IAStB,mCAAmC,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ/E,oCAAoC,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMvF,OAAO,CAAC,WAAW;IAeb,eAAe,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAqCtE,gBAAgB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAgC/E,OAAO,CAAC,WAAW;CAmCtB"}

package/dist/crypto/encoder/signature/dckf/DckfSignatureEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DckfSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/dckf/DckfSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,wBAAwB,EAAC,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAkBzE,qBAAa,oBAAqB,YAAW,wBAAwB;IACjE,SAAS,CAAC,YAAY,iGAAsC;IAEtD,mCAAmC,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIpF,oCAAoC,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIvF,eAAe,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAc/D,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;YAc1D,mBAAmB;YAInB,oBAAoB;IAOlC,OAAO,CAAC,sBAAsB;IAa9B,OAAO,CAAC,uBAAuB;CAYlC"}
+{"version":3,"file":"DckfSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/dckf/DckfSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,wBAAwB,EAAC,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAqBzE,qBAAa,oBAAqB,YAAW,wBAAwB;IACjE,SAAS,CAAC,YAAY,iGAAsC;IAEtD,mCAAmC,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIpF,oCAAoC,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIvF,eAAe,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAmB/D,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;YAc1D,mBAAmB;YAInB,oBAAoB;IAOlC,OAAO,CAAC,sBAAsB;IAgB9B,OAAO,CAAC,uBAAuB;CAelC"}

package/dist/crypto/signature/SignatureSchemeId.d.ts

@@ -11,6 +11,7 @@ export declare enum SignatureSchemeId {
     SECP256K1 = 0,
     ML_DSA_65 = 1,
     PKMS_SECP256K1 = 2,
-    ED25519 = 3
+    ED25519 = 3,
+    JWK = 4
 }
 //# sourceMappingURL=SignatureSchemeId.d.ts.map

package/dist/crypto/signature/SignatureSchemeId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SignatureSchemeId.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/SignatureSchemeId.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,oBAAY,iBAAiB;IACzB,SAAS,IAAI;IACb,SAAS,IAAI;IACb,cAAc,IAAI;IAClB,OAAO,IAAI;CACd"}
+{"version":3,"file":"SignatureSchemeId.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/SignatureSchemeId.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,oBAAY,iBAAiB;IACzB,SAAS,IAAI;IACb,SAAS,IAAI;IACb,cAAc,IAAI;IAClB,OAAO,IAAI;IACX,GAAG,IAAI;CACV"}

package/dist/crypto/signature/jwk/JwkBinaryEncoder.d.ts

@@ -0,0 +1,27 @@
+import { SignatureJwk } from './JwkSignatureAlgorithm';
+/**
+ * Serialises a JWK as CBOR, with its members in lexicographic order.
+ *
+ * Ordering the members is what makes the encoding canonical: a given key always yields
+ * the same bytes, whichever order the JWK it was imported from listed its members in.
+ * Feeding this a JWK reduced by {@link extractPublicJwk} or {@link extractPrivateJwk} —
+ * which are already ordered — additionally guarantees that two JWKs modelling the same
+ * key yield the same bytes, since neither can carry a stray `kid` or `x5c` any more.
+ *
+ * @param {SignatureJwk} jwk - The JWK to serialise.
+ * @return {Uint8Array} The CBOR encoding of the JWK.
+ */
+export declare function encodeSignatureJwk(jwk: SignatureJwk): Uint8Array;
+/**
+ * Reads back a JWK serialised by {@link encodeSignatureJwk}.
+ *
+ * The decoded JWK is returned as-is; it is the importer that validates it, so that a
+ * payload holding a well-formed but unsupported JWK fails with the same diagnostic as
+ * the same JWK passed to `fromJwk` directly.
+ *
+ * @param {Uint8Array} bytes - The CBOR encoding of a JWK.
+ * @return {SignatureJwk} The decoded JWK.
+ * @throws {Error} If the payload is not CBOR, or does not hold a map.
+ */
+export declare function decodeSignatureJwk(bytes: Uint8Array): SignatureJwk;
+//# sourceMappingURL=JwkBinaryEncoder.d.ts.map

package/dist/crypto/signature/jwk/JwkBinaryEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JwkBinaryEncoder.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/jwk/JwkBinaryEncoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAiB,MAAM,yBAAyB,CAAC;AAuBrE;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,UAAU,CAIhE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAYlE"}

package/dist/crypto/signature/jwk/JwkPrivateSignatureKey.d.ts

@@ -0,0 +1,122 @@
+import { BasePrivateSignatureKey } from '../BasePrivateSignatureKey';
+import { JwkSignatureAlgorithmName, SignatureJwk } from './JwkSignatureAlgorithm';
+import { JwkSignatureScheme } from './JwkSignatureScheme';
+import { JwkGenerationOptions } from './JwkSignatureBackend';
+import { JwkPublicSignatureKey } from './JwkPublicSignatureKey';
+/**
+ * Private signature key backed by a JWK (RFC 7517).
+ *
+ * The key type and, where needed, the `alg` and `crv` members determine the primitive:
+ * EC (ES256/ES384/ES512/ES256K), OKP (Ed25519/Ed448), RSA (RS256/RS384/RS512,
+ * PS256/PS384/PS512) and AKP (ML-DSA-44/65/87) are all supported. Signing follows JOSE
+ * semantics: the message is signed as-is, without the SHA-256 pre-hash the native
+ * Carmentis signature keys apply, so the signatures interoperate with any JOSE library.
+ *
+ * The class behaves identically in Node.js and in browsers. It uses the Web Crypto API
+ * for the algorithms both platforms implement natively, and the `@noble/*` packages for
+ * the ones they do not (secp256k1, Ed25519, ML-DSA).
+ */
+export declare class JwkPrivateSignatureKey extends BasePrivateSignatureKey {
+    private readonly algorithm;
+    private readonly privateJwk;
+    private readonly publicJwk;
+    private readonly signer;
+    private readonly scheme;
+    private constructor();
+    /**
+     * Generates a fresh key pair and wraps its private half.
+     *
+     * @param {JwkSignatureAlgorithmName} alg - The JOSE algorithm to generate a key for.
+     * @param {JwkGenerationOptions} options - Algorithm-specific options, such as the RSA modulus size.
+     * @return {Promise<JwkPrivateSignatureKey>} The generated private key.
+     */
+    static gen(alg?: JwkSignatureAlgorithmName, options?: JwkGenerationOptions): Promise<JwkPrivateSignatureKey>;
+    /**
+     * Imports a private signature key from a JWK.
+     *
+     * Any JWK is accepted, whatever it carries beyond the key itself. Only the members
+     * that model the key are retained; see {@link extractPrivateJwk} for what that means
+     * and for the list of what is dropped.
+     *
+     * @param {SignatureJwk} jwk - The private JWK to import.
+     * @return {Promise<JwkPrivateSignatureKey>} The imported private key.
+     * @throws {Error} If the JWK is malformed, carries no private material, or denotes an
+     *                 unsupported algorithm.
+     */
+    static fromJwk(jwk: SignatureJwk): Promise<JwkPrivateSignatureKey>;
+    /**
+     * Imports a private signature key from the bytes {@link getPrivateKeyAsBytes} returns.
+     *
+     * @param {Uint8Array} bytes - The CBOR encoding of a private JWK.
+     * @return {Promise<JwkPrivateSignatureKey>} The imported private key.
+     * @throws {Error} If the payload is not CBOR, or does not hold a supported private JWK.
+     */
+    static fromBytes(bytes: Uint8Array): Promise<JwkPrivateSignatureKey>;
+    /**
+     * Returns the JOSE `alg` identifier of the key.
+     *
+     * @return {JwkSignatureAlgorithmName} The JOSE algorithm identifier.
+     */
+    getAlgorithm(): JwkSignatureAlgorithmName;
+    /**
+     * Returns the canonical private JWK of the key.
+     *
+     * The JWK holds the members that model the key and nothing else, ordered
+     * lexicographically, so that two keys imported from different JWKs of the same
+     * cryptographic key expose the exact same JWK here.
+     *
+     * @return {SignatureJwk} A copy of the canonical private JWK.
+     */
+    getPrivateJwk(): SignatureJwk;
+    /**
+     * Returns the canonical public JWK of the key, stripped of every private component.
+     *
+     * @return {SignatureJwk} A copy of the canonical public JWK.
+     */
+    getPublicJwk(): SignatureJwk;
+    /**
+     * Returns the binary form of the private key: the CBOR encoding of its canonical
+     * private JWK, members ordered lexicographically.
+     *
+     * The JWK is serialised rather than the bare key material because the material alone
+     * does not say which primitive it belongs to, and because an RSA private key is a set
+     * of integers that no single scalar stands for. Encoding the JWK keeps the bytes
+     * self-describing, and keeps them round-trippable through {@link fromBytes}.
+     *
+     * @return {Uint8Array} The CBOR-encoded private JWK.
+     */
+    getPrivateKeyAsBytes(): Uint8Array;
+    /**
+     * Returns the bare private key material, outside of any JWK framing.
+     *
+     * The encoding depends on the key type: the private scalar `d` for `EC` and `OKP`,
+     * the `priv` seed for `AKP`, and the PKCS#8 (RFC 5208 `PrivateKeyInfo`) DER encoding
+     * for `RSA`, whose private key is a set of integers rather than a single scalar.
+     *
+     * Unlike {@link getPrivateKeyAsBytes}, these bytes carry no indication of the
+     * algorithm they belong to, so they cannot be imported back on their own.
+     *
+     * @return {Uint8Array} The raw private key.
+     */
+    getRawPrivateKeyBytes(): Uint8Array;
+    /**
+     * Returns the public half of the key pair.
+     *
+     * @return {Promise<JwkPublicSignatureKey>} The matching public key.
+     */
+    getPublicKey(): Promise<JwkPublicSignatureKey>;
+    /**
+     * Returns the signature scheme of the key.
+     *
+     * @return {JwkSignatureScheme} The signature scheme.
+     */
+    getScheme(): JwkSignatureScheme;
+    /**
+     * Produces a detached signature over `data`.
+     *
+     * @param {Uint8Array} data - The message to sign, signed as-is.
+     * @return {Promise<Uint8Array>} The detached signature.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array>;
+}
+//# sourceMappingURL=JwkPrivateSignatureKey.d.ts.map

package/dist/crypto/signature/jwk/JwkPrivateSignatureKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JwkPrivateSignatureKey.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/jwk/JwkPrivateSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAIH,yBAAyB,EAEzB,YAAY,EACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAwC,oBAAoB,EAAY,MAAM,uBAAuB,CAAC;AAC7G,OAAO,EAAC,qBAAqB,EAAC,MAAM,yBAAyB,CAAC;AAG9D;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAuB,SAAQ,uBAAuB;IAE3D,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAL3B,OAAO;IAUP;;;;;;OAMG;WACU,GAAG,CACZ,GAAG,GAAE,yBAAqC,EAC1C,OAAO,GAAE,oBAAyB,GACnC,OAAO,CAAC,sBAAsB,CAAC;IAIlC;;;;;;;;;;;OAWG;WACU,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAcxE;;;;;;OAMG;WACU,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAI1E;;;;OAIG;IACH,YAAY,IAAI,yBAAyB;IAIzC;;;;;;;;OAQG;IACH,aAAa,IAAI,YAAY;IAI7B;;;;OAIG;IACH,YAAY,IAAI,YAAY;IAI5B;;;;;;;;;;OAUG;IACH,oBAAoB,IAAI,UAAU;IAIlC;;;;;;;;;;;OAWG;IACH,qBAAqB,IAAI,UAAU;IAInC;;;;OAIG;IACG,YAAY,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAIpD;;;;OAIG;IACH,SAAS,IAAI,kBAAkB;IAI/B;;;;;OAKG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;CAGpD"}

package/dist/crypto/signature/jwk/JwkPublicSignatureKey.d.ts

@@ -0,0 +1,100 @@
+import { BasePublicSignatureKey } from '../BasePublicSignatureKey';
+import { JwkSignatureAlgorithmName, SignatureJwk } from './JwkSignatureAlgorithm';
+import { JwkSignatureScheme } from './JwkSignatureScheme';
+/**
+ * Public signature key backed by a JWK (RFC 7517).
+ *
+ * The key type and, where needed, the `alg` and `crv` members determine the primitive:
+ * EC (ES256/ES384/ES512/ES256K), OKP (Ed25519/Ed448), RSA (RS256/RS384/RS512,
+ * PS256/PS384/PS512) and AKP (ML-DSA-44/65/87) are all supported. Verification follows
+ * JOSE semantics: the message is verified as-is, without the SHA-256 pre-hash the native
+ * Carmentis signature keys apply.
+ *
+ * The class behaves identically in Node.js and in browsers. It uses the Web Crypto API
+ * for the algorithms both platforms implement natively, and the `@noble/*` packages for
+ * the ones they do not (secp256k1, Ed25519, ML-DSA).
+ */
+export declare class JwkPublicSignatureKey extends BasePublicSignatureKey {
+    private readonly algorithm;
+    private readonly publicJwk;
+    private readonly verifier;
+    private readonly scheme;
+    private constructor();
+    /**
+     * Imports a public signature key from a JWK.
+     *
+     * Any JWK is accepted, whatever it carries beyond the key itself. Only the members
+     * that model the key are retained; see {@link extractPublicJwk} for what that means
+     * and for the list of what is dropped. A private JWK is accepted as well: only its
+     * public members are retained.
+     *
+     * @param {SignatureJwk} jwk - The JWK to import.
+     * @return {Promise<JwkPublicSignatureKey>} The imported public key.
+     * @throws {Error} If the JWK is malformed or denotes an unsupported algorithm.
+     */
+    static fromJwk(jwk: SignatureJwk): Promise<JwkPublicSignatureKey>;
+    /**
+     * Imports a public signature key from the bytes {@link getPublicKeyAsBytes} returns.
+     *
+     * @param {Uint8Array} bytes - The CBOR encoding of a public JWK.
+     * @return {Promise<JwkPublicSignatureKey>} The imported public key.
+     * @throws {Error} If the payload is not CBOR, or does not hold a supported JWK.
+     */
+    static fromBytes(bytes: Uint8Array): Promise<JwkPublicSignatureKey>;
+    /**
+     * Returns the JOSE `alg` identifier of the key.
+     *
+     * @return {JwkSignatureAlgorithmName} The JOSE algorithm identifier.
+     */
+    getAlgorithm(): JwkSignatureAlgorithmName;
+    /**
+     * Returns the canonical public JWK of the key.
+     *
+     * The JWK holds the members that model the key and nothing else, ordered
+     * lexicographically, so that two keys imported from different JWKs of the same
+     * cryptographic key expose the exact same JWK here.
+     *
+     * @return {SignatureJwk} A copy of the canonical public JWK.
+     */
+    getPublicJwk(): SignatureJwk;
+    /**
+     * Returns the binary form of the public key: the CBOR encoding of its canonical
+     * public JWK, members ordered lexicographically.
+     *
+     * The JWK is serialised rather than the bare key material because the material alone
+     * does not say which primitive it belongs to — `x` is a 32-byte string for both an
+     * Ed25519 and a P-256 key. Encoding the JWK keeps the bytes self-describing, and
+     * keeps them round-trippable through {@link fromBytes}.
+     *
+     * @return {Promise<Uint8Array>} The CBOR-encoded public JWK.
+     */
+    getPublicKeyAsBytes(): Promise<Uint8Array>;
+    /**
+     * Returns the bare public key material, outside of any JWK framing.
+     *
+     * The encoding depends on the key type: the uncompressed point for `EC`, the
+     * public key itself for `OKP` and `AKP`, and the SPKI (RFC 5280
+     * `SubjectPublicKeyInfo`) DER encoding for `RSA`, which has no shorter raw form.
+     *
+     * Unlike {@link getPublicKeyAsBytes}, these bytes carry no indication of the
+     * algorithm they belong to, so they cannot be imported back on their own.
+     *
+     * @return {Uint8Array} The raw public key.
+     */
+    getRawPublicKeyBytes(): Uint8Array;
+    /**
+     * Returns the signature scheme of the key.
+     *
+     * @return {JwkSignatureScheme} The signature scheme.
+     */
+    getScheme(): JwkSignatureScheme;
+    /**
+     * Verifies a detached signature over `data`.
+     *
+     * @param {Uint8Array} data - The signed message, verified as-is.
+     * @param {Uint8Array} signature - The detached signature.
+     * @return {Promise<boolean>} Whether the signature is valid.
+     */
+    verify(data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+}
+//# sourceMappingURL=JwkPublicSignatureKey.d.ts.map

package/dist/crypto/signature/jwk/JwkPublicSignatureKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JwkPublicSignatureKey.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/jwk/JwkPublicSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,sBAAsB,EAAC,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAGH,yBAAyB,EAEzB,YAAY,EACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAIxD;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,SAAQ,sBAAsB;IAEzD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJ3B,OAAO;IASP;;;;;;;;;;;OAWG;WACU,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAYvE;;;;;;OAMG;WACU,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIzE;;;;OAIG;IACH,YAAY,IAAI,yBAAyB;IAIzC;;;;;;;;OAQG;IACH,YAAY,IAAI,YAAY;IAI5B;;;;;;;;;;OAUG;IACG,mBAAmB,IAAI,OAAO,CAAC,UAAU,CAAC;IAIhD;;;;;;;;;;;OAWG;IACH,oBAAoB,IAAI,UAAU;IAIlC;;;;OAIG;IACH,SAAS,IAAI,kBAAkB;IAI/B;;;;;;OAMG;IACG,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;CAQ1E"}

package/dist/crypto/signature/jwk/JwkSignatureAlgorithm.d.ts

@@ -0,0 +1,159 @@
+/**
+ * JWK (RFC 7517) signature algorithm resolution and canonicalisation.
+ *
+ * A JWK does not carry an explicit description of the primitive to use: it has to be
+ * derived from the `kty` member, completed by `crv` for elliptic-curve families and by
+ * `alg` for RSA and ML-DSA. This module centralises that derivation so that
+ * {@link JwkPrivateSignatureKey} and {@link JwkPublicSignatureKey} agree on it.
+ *
+ * It also reduces an incoming JWK to its canonical form: the lexicographically ordered
+ * set of members that are strictly necessary to model the key. Any other member is
+ * accepted on import and then dropped, so that two JWKs describing the same key always
+ * produce the same canonical form and, in turn, the same serialised bytes.
+ */
+/**
+ * Key types that can carry a signature key.
+ *
+ * - `EC`  : elliptic curve, RFC 7518 (ES256/ES384/ES512) and RFC 8812 (ES256K).
+ * - `OKP` : octet key pair, RFC 8037 (Ed25519, Ed448).
+ * - `RSA` : RFC 7518 (RS256/RS384/RS512, PS256/PS384/PS512).
+ * - `AKP` : algorithm key pair, RFC 9836 (ML-DSA-44/65/87).
+ */
+export type JwkSignatureKeyType = "EC" | "OKP" | "RSA" | "AKP";
+/** JOSE `alg` identifiers supported by the JWK signature keys. */
+export type JwkSignatureAlgorithmName = "ES256" | "ES384" | "ES512" | "ES256K" | "Ed25519" | "Ed448" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ML-DSA-44" | "ML-DSA-65" | "ML-DSA-87";
+/**
+ * Implementation actually performing sign/verify for a given algorithm.
+ *
+ * `webcrypto` is used for everything every browser and every supported Node.js version
+ * implements natively. The remaining algorithms are delegated to the `@noble/*` packages
+ * already bundled with the SDK, because their Web Crypto counterparts are either absent
+ * (secp256k1) or still experimental and unavailable in browsers (ML-DSA).
+ */
+export type JwkSignatureBackend = "webcrypto" | "ed25519" | "secp256k1" | "ml-dsa";
+/**
+ * A JWK that may hold signature key material.
+ *
+ * Extends the DOM `JsonWebKey` with the AKP members of RFC 9836, which the standard
+ * library type does not know about, and with the certificate members of RFC 7517.
+ *
+ * The members beyond the key material itself are declared for the sake of the JWKs
+ * handed to {@link extractPublicJwk} and {@link extractPrivateJwk}, which tolerate them
+ * on input; none of them survives into the canonical form those functions return.
+ */
+export interface SignatureJwk extends JsonWebKey {
+    /** Key identifier (RFC 7517 §4.5). */
+    kid?: string;
+    /** AKP public key, base64url-encoded (RFC 9836). */
+    pub?: string;
+    /** AKP private key seed, base64url-encoded (RFC 9836). */
+    priv?: string;
+    /** Certificate usage (RFC 7517 §4.6). */
+    x5u?: string;
+    /** Certificate chain (RFC 7517 §4.7). */
+    x5c?: string[];
+    /** Certificate SHA-1 Thumbprint (RFC 7517 §4.8). */
+    x5t?: string;
+    /** Certificate SHA-256 Thumbprint (RFC 7517 §4.9). */
+    "x5t#S256"?: string;
+}
+/**
+ * Fully resolved description of the signature primitive denoted by a JWK.
+ */
+export interface JwkSignatureAlgorithm {
+    /** Canonical JOSE `alg` identifier. */
+    readonly alg: JwkSignatureAlgorithmName;
+    /** Key type the algorithm applies to. */
+    readonly kty: JwkSignatureKeyType;
+    /** Curve name, for `EC` and `OKP` keys only. */
+    readonly crv?: string;
+    /** Implementation performing sign/verify. */
+    readonly backend: JwkSignatureBackend;
+    /** Parameters for `SubtleCrypto.importKey`; only set when `backend` is `webcrypto`. */
+    readonly keyAlgorithm?: EcKeyImportParams | RsaHashedImportParams | Algorithm;
+    /** Parameters for `SubtleCrypto.sign`/`verify`; only set when `backend` is `webcrypto`. */
+    readonly signAlgorithm?: EcdsaParams | RsaPssParams | Algorithm;
+    /**
+     * Size in bytes of the private scalar or seed the key is built from,
+     * or `undefined` for algorithms that have none (RSA).
+     */
+    readonly seedSize?: number;
+    /**
+     * Size in bytes of a detached signature, or `undefined` when it depends on the
+     * key size rather than on the algorithm (RSA, where it equals the modulus size).
+     */
+    readonly signatureSize?: number;
+}
+/**
+ * Resolves the signature primitive denoted by a JWK.
+ *
+ * Only the members that define the primitive are looked at. The ones that merely
+ * describe the key handle the JWK came from — `use`, `key_ops` and `ext` — are ignored,
+ * including when they contradict a signing usage: this class hierarchy is the caller's
+ * statement of intent, and a JWK is accepted whatever its declared usage.
+ *
+ * @param {SignatureJwk} jwk - The JWK to inspect. It may be either a public or a private key.
+ * @return {JwkSignatureAlgorithm} The resolved algorithm description.
+ * @throws {Error} If the JWK is malformed, is not a signature key, or uses an unsupported algorithm.
+ */
+export declare function resolveJwkSignatureAlgorithm(jwk: SignatureJwk): JwkSignatureAlgorithm;
+/**
+ * Resolves a signature primitive from its JOSE `alg` identifier, without a key.
+ *
+ * @param {JwkSignatureAlgorithmName} alg - The JOSE algorithm identifier.
+ * @return {JwkSignatureAlgorithm} The resolved algorithm description.
+ * @throws {Error} If the algorithm is not supported.
+ */
+export declare function resolveJwkSignatureAlgorithmByName(alg: JwkSignatureAlgorithmName): JwkSignatureAlgorithm;
+/**
+ * Reduces a JWK to the canonical public form of the key it holds.
+ *
+ * The result carries `kty`, the public members of that key type, and `alg` only where
+ * {@link ALG_DEPENDENT_KEY_TYPES} says the key material does not already imply the
+ * primitive. Everything else the JWK may have arrived with is dropped: the private
+ * members, and the members that describe the JWK rather than the key — `use`, `key_ops`,
+ * `ext`, `kid`, `x5u`, `x5c`, `x5t`, `x5t#S256` and anything unrecognised.
+ *
+ * The extraction works on an allow-list rather than by deleting known private members,
+ * so that a private RSA JWK cannot leak `p`, `q`, `dp`, `dq`, `qi` or `oth` into the
+ * public key, and so that a member added by a future JWK revision cannot slip through.
+ *
+ * @param {SignatureJwk} jwk - The JWK to derive the public key from.
+ * @param {JwkSignatureAlgorithm} algorithm - The algorithm resolved from that JWK.
+ * @return {SignatureJwk} The canonical public JWK, with its members ordered.
+ * @throws {Error} If a public member required by the key type is missing.
+ */
+export declare function extractPublicJwk(jwk: SignatureJwk, algorithm: JwkSignatureAlgorithm): SignatureJwk;
+/**
+ * Reduces a JWK to the canonical private form of the key it holds.
+ *
+ * The result is {@link extractPublicJwk} completed by the private members of the key
+ * type; the same members are dropped, on the same allow-list basis.
+ *
+ * @param {SignatureJwk} jwk - The private JWK.
+ * @param {JwkSignatureAlgorithm} algorithm - The algorithm resolved from that JWK.
+ * @return {SignatureJwk} The canonical private JWK, with its members ordered.
+ * @throws {Error} If a member required to sign is missing.
+ */
+export declare function extractPrivateJwk(jwk: SignatureJwk, algorithm: JwkSignatureAlgorithm): SignatureJwk;
+/**
+ * Returns a copy of a JWK whose members are ordered lexicographically.
+ *
+ * Both JSON and CBOR serialise object members in insertion order, so ordering them is
+ * what turns the canonical form into a canonical byte string: two JWKs holding the same
+ * members serialise identically no matter which order they were written in.
+ *
+ * @param {SignatureJwk | Record<string, unknown>} jwk - The JWK to order.
+ * @return {SignatureJwk} A copy of the JWK, with its members in lexicographic order.
+ */
+export declare function sortJwkMembers(jwk: SignatureJwk | Record<string, unknown>): SignatureJwk;
+/**
+ * Reads a mandatory string member of a JWK.
+ *
+ * @param {SignatureJwk} jwk - The JWK to read from.
+ * @param {string} member - Name of the member.
+ * @return {string} The member value.
+ * @throws {Error} If the member is missing or is not a string.
+ */
+export declare function requireJwkMember(jwk: SignatureJwk, member: string): string;
+//# sourceMappingURL=JwkSignatureAlgorithm.d.ts.map

package/dist/crypto/signature/jwk/JwkSignatureAlgorithm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JwkSignatureAlgorithm.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/jwk/JwkSignatureAlgorithm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAE/D,kEAAkE;AAClE,MAAM,MAAM,yBAAyB,GAC/B,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GACtC,SAAS,GAAG,OAAO,GACnB,OAAO,GAAG,OAAO,GAAG,OAAO,GAC3B,OAAO,GAAG,OAAO,GAAG,OAAO,GAC3B,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEnF;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC5C,sCAAsC;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,yCAAyC;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,yCAAyC;IACzC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IAEf,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,uCAAuC;IACvC,QAAQ,CAAC,GAAG,EAAE,yBAAyB,CAAC;IACxC,yCAAyC;IACzC,QAAQ,CAAC,GAAG,EAAE,mBAAmB,CAAC;IAClC,gDAAgD;IAChD,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,uFAAuF;IACvF,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,GAAG,qBAAqB,GAAG,SAAS,CAAC;IAC9E,2FAA2F;IAC3F,QAAQ,CAAC,aAAa,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,SAAS,CAAC;IAChE;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACnC;AAiED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,YAAY,GAAG,qBAAqB,CAqBrF;AAoKD;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,yBAAyB,GAAG,qBAAqB,CASxG;AAiBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,YAAY,EAAE,SAAS,EAAE,qBAAqB,GAAG,YAAY,CAYlG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,EAAE,SAAS,EAAE,qBAAqB,GAAG,YAAY,CAenG;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY,CAMxF;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAI1E"}

package/dist/crypto/signature/jwk/JwkSignatureBackend.d.ts

@@ -0,0 +1,56 @@
+import { JwkSignatureAlgorithm, JwkSignatureAlgorithmName, SignatureJwk } from './JwkSignatureAlgorithm';
+/** Signing half of a JWK key pair. */
+export interface JwkSigner {
+    /** Bare private key material; see {@link JwkPrivateSignatureKey.getRawPrivateKeyBytes}. */
+    readonly privateKeyBytes: Uint8Array;
+    /**
+     * Produces a detached signature over `data`.
+     *
+     * @param {Uint8Array} data - The message to sign. It is signed as-is, following JOSE semantics.
+     * @return {Promise<Uint8Array>} The detached signature.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array>;
+}
+/** Verifying half of a JWK key pair. */
+export interface JwkVerifier {
+    /** Bare public key material; see {@link JwkPublicSignatureKey.getRawPublicKeyBytes}. */
+    readonly publicKeyBytes: Uint8Array;
+    /**
+     * Checks a detached signature over `data`.
+     *
+     * @param {Uint8Array} data - The signed message.
+     * @param {Uint8Array} signature - The detached signature.
+     * @return {Promise<boolean>} Whether the signature is valid.
+     */
+    verify(data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+}
+/** Options accepted when generating a fresh signature JWK. */
+export interface JwkGenerationOptions {
+    /** Modulus size in bits, for RSA keys only. Defaults to 2048. */
+    modulusLength?: number;
+}
+/**
+ * Builds the signer of a private JWK.
+ *
+ * @param {JwkSignatureAlgorithm} algorithm - The algorithm resolved from the JWK.
+ * @param {SignatureJwk} privateJwk - The sanitised private JWK.
+ * @return {Promise<JwkSigner>} The signer bound to that key.
+ */
+export declare function createJwkSigner(algorithm: JwkSignatureAlgorithm, privateJwk: SignatureJwk): Promise<JwkSigner>;
+/**
+ * Builds the verifier of a public JWK.
+ *
+ * @param {JwkSignatureAlgorithm} algorithm - The algorithm resolved from the JWK.
+ * @param {SignatureJwk} publicJwk - The sanitised public JWK.
+ * @return {Promise<JwkVerifier>} The verifier bound to that key.
+ */
+export declare function createJwkVerifier(algorithm: JwkSignatureAlgorithm, publicJwk: SignatureJwk): Promise<JwkVerifier>;
+/**
+ * Generates a fresh private JWK for the given JOSE algorithm.
+ *
+ * @param {JwkSignatureAlgorithmName} alg - The JOSE algorithm identifier.
+ * @param {JwkGenerationOptions} options - Algorithm-specific generation options.
+ * @return {Promise<SignatureJwk>} The generated private JWK.
+ */
+export declare function generateSignatureJwk(alg: JwkSignatureAlgorithmName, options?: JwkGenerationOptions): Promise<SignatureJwk>;
+//# sourceMappingURL=JwkSignatureBackend.d.ts.map

package/dist/crypto/signature/jwk/JwkSignatureBackend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JwkSignatureBackend.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/jwk/JwkSignatureBackend.ts"],"names":[],"mappings":"AAmBA,OAAO,EACH,qBAAqB,EACrB,yBAAyB,EAGzB,YAAY,EACf,MAAM,yBAAyB,CAAC;AAkBjC,sCAAsC;AACtC,MAAM,WAAW,SAAS;IACtB,2FAA2F;IAC3F,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC;IAErC;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC/C;AAED,wCAAwC;AACxC,MAAM,WAAW,WAAW;IACxB,wFAAwF;IACxF,QAAQ,CAAC,cAAc,EAAE,UAAU,CAAC;IAEpC;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACrE;AAED,8DAA8D;AAC9D,MAAM,WAAW,oBAAoB;IACjC,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACjC,SAAS,EAAE,qBAAqB,EAChC,UAAU,EAAE,YAAY,GACzB,OAAO,CAAC,SAAS,CAAC,CAapB;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACnC,SAAS,EAAE,qBAAqB,EAChC,SAAS,EAAE,YAAY,GACxB,OAAO,CAAC,WAAW,CAAC,CAatB;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACtC,GAAG,EAAE,yBAAyB,EAC9B,OAAO,GAAE,oBAAyB,GACnC,OAAO,CAAC,YAAY,CAAC,CA+CvB"}

package/dist/crypto/signature/jwk/JwkSignatureScheme.d.ts

@@ -0,0 +1,60 @@
+import { SignatureScheme } from '../SignatureScheme';
+import { SignatureSchemeId } from '../SignatureSchemeId';
+import { JwkSignatureAlgorithm, JwkSignatureAlgorithmName, SignatureJwk } from './JwkSignatureAlgorithm';
+/**
+ * {@link SignatureScheme} describing the primitive denoted by a JWK.
+ *
+ * The instance is bound to a specific key because RSA signature sizes depend on the
+ * modulus rather than on the algorithm alone.
+ */
+export declare class JwkSignatureScheme implements SignatureScheme {
+    private readonly algorithm;
+    private readonly signatureSize;
+    /**
+     * Builds the scheme of a given key.
+     *
+     * @param {JwkSignatureAlgorithm} algorithm - The algorithm resolved from the JWK.
+     * @param {SignatureJwk} jwk - The JWK the scheme describes; must expose its public members.
+     * @return {JwkSignatureScheme} The signature scheme of that key.
+     */
+    static forJwk(algorithm: JwkSignatureAlgorithm, jwk: SignatureJwk): JwkSignatureScheme;
+    constructor(algorithm: JwkSignatureAlgorithm, signatureSize: number);
+    /**
+     * Returns the full description of the resolved signature primitive.
+     *
+     * @return {JwkSignatureAlgorithm} The algorithm description.
+     */
+    getAlgorithm(): JwkSignatureAlgorithm;
+    /**
+     * Returns the JOSE `alg` identifier of the scheme.
+     *
+     * @return {JwkSignatureAlgorithmName} The JOSE algorithm identifier.
+     */
+    getAlgorithmName(): JwkSignatureAlgorithmName;
+    /**
+     * Returns the Carmentis identifier of the scheme.
+     *
+     * Most JOSE algorithms have no Carmentis counterpart, and those that look like one
+     * are not always compatible with it; see {@link SIGNATURE_SCHEME_IDS}. Such keys can
+     * still sign and verify — they simply cannot be used where a scheme identifier has
+     * to be recorded, such as on-chain signatures.
+     *
+     * @return {SignatureSchemeId} The Carmentis signature scheme identifier.
+     * @throws {Error} If the algorithm has no equivalent Carmentis scheme.
+     */
+    getSignatureSchemeId(): SignatureSchemeId;
+    /**
+     * Returns the size in bytes of a detached signature produced by this key.
+     *
+     * @return {number} The signature size in bytes.
+     */
+    getSignatureSize(): number;
+    /**
+     * Returns the size in bytes of the seed the key is derived from.
+     *
+     * @return {number} The seed size in bytes.
+     * @throws {Error} If the algorithm is not seed-based, which is the case of RSA.
+     */
+    expectedSeedSize(): number;
+}
+//# sourceMappingURL=JwkSignatureScheme.d.ts.map

package/dist/crypto/signature/jwk/JwkSignatureScheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JwkSignatureScheme.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/jwk/JwkSignatureScheme.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AACvD,OAAO,EACH,qBAAqB,EACrB,yBAAyB,EAEzB,YAAY,EACf,MAAM,yBAAyB,CAAC;AAmBjC;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,eAAe;IAelD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAflC;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,qBAAqB,EAAE,GAAG,EAAE,YAAY,GAAG,kBAAkB;gBAOjE,SAAS,EAAE,qBAAqB,EAChC,aAAa,EAAE,MAAM;IAI1C;;;;OAIG;IACH,YAAY,IAAI,qBAAqB;IAIrC;;;;OAIG;IACH,gBAAgB,IAAI,yBAAyB;IAI7C;;;;;;;;;;OAUG;IACH,oBAAoB,IAAI,iBAAiB;IAezC;;;;OAIG;IACH,gBAAgB,IAAI,MAAM;IAI1B;;;;;OAKG;IACH,gBAAgB,IAAI,MAAM;CAM7B"}

package/dist/crypto/signature/jwk/webcrypto.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns the Web Crypto `SubtleCrypto` implementation of the current runtime.
+ *
+ * The lookup is deliberately lazy: resolving `globalThis.crypto.subtle` at module
+ * scope would throw while merely importing the module on runtimes where Web Crypto
+ * is not exposed globally (Node.js < 19, browsers in an insecure context).
+ *
+ * @return {SubtleCrypto} The `SubtleCrypto` instance of the current runtime.
+ * @throws {Error} If the runtime does not expose the Web Crypto API.
+ */
+export declare function getSubtle(): SubtleCrypto;
+//# sourceMappingURL=webcrypto.d.ts.map

package/dist/crypto/signature/jwk/webcrypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/jwk/webcrypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,SAAS,IAAI,YAAY,CAUxC"}

package/dist/crypto/signature/secp256k1/Secp256k1PrivateSignatureKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Secp256k1PrivateSignatureKey.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/secp256k1/Secp256k1PrivateSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,OAAO,EAA+B,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAC,uBAAuB,EAAC,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AAGnD;;;;;;;;GAQG;AACH,qBAAa,4BAA6B,SAAQ,uBAAuB;IACzD,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,OAAO;IAIvC,qBAAqB,CAAC,OAAO,EAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,MAAM;IAI5E;;;;;OAKG;IACH,MAAM,CAAC,GAAG,IAAI,4BAA4B;IAI1C;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU;IAI7B,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAKjD,oBAAoB,IAAI,UAAU;IAK5B,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAKjD,SAAS,IAAI,eAAe;CAG/B"}
+{"version":3,"file":"Secp256k1PrivateSignatureKey.d.ts","sourceRoot":"","sources":["../../../../src/crypto/signature/secp256k1/Secp256k1PrivateSignatureKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,OAAO,EAA0C,MAAM,kBAAkB,CAAC;AACrG,OAAO,EAAC,uBAAuB,EAAC,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AAGnD;;;;;;;;GAQG;AACH,qBAAa,4BAA6B,SAAQ,uBAAuB;IACzD,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,OAAO;IAIvC,qBAAqB,CAAC,OAAO,EAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,MAAM;IAI5E;;;;;OAKG;IACH,MAAM,CAAC,GAAG,IAAI,4BAA4B;IAI1C;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU;IAI7B,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAKjD,oBAAoB,IAAI,UAAU;IAK5B,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAKjD,SAAS,IAAI,eAAe;CAG/B"}

package/dist/crypto/signature/signer/binary/BinaryEncoder.d.ts

@@ -0,0 +1,6 @@
+import { BinaryEncoding } from './BinaryEndoding';
+export declare class BinaryEncoder {
+    static decode(message: string, encoding: BinaryEncoding): Uint8Array;
+    static encode(message: Uint8Array, encoding: BinaryEncoding): string;
+}
+//# sourceMappingURL=BinaryEncoder.d.ts.map

package/dist/crypto/signature/signer/binary/BinaryEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/signature/signer/binary/BinaryEncoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAEhD,qBAAa,aAAa;IACtB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,UAAU;IAQpE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc;CAO9D"}