@adcp/sdk 16.0.0-beta.1 → 16.0.0-beta.3

package/dist/lib/server/auth-signature.js

@@ -42,6 +42,10 @@ function verifySignatureAsAuthenticator(options) {
     throw new TypeError(
       "Web Bot Auth requires an origin-binding migration fence; use createIdentity33PrincipalResolver or supply assertLegacyOriginAllowed"
     );
+  if (options.webBotAuth && !options.webBotAuth.isRevoked && !(0, import_web_bot_auth2.isWebBotAuthRevocationChecked)(options.webBotAuth.resolvePrincipal))
+    throw new TypeError(
+      "Web Bot Auth requires origin revocation: use createIdentity33PrincipalResolver({ revocation }) or supply isRevoked"
+    );
   const revocationStore = options.revocationStore ?? new import_revocation.InMemoryRevocationStore();
   const authenticator = async (req) => {
     if (!hasSignatureHeader(req)) return null;
@@ -62,21 +66,22 @@ function verifySignatureAsAuthenticator(options) {
           throw new import_web_bot_auth2.WebBotAuthError(403, "raw_body_missing");
         const signers = await (0, import_web_bot_auth2.verifyWebBotAuth)(requestLike, {
           directory: options.webBotAuth.directory,
-          deferAuthorizationErrors: typeof options.resolveOperation(req) === "string",
           replayStore,
-          isRevoked: options.webBotAuth.isRevoked,
           now: options.now,
-          requireFreshRevocation: ![
-            "get_adcp_capabilities",
-            "get_principal",
-            "list_creative_formats",
-            "list_accounts"
-          ].includes(String(options.resolveOperation(req)))
+          ...options.webBotAuth.isRevoked && { isRevoked: options.webBotAuth.isRevoked }
         });
-        const principal2 = await options.webBotAuth.resolvePrincipal(
-          signers,
-          options.resolveOperation(req)
-        );
+        const operation = options.resolveOperation(req);
+        let principal2;
+        let deferredFailure;
+        try {
+          principal2 = await options.webBotAuth.resolvePrincipal(signers, operation);
+        } catch (error) {
+          if (error instanceof import_web_bot_auth2.WebBotAuthError || error instanceof import_web_bot_auth2.WebBotAuthUnavailableError) throw error;
+          if (typeof operation !== "string") throw (0, import_web_bot_auth2.webBotAuthPrincipalFailureError)(error);
+          const deferred = (0, import_web_bot_auth2.deferWebBotAuthPrincipalFailure)(signers, error);
+          principal2 = { principal: deferred.principal };
+          deferredFailure = deferred.authorizationFailure;
+        }
         const signer2 = signers[signers.length - 1];
         req.verifiedSigner = {
           keyid: signer2.keyid,
@@ -90,7 +95,9 @@ function verifySignatureAsAuthenticator(options) {
             ...principal2.extra,
             webBotAuthAuthorization: {
               signer: failed ?? signer2,
-              ...failed && { authorizationFailure: failed.authorizationFailure }
+              ...(failed?.authorizationFailure ?? deferredFailure) && {
+                authorizationFailure: failed?.authorizationFailure ?? deferredFailure
+              }
             }
           }
         };
@@ -117,6 +124,10 @@ function verifySignatureAsAuthenticator(options) {
     } catch (err) {
       if (err instanceof import_web_bot_auth2.WebBotAuthError)
         throw new import_auth.AuthError(err.message, { cause: err, status: err.status, headers: err.headers, body: err.body });
+      if (err instanceof import_web_bot_auth2.WebBotAuthUnavailableError) {
+        const outage = (0, import_web_bot_auth2.webBotAuthUnavailableResponse)();
+        throw new import_auth.AuthError(err.message, { cause: err, ...outage });
+      }
       if (err instanceof import_errors.RequestSignatureError) {
         throw new import_auth.AuthError(`Signature rejected (${err.code}).`, { cause: err });
       }

package/dist/lib/server/auth-signature.mjs

@@ -3,6 +3,11 @@ import { RequestSignatureError } from "../signing/errors.mjs";
 import {
   selectSignatureProfile,
   verifyWebBotAuth,
+  isWebBotAuthRevocationChecked,
+  webBotAuthUnavailableResponse,
+  WebBotAuthUnavailableError,
+  deferWebBotAuthPrincipalFailure,
+  webBotAuthPrincipalFailureError,
   WebBotAuthError
 } from "../signing/web-bot-auth.mjs";
 import { InMemoryReplayStore } from "../signing/replay.mjs";
@@ -34,6 +39,10 @@ function verifySignatureAsAuthenticator(options) {
     throw new TypeError(
       "Web Bot Auth requires an origin-binding migration fence; use createIdentity33PrincipalResolver or supply assertLegacyOriginAllowed"
     );
+  if (options.webBotAuth && !options.webBotAuth.isRevoked && !isWebBotAuthRevocationChecked(options.webBotAuth.resolvePrincipal))
+    throw new TypeError(
+      "Web Bot Auth requires origin revocation: use createIdentity33PrincipalResolver({ revocation }) or supply isRevoked"
+    );
   const revocationStore = options.revocationStore ?? new InMemoryRevocationStore();
   const authenticator = async (req) => {
     if (!hasSignatureHeader(req)) return null;
@@ -54,21 +63,22 @@ function verifySignatureAsAuthenticator(options) {
           throw new WebBotAuthError(403, "raw_body_missing");
         const signers = await verifyWebBotAuth(requestLike, {
           directory: options.webBotAuth.directory,
-          deferAuthorizationErrors: typeof options.resolveOperation(req) === "string",
           replayStore,
-          isRevoked: options.webBotAuth.isRevoked,
           now: options.now,
-          requireFreshRevocation: ![
-            "get_adcp_capabilities",
-            "get_principal",
-            "list_creative_formats",
-            "list_accounts"
-          ].includes(String(options.resolveOperation(req)))
+          ...options.webBotAuth.isRevoked && { isRevoked: options.webBotAuth.isRevoked }
         });
-        const principal2 = await options.webBotAuth.resolvePrincipal(
-          signers,
-          options.resolveOperation(req)
-        );
+        const operation = options.resolveOperation(req);
+        let principal2;
+        let deferredFailure;
+        try {
+          principal2 = await options.webBotAuth.resolvePrincipal(signers, operation);
+        } catch (error) {
+          if (error instanceof WebBotAuthError || error instanceof WebBotAuthUnavailableError) throw error;
+          if (typeof operation !== "string") throw webBotAuthPrincipalFailureError(error);
+          const deferred = deferWebBotAuthPrincipalFailure(signers, error);
+          principal2 = { principal: deferred.principal };
+          deferredFailure = deferred.authorizationFailure;
+        }
         const signer2 = signers[signers.length - 1];
         req.verifiedSigner = {
           keyid: signer2.keyid,
@@ -82,7 +92,9 @@ function verifySignatureAsAuthenticator(options) {
             ...principal2.extra,
             webBotAuthAuthorization: {
               signer: failed ?? signer2,
-              ...failed && { authorizationFailure: failed.authorizationFailure }
+              ...(failed?.authorizationFailure ?? deferredFailure) && {
+                authorizationFailure: failed?.authorizationFailure ?? deferredFailure
+              }
             }
           }
         };
@@ -109,6 +121,10 @@ function verifySignatureAsAuthenticator(options) {
     } catch (err) {
       if (err instanceof WebBotAuthError)
         throw new AuthError(err.message, { cause: err, status: err.status, headers: err.headers, body: err.body });
+      if (err instanceof WebBotAuthUnavailableError) {
+        const outage = webBotAuthUnavailableResponse();
+        throw new AuthError(err.message, { cause: err, ...outage });
+      }
       if (err instanceof RequestSignatureError) {
         throw new AuthError(`Signature rejected (${err.code}).`, { cause: err });
       }

package/dist/lib/server/auth.d.mts

@@ -145,12 +145,12 @@ export type Authenticator = (req: IncomingMessage) => AuthResult | Promise<AuthR
  */
 export declare class AuthError extends Error {
     readonly publicMessage: string;
-    readonly status?: 400 | 403 | 429;
+    readonly status?: 400 | 403 | 429 | 503;
     readonly body?: Record<string, unknown>;
     readonly headers?: Record<string, string>;
     constructor(publicMessage: string, options?: {
         cause?: unknown;
-        status?: 400 | 403 | 429;
+        status?: 400 | 403 | 429 | 503;
         headers?: Record<string, string>;
         body?: Record<string, unknown>;
     });

package/dist/lib/server/auth.d.ts

@@ -145,12 +145,12 @@ export type Authenticator = (req: IncomingMessage) => AuthResult | Promise<AuthR
  */
 export declare class AuthError extends Error {
     readonly publicMessage: string;
-    readonly status?: 400 | 403 | 429;
+    readonly status?: 400 | 403 | 429 | 503;
     readonly body?: Record<string, unknown>;
     readonly headers?: Record<string, string>;
     constructor(publicMessage: string, options?: {
         cause?: unknown;
-        status?: 400 | 403 | 429;
+        status?: 400 | 403 | 429 | 503;
         headers?: Record<string, string>;
         body?: Record<string, unknown>;
     });

package/dist/lib/server/create-adcp-server.js

@@ -1433,6 +1433,10 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
     throw new Error(
       "Web Bot Auth requires an origin-binding migration fence; use createIdentity33PrincipalResolver or supply assertLegacyOriginAllowed"
     );
+  if (signedRequests.webBotAuth && !signedRequests.webBotAuth.isRevoked && !(0, import_web_bot_auth2.isWebBotAuthRevocationChecked)(signedRequests.webBotAuth.resolvePrincipal))
+    throw new Error(
+      "Web Bot Auth requires origin revocation: use createIdentity33PrincipalResolver({ revocation }) or supply isRevoked"
+    );
   const requiredFor = effectiveRequestSigning.required_for ?? [];
   const verifier = (0, import_middleware.createExpressVerifier)({
     capability: {
@@ -1462,20 +1466,25 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         const signers = await (0, import_web_bot_auth2.verifyWebBotAuth)(
           { method: req.method ?? "POST", url: requestTarget, headers: req.headers, body: req.rawBody ?? "" },
           {
+            // Identity verification needs only key discovery and replay state;
+            // revocation and binding belong to the principal resolver.
             directory: signedRequests.webBotAuth.directory,
-            deferAuthorizationErrors: typeof (0, import_operation_resolution.resolveRequestOperation)({ rawBody: req.rawBody, method: req.method, url: req.url }) === "string",
             replayStore: signedRequests.replayStore,
-            isRevoked: signedRequests.webBotAuth.isRevoked,
-            requireFreshRevocation: ![
-              "get_adcp_capabilities",
-              "get_principal",
-              "list_creative_formats",
-              "list_accounts"
-            ].includes(String((0, import_operation_resolution.resolveRequestOperation)({ rawBody: req.rawBody, method: req.method, url: req.url })))
+            ...signedRequests.webBotAuth.isRevoked && { isRevoked: signedRequests.webBotAuth.isRevoked }
           }
         );
         const operation = (0, import_operation_resolution.resolveRequestOperation)({ rawBody: req.rawBody, method: req.method, url: req.url });
-        const principal = await signedRequests.webBotAuth.resolvePrincipal(signers, operation);
+        let principal;
+        let deferredFailure;
+        try {
+          principal = await signedRequests.webBotAuth.resolvePrincipal(signers, operation);
+        } catch (error) {
+          if (error instanceof import_web_bot_auth2.WebBotAuthError || error instanceof import_web_bot_auth2.WebBotAuthUnavailableError) throw error;
+          if (typeof operation !== "string") throw (0, import_web_bot_auth2.webBotAuthPrincipalFailureError)(error);
+          const deferred = (0, import_web_bot_auth2.deferWebBotAuthPrincipalFailure)(signers, error);
+          principal = { principal: deferred.principal };
+          deferredFailure = deferred.authorizationFailure;
+        }
         const signer = signers[signers.length - 1];
         const failed = signers.find((s) => s.authorizationFailure);
         const guardedPrincipal = {
@@ -1484,7 +1493,9 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
             ...principal.extra,
             webBotAuthAuthorization: {
               signer: failed ?? signer,
-              ...failed && { authorizationFailure: failed.authorizationFailure }
+              ...(failed?.authorizationFailure ?? deferredFailure) && {
+                authorizationFailure: failed?.authorizationFailure ?? deferredFailure
+              }
             }
           }
         };
@@ -1495,6 +1506,12 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         });
         return false;
       } catch (error) {
+        if (error instanceof import_web_bot_auth2.WebBotAuthUnavailableError) {
+          const outage = (0, import_web_bot_auth2.webBotAuthUnavailableResponse)();
+          res.writeHead(outage.status, { ...outage.headers, "Content-Type": "application/json" });
+          res.end(JSON.stringify(outage.body));
+          return true;
+        }
         const rejected = error instanceof import_web_bot_auth2.WebBotAuthError ? error : new import_web_bot_auth2.WebBotAuthError(403, "identity_rejected");
         res.writeHead(rejected.status, { ...rejected.headers, "Content-Type": "application/json" });
         res.end(JSON.stringify(rejected.body));
@@ -2981,6 +2998,8 @@ function createAdcpServer(config) {
           try {
             await config.identity33.authorize(ctx, toolName, params);
           } catch (error) {
+            if (error instanceof import_trust.TrustRecordUnavailableError)
+              return finalize((0, import_errors2.adcpError)("SERVICE_UNAVAILABLE", { message: error.message, recovery: "transient" }));
             if (error instanceof import_trust.IdentityAuthorizationError)
               return finalize(
                 (0, import_errors2.adcpError)("PERMISSION_DENIED", {
@@ -4604,6 +4623,8 @@ function createAdcpServer(config) {
         params
       );
     } catch (error) {
+      if (error instanceof import_trust.TrustRecordUnavailableError)
+        return (0, import_errors2.adcpError)("SERVICE_UNAVAILABLE", { message: error.message, recovery: "transient" });
       if (error instanceof import_trust.IdentityAuthorizationError)
         return (0, import_errors2.adcpError)("PERMISSION_DENIED", {
           message: error.message,

package/dist/lib/server/create-adcp-server.mjs

@@ -12,10 +12,15 @@ import {
   webBotAuthToolFailure,
   selectSignatureProfile,
   verifyWebBotAuth,
+  isWebBotAuthRevocationChecked,
+  webBotAuthUnavailableResponse,
+  WebBotAuthUnavailableError,
+  deferWebBotAuthPrincipalFailure,
+  webBotAuthPrincipalFailureError,
   WebBotAuthError
 } from "../signing/web-bot-auth.mjs";
 import { validateIdentity33Payload } from "../identity-3.3/validation.mjs";
-import { IdentityAuthorizationError } from "../identity-3.3/trust.mjs";
+import { IdentityAuthorizationError, TrustRecordUnavailableError } from "../identity-3.3/trust.mjs";
 import { z } from "zod";
 import {
   COMPATIBLE_ADCP_VERSIONS,
@@ -1516,6 +1521,10 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
     throw new Error(
       "Web Bot Auth requires an origin-binding migration fence; use createIdentity33PrincipalResolver or supply assertLegacyOriginAllowed"
     );
+  if (signedRequests.webBotAuth && !signedRequests.webBotAuth.isRevoked && !isWebBotAuthRevocationChecked(signedRequests.webBotAuth.resolvePrincipal))
+    throw new Error(
+      "Web Bot Auth requires origin revocation: use createIdentity33PrincipalResolver({ revocation }) or supply isRevoked"
+    );
   const requiredFor = effectiveRequestSigning.required_for ?? [];
   const verifier = createExpressVerifier({
     capability: {
@@ -1545,20 +1554,25 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         const signers = await verifyWebBotAuth(
           { method: req.method ?? "POST", url: requestTarget, headers: req.headers, body: req.rawBody ?? "" },
           {
+            // Identity verification needs only key discovery and replay state;
+            // revocation and binding belong to the principal resolver.
             directory: signedRequests.webBotAuth.directory,
-            deferAuthorizationErrors: typeof resolveRequestOperation({ rawBody: req.rawBody, method: req.method, url: req.url }) === "string",
             replayStore: signedRequests.replayStore,
-            isRevoked: signedRequests.webBotAuth.isRevoked,
-            requireFreshRevocation: ![
-              "get_adcp_capabilities",
-              "get_principal",
-              "list_creative_formats",
-              "list_accounts"
-            ].includes(String(resolveRequestOperation({ rawBody: req.rawBody, method: req.method, url: req.url })))
+            ...signedRequests.webBotAuth.isRevoked && { isRevoked: signedRequests.webBotAuth.isRevoked }
           }
         );
         const operation = resolveRequestOperation({ rawBody: req.rawBody, method: req.method, url: req.url });
-        const principal = await signedRequests.webBotAuth.resolvePrincipal(signers, operation);
+        let principal;
+        let deferredFailure;
+        try {
+          principal = await signedRequests.webBotAuth.resolvePrincipal(signers, operation);
+        } catch (error) {
+          if (error instanceof WebBotAuthError || error instanceof WebBotAuthUnavailableError) throw error;
+          if (typeof operation !== "string") throw webBotAuthPrincipalFailureError(error);
+          const deferred = deferWebBotAuthPrincipalFailure(signers, error);
+          principal = { principal: deferred.principal };
+          deferredFailure = deferred.authorizationFailure;
+        }
         const signer = signers[signers.length - 1];
         const failed = signers.find((s) => s.authorizationFailure);
         const guardedPrincipal = {
@@ -1567,7 +1581,9 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
             ...principal.extra,
             webBotAuthAuthorization: {
               signer: failed ?? signer,
-              ...failed && { authorizationFailure: failed.authorizationFailure }
+              ...(failed?.authorizationFailure ?? deferredFailure) && {
+                authorizationFailure: failed?.authorizationFailure ?? deferredFailure
+              }
             }
           }
         };
@@ -1578,6 +1594,12 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
         });
         return false;
       } catch (error) {
+        if (error instanceof WebBotAuthUnavailableError) {
+          const outage = webBotAuthUnavailableResponse();
+          res.writeHead(outage.status, { ...outage.headers, "Content-Type": "application/json" });
+          res.end(JSON.stringify(outage.body));
+          return true;
+        }
         const rejected = error instanceof WebBotAuthError ? error : new WebBotAuthError(403, "identity_rejected");
         res.writeHead(rejected.status, { ...rejected.headers, "Content-Type": "application/json" });
         res.end(JSON.stringify(rejected.body));
@@ -3064,6 +3086,8 @@ function createAdcpServer(config) {
           try {
             await config.identity33.authorize(ctx, toolName, params);
           } catch (error) {
+            if (error instanceof TrustRecordUnavailableError)
+              return finalize(adcpError("SERVICE_UNAVAILABLE", { message: error.message, recovery: "transient" }));
             if (error instanceof IdentityAuthorizationError)
               return finalize(
                 adcpError("PERMISSION_DENIED", {
@@ -4687,6 +4711,8 @@ function createAdcpServer(config) {
         params
       );
     } catch (error) {
+      if (error instanceof TrustRecordUnavailableError)
+        return adcpError("SERVICE_UNAVAILABLE", { message: error.message, recovery: "transient" });
       if (error instanceof IdentityAuthorizationError)
         return adcpError("PERMISSION_DENIED", {
           message: error.message,

package/dist/lib/signing/crypto.d.mts

@@ -2,3 +2,18 @@ import { type KeyObject } from 'crypto';
 import type { AdcpJsonWebKey } from './types.mjs';
 export declare function jwkToPublicKey(jwk: AdcpJsonWebKey): KeyObject;
 export declare function verifySignature(alg: string, publicKey: KeyObject, data: Uint8Array, signature: Uint8Array): boolean;
+/**
+ * Verify with WebCrypto when available. ES256 uses `crypto.subtle`, whose
+ * ECDSA signatures are IEEE P1363 (r||s) natively, so edge runtimes such as
+ * Cloudflare workerd verify without node:crypto option-shape differences
+ * (#3243). Other algorithms, and runtimes without WebCrypto, use
+ * {@link verifySignature}.
+ */
+export declare function verifySignatureAsync(alg: string, publicKey: KeyObject | AdcpJsonWebKey, data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+/**
+ * Sign with a private JWK. ES256 output is IEEE P1363 (r||s). The node:crypto
+ * path passes the key as a JWK so workerd accepts it (#3243).
+ */
+export declare function signWithPrivateJwk(alg: string, privateJwk: AdcpJsonWebKey, data: Uint8Array): Uint8Array;
+/** {@link signWithPrivateJwk}, preferring WebCrypto for ES256 when available. */
+export declare function signWithPrivateJwkAsync(alg: string, privateJwk: AdcpJsonWebKey, data: Uint8Array): Promise<Uint8Array>;

package/dist/lib/signing/crypto.d.ts

@@ -2,3 +2,18 @@ import { type KeyObject } from 'crypto';
 import type { AdcpJsonWebKey } from './types';
 export declare function jwkToPublicKey(jwk: AdcpJsonWebKey): KeyObject;
 export declare function verifySignature(alg: string, publicKey: KeyObject, data: Uint8Array, signature: Uint8Array): boolean;
+/**
+ * Verify with WebCrypto when available. ES256 uses `crypto.subtle`, whose
+ * ECDSA signatures are IEEE P1363 (r||s) natively, so edge runtimes such as
+ * Cloudflare workerd verify without node:crypto option-shape differences
+ * (#3243). Other algorithms, and runtimes without WebCrypto, use
+ * {@link verifySignature}.
+ */
+export declare function verifySignatureAsync(alg: string, publicKey: KeyObject | AdcpJsonWebKey, data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+/**
+ * Sign with a private JWK. ES256 output is IEEE P1363 (r||s). The node:crypto
+ * path passes the key as a JWK so workerd accepts it (#3243).
+ */
+export declare function signWithPrivateJwk(alg: string, privateJwk: AdcpJsonWebKey, data: Uint8Array): Uint8Array;
+/** {@link signWithPrivateJwk}, preferring WebCrypto for ES256 when available. */
+export declare function signWithPrivateJwkAsync(alg: string, privateJwk: AdcpJsonWebKey, data: Uint8Array): Promise<Uint8Array>;

package/dist/lib/signing/crypto.js

@@ -19,7 +19,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var crypto_exports = {};
 __export(crypto_exports, {
   jwkToPublicKey: () => jwkToPublicKey,
-  verifySignature: () => verifySignature
+  signWithPrivateJwk: () => signWithPrivateJwk,
+  signWithPrivateJwkAsync: () => signWithPrivateJwkAsync,
+  verifySignature: () => verifySignature,
+  verifySignatureAsync: () => verifySignatureAsync
 });
 module.exports = __toCommonJS(crypto_exports);
 var import_crypto = require("crypto");
@@ -45,15 +48,92 @@ function verifySignature(alg, publicKey, data, signature) {
       return (0, import_crypto.verify)(null, data, publicKey, signature);
     }
     if (alg === "ecdsa-p256-sha256") {
-      return (0, import_crypto.verify)("sha256", data, { key: publicKey, dsaEncoding: "ieee-p1363" }, signature);
+      try {
+        return (0, import_crypto.verify)("sha256", data, { key: publicKey, dsaEncoding: "ieee-p1363" }, signature);
+      } catch {
+        return (0, import_crypto.verify)(
+          "sha256",
+          data,
+          { key: publicKey.export({ format: "jwk" }), format: "jwk", dsaEncoding: "ieee-p1363" },
+          signature
+        );
+      }
+    }
+    if (alg === "rsa-pss-sha512") {
+      return (0, import_crypto.verify)(
+        "sha512",
+        data,
+        { key: publicKey, padding: import_crypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: 64 },
+        signature
+      );
     }
     return false;
   } catch {
     return false;
   }
 }
+function subtleCrypto() {
+  const subtle = globalThis.crypto?.subtle;
+  return subtle && typeof subtle.importKey === "function" ? subtle : void 0;
+}
+const P256 = { name: "ECDSA", namedCurve: "P-256" };
+const P256_SHA256 = { name: "ECDSA", hash: "SHA-256" };
+function publicP256Jwk(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y };
+}
+function privateP256Jwk(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y, d: jwk.d };
+}
+async function verifySignatureAsync(alg, publicKey, data, signature) {
+  const subtle = subtleCrypto();
+  const keyObject = () => isKeyObject(publicKey) ? publicKey : jwkToPublicKey(publicKey);
+  if (alg !== "ecdsa-p256-sha256" || !subtle) return verifySignature(alg, keyObject(), data, signature);
+  try {
+    const jwk = isKeyObject(publicKey) ? publicKey.export({ format: "jwk" }) : publicKey;
+    const key = await importP256VerifyKey(subtle, jwk);
+    return await subtle.verify(P256_SHA256, key, toArrayBuffer(signature), toArrayBuffer(data));
+  } catch {
+    return false;
+  }
+}
+function isKeyObject(value) {
+  return typeof value?.export === "function" && "asymmetricKeyType" in value;
+}
+const p256VerifyKeys = /* @__PURE__ */ new Map();
+function importP256VerifyKey(subtle, jwk) {
+  if (jwk.kty !== "EC" || jwk.crv !== "P-256" || typeof jwk.x !== "string" || typeof jwk.y !== "string")
+    return Promise.reject(new TypeError("Not a P-256 public key"));
+  const cacheKey = `${jwk.x}.${jwk.y}`;
+  let key = p256VerifyKeys.get(cacheKey);
+  if (!key) {
+    key = subtle.importKey("jwk", publicP256Jwk(jwk), P256, false, ["verify"]);
+    key.catch(() => p256VerifyKeys.delete(cacheKey));
+    if (p256VerifyKeys.size >= 256) p256VerifyKeys.delete(p256VerifyKeys.keys().next().value);
+    p256VerifyKeys.set(cacheKey, key);
+  }
+  return key;
+}
+function signWithPrivateJwk(alg, privateJwk, data) {
+  if (alg === "ed25519")
+    return new Uint8Array((0, import_crypto.sign)(null, data, (0, import_crypto.createPrivateKey)({ key: privateJwk, format: "jwk" })));
+  if (alg === "ecdsa-p256-sha256")
+    return new Uint8Array((0, import_crypto.sign)("sha256", data, { key: privateJwk, format: "jwk", dsaEncoding: "ieee-p1363" }));
+  throw new TypeError(`Unsupported signing algorithm: ${alg}`);
+}
+async function signWithPrivateJwkAsync(alg, privateJwk, data) {
+  const subtle = subtleCrypto();
+  if (alg !== "ecdsa-p256-sha256" || !subtle) return signWithPrivateJwk(alg, privateJwk, data);
+  const key = await subtle.importKey("jwk", privateP256Jwk(privateJwk), P256, false, ["sign"]);
+  return new Uint8Array(await subtle.sign(P256_SHA256, key, toArrayBuffer(data)));
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   jwkToPublicKey,
-  verifySignature
+  signWithPrivateJwk,
+  signWithPrivateJwkAsync,
+  verifySignature,
+  verifySignatureAsync
 });

package/dist/lib/signing/crypto.mjs

@@ -1,4 +1,10 @@
-import { createPublicKey, verify as nodeVerify } from "crypto";
+import {
+  constants,
+  createPrivateKey,
+  createPublicKey,
+  sign as nodeSign,
+  verify as nodeVerify
+} from "crypto";
 import { RequestSignatureError } from "./errors.mjs";
 function jwkToPublicKey(jwk) {
   const publicJwk = { ...jwk };
@@ -21,14 +27,91 @@ function verifySignature(alg, publicKey, data, signature) {
       return nodeVerify(null, data, publicKey, signature);
     }
     if (alg === "ecdsa-p256-sha256") {
-      return nodeVerify("sha256", data, { key: publicKey, dsaEncoding: "ieee-p1363" }, signature);
+      try {
+        return nodeVerify("sha256", data, { key: publicKey, dsaEncoding: "ieee-p1363" }, signature);
+      } catch {
+        return nodeVerify(
+          "sha256",
+          data,
+          { key: publicKey.export({ format: "jwk" }), format: "jwk", dsaEncoding: "ieee-p1363" },
+          signature
+        );
+      }
+    }
+    if (alg === "rsa-pss-sha512") {
+      return nodeVerify(
+        "sha512",
+        data,
+        { key: publicKey, padding: constants.RSA_PKCS1_PSS_PADDING, saltLength: 64 },
+        signature
+      );
     }
     return false;
   } catch {
     return false;
   }
 }
+function subtleCrypto() {
+  const subtle = globalThis.crypto?.subtle;
+  return subtle && typeof subtle.importKey === "function" ? subtle : void 0;
+}
+const P256 = { name: "ECDSA", namedCurve: "P-256" };
+const P256_SHA256 = { name: "ECDSA", hash: "SHA-256" };
+function publicP256Jwk(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y };
+}
+function privateP256Jwk(jwk) {
+  return { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y, d: jwk.d };
+}
+async function verifySignatureAsync(alg, publicKey, data, signature) {
+  const subtle = subtleCrypto();
+  const keyObject = () => isKeyObject(publicKey) ? publicKey : jwkToPublicKey(publicKey);
+  if (alg !== "ecdsa-p256-sha256" || !subtle) return verifySignature(alg, keyObject(), data, signature);
+  try {
+    const jwk = isKeyObject(publicKey) ? publicKey.export({ format: "jwk" }) : publicKey;
+    const key = await importP256VerifyKey(subtle, jwk);
+    return await subtle.verify(P256_SHA256, key, toArrayBuffer(signature), toArrayBuffer(data));
+  } catch {
+    return false;
+  }
+}
+function isKeyObject(value) {
+  return typeof value?.export === "function" && "asymmetricKeyType" in value;
+}
+const p256VerifyKeys = /* @__PURE__ */ new Map();
+function importP256VerifyKey(subtle, jwk) {
+  if (jwk.kty !== "EC" || jwk.crv !== "P-256" || typeof jwk.x !== "string" || typeof jwk.y !== "string")
+    return Promise.reject(new TypeError("Not a P-256 public key"));
+  const cacheKey = `${jwk.x}.${jwk.y}`;
+  let key = p256VerifyKeys.get(cacheKey);
+  if (!key) {
+    key = subtle.importKey("jwk", publicP256Jwk(jwk), P256, false, ["verify"]);
+    key.catch(() => p256VerifyKeys.delete(cacheKey));
+    if (p256VerifyKeys.size >= 256) p256VerifyKeys.delete(p256VerifyKeys.keys().next().value);
+    p256VerifyKeys.set(cacheKey, key);
+  }
+  return key;
+}
+function signWithPrivateJwk(alg, privateJwk, data) {
+  if (alg === "ed25519")
+    return new Uint8Array(nodeSign(null, data, createPrivateKey({ key: privateJwk, format: "jwk" })));
+  if (alg === "ecdsa-p256-sha256")
+    return new Uint8Array(nodeSign("sha256", data, { key: privateJwk, format: "jwk", dsaEncoding: "ieee-p1363" }));
+  throw new TypeError(`Unsupported signing algorithm: ${alg}`);
+}
+async function signWithPrivateJwkAsync(alg, privateJwk, data) {
+  const subtle = subtleCrypto();
+  if (alg !== "ecdsa-p256-sha256" || !subtle) return signWithPrivateJwk(alg, privateJwk, data);
+  const key = await subtle.importKey("jwk", privateP256Jwk(privateJwk), P256, false, ["sign"]);
+  return new Uint8Array(await subtle.sign(P256_SHA256, key, toArrayBuffer(data)));
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
 export {
   jwkToPublicKey,
-  verifySignature
+  signWithPrivateJwk,
+  signWithPrivateJwkAsync,
+  verifySignature,
+  verifySignatureAsync
 };

package/dist/lib/signing/fetch-async.js

@@ -82,7 +82,7 @@ function bodyToString(body) {
 }
 function decodeUtf8Strict(bytes) {
   try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
   } catch {
     throw new TypeError(
       "createSigningFetchAsync received a Uint8Array/ArrayBuffer body that is not valid UTF-8. Pass a string body, ensure the bytes are UTF-8, or sign the request manually with `signRequestAsync` against the exact wire bytes you intend to send."

package/dist/lib/signing/fetch-async.mjs

@@ -61,7 +61,7 @@ function bodyToString(body) {
 }
 function decodeUtf8Strict(bytes) {
   try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
   } catch {
     throw new TypeError(
       "createSigningFetchAsync received a Uint8Array/ArrayBuffer body that is not valid UTF-8. Pass a string body, ensure the bytes are UTF-8, or sign the request manually with `signRequestAsync` against the exact wire bytes you intend to send."

package/dist/lib/signing/fetch.js

@@ -91,7 +91,7 @@ function bodyToString(body) {
 }
 function decodeUtf8Strict(bytes) {
   try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
   } catch {
     throw new TypeError(
       "createSigningFetch received a Uint8Array/ArrayBuffer body that is not valid UTF-8. Pass a string body, ensure the bytes are UTF-8, or sign the request manually with `signRequest` against the exact wire bytes you intend to send."