@adcp/sdk 14.0.0-beta.14 → 14.0.0-beta.15

package/dist/lib/server/webhook-delivery/recovery.mjs

@@ -7,6 +7,12 @@ import {
   assertWebhookDisposition,
   isWebhookDeliveryTerminalError
 } from "./common.mjs";
+class WebhookAuthenticationProtectionError extends Error {
+  name = "WebhookAuthenticationProtectionError";
+}
+class WebhookAuthenticationResolutionError extends Error {
+  name = "WebhookAuthenticationResolutionError";
+}
 function memoryWebhookDeliveryRecoveryBackend(options = {}) {
   const records = /* @__PURE__ */ new Map();
   const now = options.now ?? Date.now;
@@ -116,13 +122,25 @@ function createWebhookDeliveryRecovery(options) {
   return {
     durability: "durable",
     probe: () => options.backend.probe(),
+    async prepare(key, snapshot, prepareOptions) {
+      assertDeliveryKey(key);
+      const stored = await protectSnapshot(
+        snapshot,
+        key,
+        options.authenticationAdapter,
+        prepareOptions?.protectPayloadToken === true
+      );
+      assertStoredSnapshotSize(stored, maxSnapshotBytes);
+      return {
+        snapshot: stored,
+        snapshotFingerprint: snapshotFingerprint(stored),
+        storageFingerprint: canonicalJsonSha256(stored)
+      };
+    },
     async checkpoint(key, snapshot) {
       assertDeliveryKey(key);
-      const stored = await protectSnapshot(snapshot, key, options.authenticationAdapter);
-      const storedBytes = Buffer.byteLength(JSON.stringify(stored));
-      if (storedBytes > maxSnapshotBytes) {
-        throw new TypeError(`Webhook recovery snapshot exceeds maxSnapshotBytes (${maxSnapshotBytes})`);
-      }
+      const stored = await protectSnapshot(snapshot, key, options.authenticationAdapter, false);
+      assertStoredSnapshotSize(stored, maxSnapshotBytes);
       const fingerprint = snapshotFingerprint(stored);
       const storageFingerprint = canonicalJsonSha256(stored);
       const ownerToken = randomUUID();
@@ -294,59 +312,101 @@ function assertPollOutcome(outcome) {
     throw new TypeError("Webhook recovery deliver() returned an invalid disposition");
   }
 }
-async function protectSnapshot(snapshot, key, adapter) {
+async function protectSnapshot(snapshot, key, adapter, protectPayloadToken) {
+  const payload = structuredClone(snapshot.payload);
+  const cleartextPayloadToken = protectPayloadToken && typeof payload.token === "string" ? payload.token : void 0;
+  if (cleartextPayloadToken !== void 0) delete payload.token;
   const base = {
     url: snapshot.url,
-    payload: structuredClone(snapshot.payload),
+    payload,
     retries: { ...snapshot.retries }
   };
   canonicalJsonSha256(base);
-  if (snapshot.authentication === null) return { ...base, authentication: { kind: "none" } };
-  if (!adapter) {
+  if ((snapshot.authentication !== null || cleartextPayloadToken !== void 0) && !adapter) {
     throw new TypeError(
-      "Durable webhook recovery requires authenticationAdapter when bearer or HMAC authentication is present"
+      "Durable webhook recovery requires authenticationAdapter when bearer/HMAC authentication or a payload token is present"
     );
   }
-  const context = authenticationContext(key, base);
-  const protectedAuth = await adapter.protect(structuredClone(snapshot.authentication), context);
-  if (!protectedAuth || typeof protectedAuth.fingerprint !== "string" || protectedAuth.fingerprint.length < 16) {
-    throw new TypeError(
-      "WebhookAuthenticationAdapter.protect() must return a stable fingerprint of at least 16 characters"
-    );
-  }
-  canonicalJsonSha256(protectedAuth.protectedValue);
-  return {
+  const stored = {
     ...base,
-    authentication: {
-      kind: "protected",
-      protectedValue: structuredClone(protectedAuth.protectedValue),
-      fingerprint: protectedAuth.fingerprint
-    }
+    authentication: { kind: "none" }
   };
+  if (snapshot.authentication !== null) {
+    const protectedAuth = await protectAuthentication(
+      adapter,
+      structuredClone(snapshot.authentication),
+      authenticationContext(key, base)
+    );
+    stored.authentication = { kind: "protected", ...protectedAuth };
+  }
+  if (cleartextPayloadToken !== void 0) {
+    const protectedToken = await protectAuthentication(
+      adapter,
+      { type: "bearer", token: cleartextPayloadToken },
+      authenticationContext(key, base, "payload_token")
+    );
+    stored.payloadToken = { kind: "protected", ...protectedToken };
+  }
+  return stored;
 }
 async function resolveSnapshot(snapshot, key, adapter) {
-  let authentication = null;
-  if (snapshot.authentication.kind === "protected") {
-    if (!adapter) throw new Error("Cannot recover protected webhook authentication without authenticationAdapter");
-    authentication = await adapter.resolve(
-      structuredClone(snapshot.authentication.protectedValue),
-      authenticationContext(key, snapshot)
-    );
-    if (authentication === null)
-      throw new Error("WebhookAuthenticationAdapter.resolve() returned null for protected state");
+  try {
+    let authentication = null;
+    if (snapshot.authentication.kind === "protected") {
+      if (!adapter) throw new Error("Cannot recover protected webhook authentication without authenticationAdapter");
+      authentication = await adapter.resolve(
+        structuredClone(snapshot.authentication.protectedValue),
+        authenticationContext(key, snapshot)
+      );
+      if (authentication === null)
+        throw new Error("WebhookAuthenticationAdapter.resolve() returned null for protected state");
+    }
+    const payload = structuredClone(snapshot.payload);
+    if (snapshot.payloadToken) {
+      if (!adapter) throw new Error("Cannot recover protected webhook payload token without authenticationAdapter");
+      const resolved = await adapter.resolve(
+        structuredClone(snapshot.payloadToken.protectedValue),
+        authenticationContext(key, snapshot, "payload_token")
+      );
+      if (resolved?.type !== "bearer" || typeof resolved.token !== "string") {
+        throw new Error("WebhookAuthenticationAdapter.resolve() returned an invalid protected payload token");
+      }
+      payload.token = resolved.token;
+    }
+    return {
+      url: snapshot.url,
+      payload,
+      authentication,
+      retries: { ...snapshot.retries }
+    };
+  } catch (cause) {
+    if (cause instanceof WebhookAuthenticationResolutionError) throw cause;
+    throw new WebhookAuthenticationResolutionError("Webhook authentication resolution failed", { cause });
   }
-  return {
-    url: snapshot.url,
-    payload: structuredClone(snapshot.payload),
-    authentication,
-    retries: { ...snapshot.retries }
-  };
 }
-function authenticationContext(key, snapshot) {
-  return {
+function authenticationContext(key, snapshot, purpose) {
+  const base = {
     key: { ...key },
-    url: snapshot.url,
+    url: snapshot.url
+  };
+  if (purpose === void 0) {
+    return {
+      ...base,
+      // This is the exact pre-payload-token context hash. Do not change it:
+      // applications may bind KMS AAD to this value for pending snapshots.
+      snapshotContextFingerprint: canonicalJsonSha256({
+        key,
+        url: snapshot.url,
+        payload: snapshot.payload,
+        retries: snapshot.retries
+      })
+    };
+  }
+  return {
+    ...base,
+    purpose,
     snapshotContextFingerprint: canonicalJsonSha256({
+      purpose,
       key,
       url: snapshot.url,
       payload: snapshot.payload,
@@ -402,15 +462,56 @@ function snapshotFingerprint(snapshot) {
     url: snapshot.url,
     payload: snapshot.payload,
     retries: snapshot.retries,
-    authentication: snapshot.authentication.kind === "none" ? { kind: "none" } : { kind: "protected", fingerprint: snapshot.authentication.fingerprint }
+    authentication: snapshot.authentication.kind === "none" ? { kind: "none" } : { kind: "protected", fingerprint: snapshot.authentication.fingerprint },
+    ...snapshot.payloadToken && { payloadToken: { fingerprint: snapshot.payloadToken.fingerprint } }
   });
 }
+async function protectAuthentication(adapter, authentication, context) {
+  let protectedAuth;
+  try {
+    protectedAuth = await adapter.protect(authentication, context);
+  } catch (cause) {
+    throw new WebhookAuthenticationProtectionError("Webhook authentication protection failed", { cause });
+  }
+  if (!protectedAuth || typeof protectedAuth.fingerprint !== "string" || protectedAuth.fingerprint.length < 16) {
+    throw new TypeError(
+      "WebhookAuthenticationAdapter.protect() must return a stable fingerprint of at least 16 characters"
+    );
+  }
+  canonicalJsonSha256(protectedAuth.protectedValue);
+  const cleartext = authentication.type === "bearer" ? authentication.token : authentication.secret;
+  if (protectedValueContainsSecret(protectedAuth.protectedValue, cleartext) || protectedAuth.fingerprint.includes(cleartext)) {
+    throw new TypeError("WebhookAuthenticationAdapter.protect() returned durable state containing cleartext");
+  }
+  return {
+    protectedValue: structuredClone(protectedAuth.protectedValue),
+    fingerprint: protectedAuth.fingerprint
+  };
+}
+function protectedValueContainsSecret(value, cleartext) {
+  if (typeof value === "string") return value.includes(cleartext);
+  if (Array.isArray(value)) return value.some((item) => protectedValueContainsSecret(item, cleartext));
+  if (value && typeof value === "object") {
+    return Object.entries(value).some(
+      ([key, item]) => key.includes(cleartext) || protectedValueContainsSecret(item, cleartext)
+    );
+  }
+  return false;
+}
+function assertStoredSnapshotSize(snapshot, maxSnapshotBytes) {
+  const storedBytes = Buffer.byteLength(JSON.stringify(snapshot));
+  if (storedBytes > maxSnapshotBytes) {
+    throw new TypeError(`Webhook recovery snapshot exceeds maxSnapshotBytes (${maxSnapshotBytes})`);
+  }
+}
 function assertLeaseMs(value) {
   if (!Number.isSafeInteger(value) || value < 1e3 || value > 36e5) {
     throw new TypeError("leaseMs must be an integer from 1000 through 3600000");
   }
 }
 export {
+  WebhookAuthenticationProtectionError,
+  WebhookAuthenticationResolutionError,
   createWebhookDeliveryRecovery,
   memoryWebhookDeliveryRecoveryBackend,
   pollWebhookDeliveryRecovery

package/dist/lib/signing/agent-resolver/index.d.mts

@@ -17,7 +17,7 @@
  */
 export { resolveAgent } from './resolve-agent.mjs';
 export { ResolvedAgentJwksResolver } from './resolved-agent-jwks.mjs';
-export type { AgentResolution, AgentProtocol, AuthorizedOperatorScope, FetchCapabilitiesFn, ResolveAgentOptions, TraceStep, } from './resolve-agent.mjs';
+export type { AgentResolution, AgentProtocol, AuthorizedOperatorScope, DelegatedOperatorAuthorizationContext, FetchCapabilitiesFn, ResolveAgentOptions, TraceStep, } from './resolve-agent.mjs';
 export type { ResolvedAgentJwksResolverOptions } from './resolved-agent-jwks.mjs';
 export { getAgentJwks, createAgentJwksSet } from './jwks-set.mjs';
 export type { AgentJwksResult, GetAgentJwksOptions, CreateAgentJwksSetOptions } from './jwks-set.mjs';

package/dist/lib/signing/agent-resolver/index.d.ts

@@ -17,7 +17,7 @@
  */
 export { resolveAgent } from './resolve-agent';
 export { ResolvedAgentJwksResolver } from './resolved-agent-jwks';
-export type { AgentResolution, AgentProtocol, AuthorizedOperatorScope, FetchCapabilitiesFn, ResolveAgentOptions, TraceStep, } from './resolve-agent';
+export type { AgentResolution, AgentProtocol, AuthorizedOperatorScope, DelegatedOperatorAuthorizationContext, FetchCapabilitiesFn, ResolveAgentOptions, TraceStep, } from './resolve-agent';
 export type { ResolvedAgentJwksResolverOptions } from './resolved-agent-jwks';
 export { getAgentJwks, createAgentJwksSet } from './jwks-set';
 export type { AgentJwksResult, GetAgentJwksOptions, CreateAgentJwksSetOptions } from './jwks-set';

package/dist/lib/signing/agent-resolver/resolve-agent.d.mts

@@ -33,6 +33,15 @@ import { type AgentResolverErrorDetail } from './errors.mjs';
 import { type AgentEntry } from './select-agent.mjs';
 export type AgentProtocol = 'mcp' | 'a2a';
 export type AuthorizedOperatorScope = 'media_buying' | 'creative_generation' | 'rights_clearance' | 'governance' | 'measurement' | 'agent_operations';
+/**
+ * Trusted local context selecting one delegated-operator authorization tuple.
+ * This is receiver policy, never counterparty-supplied wire data.
+ */
+export interface DelegatedOperatorAuthorizationContext {
+    brand?: string;
+    scope?: AuthorizedOperatorScope;
+    country?: string;
+}
 export interface FetchCapabilitiesFn {
     (agentUrl: string): Promise<unknown>;
 }

package/dist/lib/signing/agent-resolver/resolve-agent.d.ts

@@ -33,6 +33,15 @@ import { type AgentResolverErrorDetail } from './errors';
 import { type AgentEntry } from './select-agent';
 export type AgentProtocol = 'mcp' | 'a2a';
 export type AuthorizedOperatorScope = 'media_buying' | 'creative_generation' | 'rights_clearance' | 'governance' | 'measurement' | 'agent_operations';
+/**
+ * Trusted local context selecting one delegated-operator authorization tuple.
+ * This is receiver policy, never counterparty-supplied wire data.
+ */
+export interface DelegatedOperatorAuthorizationContext {
+    brand?: string;
+    scope?: AuthorizedOperatorScope;
+    country?: string;
+}
 export interface FetchCapabilitiesFn {
     (agentUrl: string): Promise<unknown>;
 }

package/dist/lib/signing/agent-resolver/resolved-agent-jwks.d.mts

@@ -1,5 +1,5 @@
 import type { AdcpJsonWebKey } from '../types.mjs';
-import type { JwksResolver } from '../jwks.mjs';
+import type { JwksResolution, JwksResolver } from '../jwks.mjs';
 import { type AgentProtocol, type AgentResolution, type ResolveAgentOptions } from './resolve-agent.mjs';
 export interface ResolvedAgentJwksResolverOptions extends Pick<ResolveAgentOptions, 'fetchCapabilities' | 'allowPrivateIp' | 'bodyCaps' | 'timeoutMs' | 'now' | 'requiredOperatorBrand' | 'requiredOperatorScope' | 'requiredOperatorCountry'> {
     /** Positive cache lifetime in seconds. Defaults to 300. */
@@ -20,9 +20,12 @@ export declare class ResolvedAgentJwksResolver implements JwksResolver {
     private readonly resolveAgentFn;
     private keys;
     private expiresAt;
+    private operatorAuthorizationValidUntil?;
     private lastUnknownKidRefresh;
     private inFlight?;
     constructor(agentUrl: string, protocol: AgentProtocol, options?: ResolvedAgentJwksResolverOptions);
     resolve(keyid: string): Promise<AdcpJsonWebKey | null>;
+    resolveWithMetadata(keyid: string): Promise<JwksResolution>;
+    private resolution;
     private refresh;
 }

package/dist/lib/signing/agent-resolver/resolved-agent-jwks.d.ts

@@ -1,5 +1,5 @@
 import type { AdcpJsonWebKey } from '../types';
-import type { JwksResolver } from '../jwks';
+import type { JwksResolution, JwksResolver } from '../jwks';
 import { type AgentProtocol, type AgentResolution, type ResolveAgentOptions } from './resolve-agent';
 export interface ResolvedAgentJwksResolverOptions extends Pick<ResolveAgentOptions, 'fetchCapabilities' | 'allowPrivateIp' | 'bodyCaps' | 'timeoutMs' | 'now' | 'requiredOperatorBrand' | 'requiredOperatorScope' | 'requiredOperatorCountry'> {
     /** Positive cache lifetime in seconds. Defaults to 300. */
@@ -20,9 +20,12 @@ export declare class ResolvedAgentJwksResolver implements JwksResolver {
     private readonly resolveAgentFn;
     private keys;
     private expiresAt;
+    private operatorAuthorizationValidUntil?;
     private lastUnknownKidRefresh;
     private inFlight?;
     constructor(agentUrl: string, protocol: AgentProtocol, options?: ResolvedAgentJwksResolverOptions);
     resolve(keyid: string): Promise<AdcpJsonWebKey | null>;
+    resolveWithMetadata(keyid: string): Promise<JwksResolution>;
+    private resolution;
     private refresh;
 }

package/dist/lib/signing/agent-resolver/resolved-agent-jwks.js

@@ -48,9 +48,13 @@ class ResolvedAgentJwksResolver {
   resolveAgentFn;
   keys = /* @__PURE__ */ new Map();
   expiresAt = 0;
+  operatorAuthorizationValidUntil;
   lastUnknownKidRefresh = Number.NEGATIVE_INFINITY;
   inFlight;
   async resolve(keyid) {
+    return (await this.resolveWithMetadata(keyid)).jwk;
+  }
+  async resolveWithMetadata(keyid) {
     const now = this.now();
     let refreshed = false;
     if (now >= this.expiresAt) {
@@ -58,15 +62,23 @@ class ResolvedAgentJwksResolver {
       refreshed = true;
     }
     const cached = this.keys.get(keyid);
-    if (cached) return cached;
+    if (cached) return this.resolution(cached);
     if (refreshed) {
       this.lastUnknownKidRefresh = now;
-      return null;
+      return this.resolution(null);
     }
-    if (now - this.lastUnknownKidRefresh < this.unknownKidCooldownSeconds) return null;
+    if (now - this.lastUnknownKidRefresh < this.unknownKidCooldownSeconds) return this.resolution(null);
     await this.refresh();
     this.lastUnknownKidRefresh = now;
-    return this.keys.get(keyid) ?? null;
+    return this.resolution(this.keys.get(keyid) ?? null);
+  }
+  resolution(jwk) {
+    return {
+      jwk,
+      ...this.operatorAuthorizationValidUntil !== void 0 && {
+        operatorAuthorizationValidUntil: this.operatorAuthorizationValidUntil
+      }
+    };
   }
   async refresh() {
     if (this.inFlight) return this.inFlight;
@@ -104,6 +116,7 @@ class ResolvedAgentJwksResolver {
         }
       }
       this.keys = next;
+      this.operatorAuthorizationValidUntil = resolution.operatorAuthorizationValidUntil;
       this.expiresAt = Math.min(
         refreshedAt + this.cacheTtlSeconds,
         resolution.operatorAuthorizationValidUntil ?? Number.POSITIVE_INFINITY

package/dist/lib/signing/agent-resolver/resolved-agent-jwks.mjs

@@ -25,9 +25,13 @@ class ResolvedAgentJwksResolver {
   resolveAgentFn;
   keys = /* @__PURE__ */ new Map();
   expiresAt = 0;
+  operatorAuthorizationValidUntil;
   lastUnknownKidRefresh = Number.NEGATIVE_INFINITY;
   inFlight;
   async resolve(keyid) {
+    return (await this.resolveWithMetadata(keyid)).jwk;
+  }
+  async resolveWithMetadata(keyid) {
     const now = this.now();
     let refreshed = false;
     if (now >= this.expiresAt) {
@@ -35,15 +39,23 @@ class ResolvedAgentJwksResolver {
       refreshed = true;
     }
     const cached = this.keys.get(keyid);
-    if (cached) return cached;
+    if (cached) return this.resolution(cached);
     if (refreshed) {
       this.lastUnknownKidRefresh = now;
-      return null;
+      return this.resolution(null);
     }
-    if (now - this.lastUnknownKidRefresh < this.unknownKidCooldownSeconds) return null;
+    if (now - this.lastUnknownKidRefresh < this.unknownKidCooldownSeconds) return this.resolution(null);
     await this.refresh();
     this.lastUnknownKidRefresh = now;
-    return this.keys.get(keyid) ?? null;
+    return this.resolution(this.keys.get(keyid) ?? null);
+  }
+  resolution(jwk) {
+    return {
+      jwk,
+      ...this.operatorAuthorizationValidUntil !== void 0 && {
+        operatorAuthorizationValidUntil: this.operatorAuthorizationValidUntil
+      }
+    };
   }
   async refresh() {
     if (this.inFlight) return this.inFlight;
@@ -81,6 +93,7 @@ class ResolvedAgentJwksResolver {
         }
       }
       this.keys = next;
+      this.operatorAuthorizationValidUntil = resolution.operatorAuthorizationValidUntil;
       this.expiresAt = Math.min(
         refreshedAt + this.cacheTtlSeconds,
         resolution.operatorAuthorizationValidUntil ?? Number.POSITIVE_INFINITY

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

@@ -1,6 +1,13 @@
 import type { AdcpJsonWebKey } from './types.mjs';
+export interface JwksResolution {
+    jwk: AdcpJsonWebKey | null;
+    /** Epoch seconds for a delegated-operator authorization boundary, when applicable. */
+    operatorAuthorizationValidUntil?: number;
+}
 export interface JwksResolver {
     resolve(keyid: string): Promise<AdcpJsonWebKey | null>;
+    /** Optional metadata-aware lookup used by verifiers that must enforce delegation expiry at acceptance time. */
+    resolveWithMetadata?(keyid: string): Promise<JwksResolution>;
 }
 export declare class StaticJwksResolver implements JwksResolver {
     private readonly byKid;

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

@@ -1,6 +1,13 @@
 import type { AdcpJsonWebKey } from './types';
+export interface JwksResolution {
+    jwk: AdcpJsonWebKey | null;
+    /** Epoch seconds for a delegated-operator authorization boundary, when applicable. */
+    operatorAuthorizationValidUntil?: number;
+}
 export interface JwksResolver {
     resolve(keyid: string): Promise<AdcpJsonWebKey | null>;
+    /** Optional metadata-aware lookup used by verifiers that must enforce delegation expiry at acceptance time. */
+    resolveWithMetadata?(keyid: string): Promise<JwksResolution>;
 }
 export declare class StaticJwksResolver implements JwksResolver {
     private readonly byKid;

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

@@ -13,7 +13,7 @@ export { computeContentDigest, contentDigestMatches, parseContentDigest } from '
 export { requestContextFromExpress, requestContextFromFetch, requestContextFromLambda, type ExpressRequestLike, type FetchRequestLike, type LambdaRequestEvent, type RequestContextFromExpressOptions, type RequestContextFromLambdaOptions, } from './request-context.mjs';
 export { jwkToPublicKey, verifySignature } from './crypto.mjs';
 export { RequestSignatureError, type RequestSignatureErrorCode, ResponseSignatureError, type ResponseSignatureErrorCode, WebhookSignatureError, type WebhookSignatureErrorCode, } from './errors.mjs';
-export { StaticJwksResolver, type JwksResolver } from './jwks.mjs';
+export { StaticJwksResolver, type JwksResolution, type JwksResolver } from './jwks.mjs';
 export { HttpsJwksResolver, type HttpsJwksResolverOptions } from './jwks-https.mjs';
 export { BrandJsonJwksResolver, BrandJsonResolverError, type BrandAgentType, type BrandJsonJwksResolverOptions, type BrandJsonResolverErrorCode, } from './brand-jwks.mjs';
 export { parseSignature, parseSignatureInput, type ParsedSignature, type ParsedSignatureInput } from './parser.mjs';
@@ -28,4 +28,4 @@ export { createWebhookVerifier, isWebhookLoopbackHost, verifyWebhookSignature, W
 export { createExpressVerifier, type ExpressLike, type ExpressMiddlewareOptions } from './middleware.mjs';
 export { finalizeResponseSignature, prepareResponseSignature, signResponse, type PreparedResponseSignature, type SignedResponse, type SignResponseOptions, } from './signer.mjs';
 export { signResponseAsync } from './signer-async.mjs';
-export { resolveAgent, ResolvedAgentJwksResolver, getAgentJwks, createAgentJwksSet, AgentResolverError, attackerInfluencedFields, ATTACKER_INFLUENCED, readBrandJsonUrl, readIdentityPosture, type AgentResolution, type AgentProtocol, type AuthorizedOperatorScope, type AgentResolverErrorCode, type AgentResolverErrorDetail, type AgentEntry, type AgentJwksResult, type CapabilitiesWithBrandJsonUrl, type CreateAgentJwksSetOptions, type FetchCapabilitiesFn, type GetAgentJwksOptions, type IdentityKeyOriginPurpose, type IdentityKeyOrigins, type IdentityPosture, type ResolveAgentOptions, type ResolvedAgentJwksResolverOptions, type TraceStep, } from './agent-resolver/index.mjs';
+export { resolveAgent, ResolvedAgentJwksResolver, getAgentJwks, createAgentJwksSet, AgentResolverError, attackerInfluencedFields, ATTACKER_INFLUENCED, readBrandJsonUrl, readIdentityPosture, type AgentResolution, type AgentProtocol, type AuthorizedOperatorScope, type DelegatedOperatorAuthorizationContext, type AgentResolverErrorCode, type AgentResolverErrorDetail, type AgentEntry, type AgentJwksResult, type CapabilitiesWithBrandJsonUrl, type CreateAgentJwksSetOptions, type FetchCapabilitiesFn, type GetAgentJwksOptions, type IdentityKeyOriginPurpose, type IdentityKeyOrigins, type IdentityPosture, type ResolveAgentOptions, type ResolvedAgentJwksResolverOptions, type TraceStep, } from './agent-resolver/index.mjs';

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

@@ -13,7 +13,7 @@ export { computeContentDigest, contentDigestMatches, parseContentDigest } from '
 export { requestContextFromExpress, requestContextFromFetch, requestContextFromLambda, type ExpressRequestLike, type FetchRequestLike, type LambdaRequestEvent, type RequestContextFromExpressOptions, type RequestContextFromLambdaOptions, } from './request-context';
 export { jwkToPublicKey, verifySignature } from './crypto';
 export { RequestSignatureError, type RequestSignatureErrorCode, ResponseSignatureError, type ResponseSignatureErrorCode, WebhookSignatureError, type WebhookSignatureErrorCode, } from './errors';
-export { StaticJwksResolver, type JwksResolver } from './jwks';
+export { StaticJwksResolver, type JwksResolution, type JwksResolver } from './jwks';
 export { HttpsJwksResolver, type HttpsJwksResolverOptions } from './jwks-https';
 export { BrandJsonJwksResolver, BrandJsonResolverError, type BrandAgentType, type BrandJsonJwksResolverOptions, type BrandJsonResolverErrorCode, } from './brand-jwks';
 export { parseSignature, parseSignatureInput, type ParsedSignature, type ParsedSignatureInput } from './parser';
@@ -28,4 +28,4 @@ export { createWebhookVerifier, isWebhookLoopbackHost, verifyWebhookSignature, W
 export { createExpressVerifier, type ExpressLike, type ExpressMiddlewareOptions } from './middleware';
 export { finalizeResponseSignature, prepareResponseSignature, signResponse, type PreparedResponseSignature, type SignedResponse, type SignResponseOptions, } from './signer';
 export { signResponseAsync } from './signer-async';
-export { resolveAgent, ResolvedAgentJwksResolver, getAgentJwks, createAgentJwksSet, AgentResolverError, attackerInfluencedFields, ATTACKER_INFLUENCED, readBrandJsonUrl, readIdentityPosture, type AgentResolution, type AgentProtocol, type AuthorizedOperatorScope, type AgentResolverErrorCode, type AgentResolverErrorDetail, type AgentEntry, type AgentJwksResult, type CapabilitiesWithBrandJsonUrl, type CreateAgentJwksSetOptions, type FetchCapabilitiesFn, type GetAgentJwksOptions, type IdentityKeyOriginPurpose, type IdentityKeyOrigins, type IdentityPosture, type ResolveAgentOptions, type ResolvedAgentJwksResolverOptions, type TraceStep, } from './agent-resolver';
+export { resolveAgent, ResolvedAgentJwksResolver, getAgentJwks, createAgentJwksSet, AgentResolverError, attackerInfluencedFields, ATTACKER_INFLUENCED, readBrandJsonUrl, readIdentityPosture, type AgentResolution, type AgentProtocol, type AuthorizedOperatorScope, type DelegatedOperatorAuthorizationContext, type AgentResolverErrorCode, type AgentResolverErrorDetail, type AgentEntry, type AgentJwksResult, type CapabilitiesWithBrandJsonUrl, type CreateAgentJwksSetOptions, type FetchCapabilitiesFn, type GetAgentJwksOptions, type IdentityKeyOriginPurpose, type IdentityKeyOrigins, type IdentityPosture, type ResolveAgentOptions, type ResolvedAgentJwksResolverOptions, type TraceStep, } from './agent-resolver';

package/dist/lib/signing/webhook-verifier.d.mts

@@ -53,6 +53,12 @@ export interface VerifyWebhookOptions {
     requiredTag?: string;
     /** Optional reverse-lookup (kid → publisher URL) for result attribution. */
     agentUrlForKeyid?: (keyid: string) => string | undefined;
+    /**
+     * Trusted local discriminator appended to replay accounting. Receivers use
+     * this to isolate registrations authorized under different delegated-
+     * operator tuples even when they share a callback URL and signing key.
+     */
+    replayScopeBinding?: string;
 }
 export interface VerifyWebhookResult {
     status: 'verified';

package/dist/lib/signing/webhook-verifier.d.ts

@@ -53,6 +53,12 @@ export interface VerifyWebhookOptions {
     requiredTag?: string;
     /** Optional reverse-lookup (kid → publisher URL) for result attribution. */
     agentUrlForKeyid?: (keyid: string) => string | undefined;
+    /**
+     * Trusted local discriminator appended to replay accounting. Receivers use
+     * this to isolate registrations authorized under different delegated-
+     * operator tuples even when they share a callback URL and signing key.
+     */
+    replayScopeBinding?: string;
 }
 export interface VerifyWebhookResult {
     status: 'verified';

package/dist/lib/signing/webhook-verifier.js

@@ -42,7 +42,8 @@ const WEBHOOK_MANDATORY_COMPONENTS = [
   "content-digest"
 ];
 async function verifyWebhookSignature(request, options) {
-  const now = options.now ? options.now() : Math.floor(Date.now() / 1e3);
+  const currentTime = options.now ?? (() => Date.now() / 1e3);
+  const now = currentTime();
   const requiredTag = options.requiredTag ?? WEBHOOK_SIGNING_TAG;
   const sigInputHeader = (0, import_canonicalize.getHeaderValue)(request.headers, "Signature-Input");
   const sigHeader = (0, import_canonicalize.getHeaderValue)(request.headers, "Signature");
@@ -83,7 +84,8 @@ async function verifyWebhookSignature(request, options) {
   validateWindow(parsedInput.params.created, parsedInput.params.expires, now);
   validateCoveredComponents(parsedInput.components);
   const canonicalWebhookTarget = validateTargetUri(request.url);
-  const jwk = await options.jwks.resolve(parsedInput.params.keyid);
+  const keyResolution = options.jwks.resolveWithMetadata ? await options.jwks.resolveWithMetadata(parsedInput.params.keyid) : { jwk: await options.jwks.resolve(parsedInput.params.keyid) };
+  const jwk = keyResolution.jwk;
   if (!jwk) {
     throw new import_errors.WebhookSignatureError(
       "webhook_signature_key_unknown",
@@ -98,6 +100,9 @@ async function verifyWebhookSignature(request, options) {
       `JWKS resolver returned a JWK whose kid "${jwk.kid}" does not match requested keyid "${parsedInput.params.keyid}".`
     );
   }
+  if (keyResolution.operatorAuthorizationValidUntil !== void 0) {
+    assertDelegatedOperatorAuthorizationActive(keyResolution.operatorAuthorizationValidUntil, currentTime());
+  }
   if (jwk.adcp_use === void 0 || !jwk.key_ops?.includes("verify") || jwk.adcp_use !== "request-signing" && jwk.adcp_use !== "webhook-signing") {
     throw new import_errors.WebhookSignatureError(
       "webhook_signature_key_purpose_invalid",
@@ -115,7 +120,7 @@ async function verifyWebhookSignature(request, options) {
     }
     throw err;
   }
-  const replayScope = canonicalWebhookTarget;
+  const replayScope = replayScopeForWebhook(canonicalWebhookTarget, options.replayScopeBinding);
   if (await options.replayStore.has(jwk.kid, replayScope, parsedInput.params.nonce, now)) {
     throw new import_errors.WebhookSignatureError(
       "webhook_signature_replayed",
@@ -161,6 +166,9 @@ async function verifyWebhookSignature(request, options) {
       "Content-Digest header does not match recomputed body hash."
     );
   }
+  if (keyResolution.operatorAuthorizationValidUntil !== void 0) {
+    assertDelegatedOperatorAuthorizationActive(keyResolution.operatorAuthorizationValidUntil, currentTime());
+  }
   const remaining = parsedInput.params.expires - now + import_types.CLOCK_SKEW_TOLERANCE_SECONDS;
   const ttl = Math.max(remaining, import_types.MAX_SIGNATURE_WINDOW_SECONDS + import_types.CLOCK_SKEW_TOLERANCE_SECONDS);
   const insertResult = await options.replayStore.insert(jwk.kid, replayScope, parsedInput.params.nonce, ttl, now);
@@ -178,8 +186,34 @@ async function verifyWebhookSignature(request, options) {
       `Per-keyid replay cache cap exceeded on commit for keyid=${jwk.kid}.`
     );
   }
+  if (keyResolution.operatorAuthorizationValidUntil !== void 0) {
+    assertDelegatedOperatorAuthorizationActive(keyResolution.operatorAuthorizationValidUntil, currentTime());
+  }
   const agent_url = options.agentUrlForKeyid?.(jwk.kid);
-  return { status: "verified", keyid: jwk.kid, ...agent_url !== void 0 && { agent_url }, verified_at: now };
+  return {
+    status: "verified",
+    keyid: jwk.kid,
+    ...agent_url !== void 0 && { agent_url },
+    // Keep the established whole-second credential timestamp while using the
+    // fractional clock above for exact authorization-expiry enforcement.
+    verified_at: Math.floor(now)
+  };
+}
+function assertDelegatedOperatorAuthorizationActive(validUntil, now) {
+  if (validUntil !== void 0 && (!Number.isFinite(validUntil) || now >= validUntil)) {
+    throw new import_errors.WebhookSignatureError(
+      "webhook_signature_key_unknown",
+      7,
+      "The signing key is no longer authorized for this webhook registration."
+    );
+  }
+}
+function replayScopeForWebhook(canonicalTarget, binding) {
+  if (binding === void 0) return canonicalTarget;
+  if (binding.length === 0 || binding.length > 1024 || binding.includes("\0")) {
+    throw new TypeError("replayScopeBinding must be a non-empty string of at most 1024 characters without NUL.");
+  }
+  return JSON.stringify([canonicalTarget, binding]);
 }
 function requireParams(parsed) {
   const required = ["created", "expires", "nonce", "keyid", "alg", "tag"];