mppx 0.8.15 → 0.8.17

package/src/tempo/session/server/Session.ts

@@ -31,7 +31,7 @@ import {
   serializeSnapshot as serializeSessionSnapshot,
 } from '../Snapshot.js'
 import * as ChannelStore from './ChannelStore.js'
-import { verifyCredentialPayload } from './CredentialVerification.js'
+import { broadcastCredentialPayload, validateCredentialPayload } from './CredentialVerification.js'
 import { requireSessionCredentialPayload } from './CredentialVerification.js'
 import {
   type ResolveSessionChannelId,
@@ -42,13 +42,18 @@ import {
   type SessionPaymentRequestInput,
 } from './RequestState.js'
 import { respondToSessionCredential } from './RequestState.js'
-import { applyVerifiedHttpAccounting, chargeSessionChannel } from './Settlement.js'
-import { maybeSettleScheduled } from './Settlement.js'
+import {
+  applyVerifiedHttpAccounting,
+  chargeSessionChannel,
+  type SettleChargedSessionChannel,
+} from './Settlement.js'
+import { isSettlementDue, maybeSettleScheduled } from './Settlement.js'
 import {
   resolveSettlementSchedule,
   type OnSessionSettlement,
   type SettlementSchedule,
 } from './Settlement.js'
+import * as Ws from './Ws.js'
 
 /** Server-side automatic settlement schedule. */
 export type { SettlementSchedule } from './Settlement.js'
@@ -330,6 +335,26 @@ export function session<const parameters extends session.Parameters>(
     getClient: parameters.getClient,
     rpcUrl: defaults.rpcUrl,
   })
+  const settleScheduled: SettleChargedSessionChannel = async (channel) => {
+    if (!isSettlementDue(channel, settlementSchedule)) return undefined
+    return maybeSettleScheduled({
+      account,
+      channel,
+      client: await getClient({ chainId: channel.chainId }),
+      ...(feePayer ? { feePayer } : {}),
+      feePayerPolicy: parameters.feePayerPolicy,
+      feeToken: parameters.feeToken,
+      onSessionSettlement,
+      schedule: settlementSchedule,
+      store,
+    })
+  }
+  const serveWebSocket: session.Extensions['serveWebSocket'] = (options) =>
+    Ws.serve({
+      ...options,
+      onChargeCommitted: settleScheduled,
+      store,
+    })
   const bootstrapCharge = ChargeServer.charge({
     account,
     chainId: parameters.chainId,
@@ -341,16 +366,123 @@ export function session<const parameters extends session.Parameters>(
     store: rawStore,
   })
 
-  type Transport = parameters['sse'] extends false | undefined ? undefined : Transport.Sse
+  type SessionTransport = parameters['sse'] extends false | undefined ? undefined : Transport.Sse
   const transport = parameters.sse
     ? Transport.sse({
+        settleCharged: settleScheduled,
         store,
         ...(typeof parameters.sse === 'object' ? parameters.sse : undefined),
       })
     : undefined
 
+  const validateCredential: Method.ValidateFn<typeof Methods.session> = async ({
+    credential,
+    request,
+  }) => {
+    const payload = requireSessionCredentialPayload(credential.payload)
+    const context = await resolveCredentialVerificationContext({
+      decimals,
+      feePayer: configuredFeePayer,
+      getClient,
+      minVoucherDelta: parameters.minVoucherDelta,
+      request,
+    })
+
+    const details = await validateCredentialPayload({
+      account,
+      challenge: credential.challenge,
+      channelStateTtl,
+      chainId: context.chainId,
+      client: context.client,
+      credentialSource: credential.source,
+      escrow: context.escrow,
+      expectedOperator: context.methodDetails.operator,
+      feePayer: context.feePayer,
+      feePayerPolicy: parameters.feePayerPolicy,
+      lastOnChainVerified,
+      minVoucherDelta: context.minVoucherDelta,
+      payload,
+      store,
+    })
+
+    return {
+      challenge: credential.challenge,
+      credential: { ...credential, payload },
+      details,
+      intent: 'session' as const,
+      method: 'tempo' as const,
+      request: context.request,
+      source: credential.source,
+    }
+  }
+
+  const broadcastCredential: Method.BroadcastFn<typeof Methods.session> = async ({
+    credential,
+    envelope,
+    request,
+  }) => {
+    const { challenge } = credential
+    const payload = requireSessionCredentialPayload(credential.payload)
+    const context = await resolveCredentialVerificationContext({
+      decimals,
+      feePayer: configuredFeePayer,
+      getClient,
+      minVoucherDelta: parameters.minVoucherDelta,
+      request,
+    })
+
+    const sessionReceipt = await broadcastCredentialPayload({
+      account,
+      challenge,
+      channelStateTtl,
+      chainId: context.chainId,
+      client: context.client,
+      credentialSource: credential.source,
+      escrow: context.escrow,
+      expectedOperator: context.methodDetails.operator,
+      feePayer: context.feePayer,
+      feePayerPolicy: parameters.feePayerPolicy,
+      feeToken: parameters.feeToken,
+      lastOnChainVerified,
+      minVoucherDelta: context.minVoucherDelta,
+      onSessionSettlement,
+      payload,
+      store,
+    })
+
+    return applyVerifiedHttpAccounting({
+      capturedRequest: envelope?.capturedRequest,
+      payloadAction: payload.action,
+      receipt: sessionReceipt,
+      getRequestAmount: () => BigInt(context.request.amount ?? challenge.request.amount),
+      sseEnabled: Boolean(parameters.sse),
+      markPrepaidReceipt: Transport.markPrepaidSessionTick,
+      charge: (channelId, requestAmount) =>
+        chargeSessionChannel({ store, channelId, amount: requestAmount }),
+      settleCharged: (channel) =>
+        maybeSettleScheduled({
+          account,
+          client: context.client,
+          ...(typeof context.feePayer === 'object' ? { feePayer: context.feePayer } : {}),
+          feePayerPolicy: parameters.feePayerPolicy,
+          feeToken: parameters.feeToken,
+          onSessionSettlement,
+          schedule: settlementSchedule,
+          store,
+          channel,
+        }),
+    })
+  }
+
   type Defaults = session.DeriveDefaults<parameters>
-  return Method.toServer<typeof Methods.session, Defaults, Transport>(Methods.session, {
+  const method = Method.toServer<
+    typeof Methods.session,
+    Defaults,
+    SessionTransport,
+    session.Extensions
+  >(Methods.session, {
+    canOffer: parameters.canOffer,
+    onPaymentSuccess: parameters.onPaymentSuccess,
     defaults: deriveServerDefaults<parameters>({
       amount,
       currency,
@@ -361,6 +493,8 @@ export function session<const parameters extends session.Parameters>(
       unitType,
     }),
 
+    extensions: { serveWebSocket, settleScheduled },
+
     transport: deriveTransport<parameters>(transport),
 
     preflight: parameters.bootstrap
@@ -406,59 +540,8 @@ export function session<const parameters extends session.Parameters>(
       }
     },
 
-    async verify({ credential, envelope, request }) {
-      const { challenge } = credential
-      const payload = requireSessionCredentialPayload(credential.payload)
-      const context = await resolveCredentialVerificationContext({
-        decimals,
-        feePayer: configuredFeePayer,
-        getClient,
-        minVoucherDelta: parameters.minVoucherDelta,
-        request,
-      })
-
-      const sessionReceipt = await verifyCredentialPayload({
-        account,
-        challenge,
-        channelStateTtl,
-        chainId: context.chainId,
-        client: context.client,
-        credentialSource: credential.source,
-        escrow: context.escrow,
-        expectedOperator: context.methodDetails.operator,
-        feePayer: context.feePayer,
-        feePayerPolicy: parameters.feePayerPolicy,
-        feeToken: parameters.feeToken,
-        lastOnChainVerified,
-        minVoucherDelta: context.minVoucherDelta,
-        onSessionSettlement,
-        payload,
-        store,
-      })
-
-      return applyVerifiedHttpAccounting({
-        capturedRequest: envelope?.capturedRequest,
-        payloadAction: payload.action,
-        receipt: sessionReceipt,
-        getRequestAmount: () => BigInt(context.request.amount ?? challenge.request.amount),
-        sseEnabled: Boolean(parameters.sse),
-        markPrepaidReceipt: Transport.markPrepaidSessionTick,
-        charge: (channelId, requestAmount) =>
-          chargeSessionChannel({ store, channelId, amount: requestAmount }),
-        settleCharged: (channel) =>
-          maybeSettleScheduled({
-            account,
-            client: context.client,
-            ...(typeof context.feePayer === 'object' ? { feePayer: context.feePayer } : {}),
-            feePayerPolicy: parameters.feePayerPolicy,
-            feeToken: parameters.feeToken,
-            onSessionSettlement,
-            schedule: settlementSchedule,
-            store,
-            channel,
-          }),
-      })
-    },
+    validate: validateCredential,
+    broadcast: broadcastCredential,
 
     // This hook acts as a gate: when it returns a Response, `withReceipt()`
     // in Mppx.ts short-circuits and returns that response directly without
@@ -478,12 +561,27 @@ export function session<const parameters extends session.Parameters>(
       })
     },
   })
+  return method
 }
 
 export namespace session {
   export const serializeSnapshot = serializeSessionSnapshot
   export const deserializeSnapshot = deserializeSessionSnapshot
 
+  /** Extensions attached to the Tempo session method handler. */
+  export type Extensions = {
+    /** Applies the configured automatic settlement policy to a committed channel charge. */
+    settleScheduled: SettleChargedSessionChannel
+    /** Serves a WebSocket route from this handler using its configured store and settlement policy. */
+    serveWebSocket: (options: ServeWebSocketOptions) => Promise<void>
+  }
+
+  /** WebSocket server options supplied after the session binds shared dependencies. */
+  export type ServeWebSocketOptions = Omit<
+    Ws.serve.Options,
+    'onChargeCommitted' | 'settleScheduled' | 'store'
+  >
+
   /** Request defaults inferred from the Tempo session method schema. */
   export type Defaults = LooseOmit<
     Method.RequestDefaults<typeof Methods.session>,
@@ -526,7 +624,7 @@ export namespace session {
     store?: Store.AtomicStore | undefined
     /** Enable SSE streaming. Pass `true` for defaults or an options object to configure SSE. */
     sse?: boolean | Transport.sse.Options | undefined
-    /** Tempo chain ID used for TIP-1034 channel escrow challenges. Defaults to the resolved client chain ID. Pass the Tempo testnet chain ID here instead of using legacy session's `testnet` boolean. */
+    /** Tempo chain ID used for TIP-1034 channel escrow challenges. Defaults to the resolved client chain ID. */
     chainId?: number | undefined
     /** TIP20EscrowChannel precompile address override. */
     escrowContract?: Address | undefined
@@ -539,7 +637,8 @@ export namespace session {
     feeToken?: Address | undefined
   } & Account.resolve.Parameters &
     Client.getResolver.Parameters &
-    Defaults
+    Defaults &
+    Method.ComposableHooks<typeof Methods.session>
 
   /** Defaults derived from `session()` parameters for handler type inference. */
   export type DeriveDefaults<parameters extends Parameters> = types.DeriveDefaults<

package/src/tempo/session/server/Sse.test.ts

@@ -260,6 +260,7 @@ describe('serve', () => {
 
   test('uses a prepaid unit for the first generated value', async () => {
     const storage = memoryStore()
+    const committed: Array<{ spent: bigint; units: number }> = []
     await seedChannel(storage, 3000000n)
     await storage.updateChannel(channelId, (current) =>
       current ? { ...current, spent: 1000000n, units: 1 } : current,
@@ -271,6 +272,9 @@ describe('serve', () => {
       challengeId,
       tickCost: 1000000n,
       generate: generate(['hello', 'world']),
+      onChargeCommitted(channel) {
+        committed.push({ spent: channel.spent, units: channel.units })
+      },
       prepaidUnits: 1,
     })
 
@@ -281,6 +285,79 @@ describe('serve', () => {
     const channel = await storage.getChannel(channelId)
     expect(channel!.spent).toBe(2000000n)
     expect(channel!.units).toBe(2)
+    expect(committed).toEqual([{ spent: 2000000n, units: 2 }])
+  })
+
+  test('runs the post-commit hook before emitting each charged value', async () => {
+    const storage = memoryStore()
+    const committed: Array<{ spent: bigint; units: number }> = []
+    await seedChannel(storage, 2000000n)
+
+    const output = await readStream(
+      serve({
+        store: storage,
+        channelId,
+        challengeId,
+        tickCost: 1000000n,
+        generate: generate(['first', 'second']),
+        onChargeCommitted(channel) {
+          committed.push({ spent: channel.spent, units: channel.units })
+        },
+      }),
+    )
+
+    expect(output).toContain('event: message\ndata: first\n\n')
+    expect(output).toContain('event: message\ndata: second\n\n')
+    expect(committed).toEqual([
+      { spent: 1000000n, units: 1 },
+      { spent: 2000000n, units: 2 },
+    ])
+  })
+
+  test('does not emit a charged value when the post-commit hook fails', async () => {
+    const storage = memoryStore()
+    await seedChannel(storage, 1000000n)
+
+    const reader = serve({
+      store: storage,
+      channelId,
+      challengeId,
+      tickCost: 1000000n,
+      generate: generate(['blocked']),
+      onChargeCommitted() {
+        throw new Error('settlement failed')
+      },
+    }).getReader()
+
+    await expect(reader.read()).rejects.toThrow('settlement failed')
+    const channel = await storage.getChannel(channelId)
+    expect(channel).toMatchObject({ spent: 1000000n, units: 1 })
+  })
+
+  test('does not run the post-commit hook for an unconsumed reservation', async () => {
+    const storage = memoryStore()
+    let commits = 0
+    await seedChannel(storage, 1000000n)
+
+    await readStream(
+      serve({
+        store: storage,
+        channelId,
+        challengeId,
+        tickCost: 1000000n,
+        generate: async function* (stream) {
+          await stream.charge()
+          yield* []
+        },
+        onChargeCommitted() {
+          commits++
+        },
+      }),
+    )
+
+    expect(commits).toBe(0)
+    const channel = await storage.getChannel(channelId)
+    expect(channel).toMatchObject({ spent: 0n, units: 0 })
   })
 
   test('emits multiline message values as a single SSE message event', async () => {

package/src/tempo/session/server/Sse.ts

@@ -12,7 +12,11 @@ import {
   requireSessionCredentialContext,
 } from '../precompile/Protocol.js'
 import * as ChannelStore from './ChannelStore.js'
-import { meterIterable, type SessionController } from './MeteredStream.js'
+import {
+  meterIterable,
+  type MeteredStreamOptions,
+  type SessionController,
+} from './MeteredStream.js'
 
 /**
  * SSE (Server-Sent Events) utilities for metered streaming payments.
@@ -81,6 +85,7 @@ export function serve(options: serve.Options): ReadableStream<Uint8Array> {
           channelId,
           tickCost,
           generate,
+          onChargeCommitted: options.onChargeCommitted,
           pollIntervalMs,
           prepaidUnits: options.prepaidUnits,
           signal,
@@ -121,6 +126,8 @@ export declare namespace serve {
     challengeId: string
     tickCost: bigint
     generate: AsyncIterable<string> | ((stream: SessionController) => AsyncIterable<string>)
+    /** Callback invoked after each nonzero stream charge is committed. */
+    onChargeCommitted?: MeteredStreamOptions['onChargeCommitted']
     pollIntervalMs?: number | undefined
     prepaidUnits?: number | undefined
     signal?: AbortSignal | undefined

package/src/tempo/session/server/Transports.ts

@@ -86,7 +86,7 @@ export async function reserveChargeOrWait(options: ReserveChargeParameters): Pro
 /** Atomically commits previously reserved stream charges to channel spend and unit counters. */
 export async function commitReservedCharges(
   options: CommitReservedChargesParameters,
-): Promise<void> {
+): Promise<ChannelStore.State | undefined> {
   const { amount, channelId, store, units } = options
   if (amount === 0n || units === 0) return
 
@@ -107,6 +107,7 @@ export async function commitReservedCharges(
   if (!channel) throw new Error('channel not found')
   throwIfChannelClosed(channel)
   if (!committed) throw new Error('reserved voucher coverage is no longer available')
+  return channel
 }
 
 /** Throws when a channel can no longer be used for streaming charges. */

package/src/tempo/session/server/Ws.test.ts

@@ -124,6 +124,27 @@ function seedChannel(
   }))
 }
 
+function acceptingRoute(acceptedCumulative: bigint): Ws.serve.Options['route'] {
+  return async () => ({
+    status: 200,
+    withReceipt(response = new Response(null, { status: 204 })) {
+      response.headers.set(
+        'Payment-Receipt',
+        serializeSessionReceipt(
+          createSessionReceipt({
+            challengeId: challenge.id,
+            channelId,
+            acceptedCumulative,
+            spent: 0n,
+            units: 0,
+          }),
+        ),
+      )
+      return response
+    },
+  })
+}
+
 describe('parseMessage', () => {
   test('rejects non-object data in payment-receipt', () => {
     expect(Ws.parseMessage('{"mpp":"payment-receipt","data":true}')).toBeNull()
@@ -348,6 +369,7 @@ describe('isows', () => {
   test('drops reserved charges when the stream ends without delivering a chunk', async () => {
     const socket = new MockSocket()
     const store = memoryChannelStore()
+    let commits = 0
     await seedChannel(store, 1n)
 
     await Ws.serve({
@@ -376,6 +398,9 @@ describe('isows', () => {
         await stream.charge()
         yield* []
       },
+      onChargeCommitted() {
+        commits++
+      },
     })
 
     socket.receive(
@@ -406,6 +431,7 @@ describe('isows', () => {
     const channel = await store.getChannel(channelId)
     expect(channel?.spent).toBe(0n)
     expect(channel?.units).toBe(0)
+    expect(commits).toBe(0)
   })
 
   test('aborts a blocked application generator before sending close-ready', async () => {
@@ -521,6 +547,151 @@ describe('isows', () => {
     expect(socket.sent.some((message) => message.includes('priced-response'))).toBe(true)
   })
 
+  test.each(['onChargeCommitted', 'settleScheduled'] as const)(
+    'runs %s after each committed charge and before emitting its message',
+    async (hookName) => {
+      const socket = new MockSocket()
+      const store = memoryChannelStore()
+      const committed: Array<{ emitted: number; spent: bigint; units: number }> = []
+      await seedChannel(store, 2n)
+
+      const hook = async (channel: ChannelStore.State) => {
+        committed.push({
+          emitted: socket.sent.filter((message) => Ws.parseMessage(message)?.mpp === 'message')
+            .length,
+          spent: channel.spent,
+          units: channel.units,
+        })
+        return undefined
+      }
+
+      await Ws.serve({
+        socket,
+        store,
+        url: 'ws://example.test/stream',
+        route: acceptingRoute(2n),
+        generate: (async function* () {
+          yield 'first'
+          yield 'second'
+        })(),
+        ...(hookName === 'onChargeCommitted'
+          ? { onChargeCommitted: hook }
+          : { settleScheduled: hook }),
+      })
+
+      socket.receive(
+        Ws.formatAuthorizationMessage(
+          makeCredential({
+            action: 'open',
+            channelId,
+            cumulativeAmount: '2',
+            signature: `0x${'77'.repeat(65)}`,
+            transaction: '0x01',
+            type: 'transaction',
+          }),
+        ),
+      )
+
+      await sleep(10)
+
+      expect(committed).toEqual([
+        { emitted: 0, spent: 1n, units: 1 },
+        { emitted: 1, spent: 2n, units: 2 },
+      ])
+      expect(
+        socket.sent
+          .map((message) => Ws.parseMessage(message))
+          .filter((message) => message?.mpp === 'message')
+          .map((message) => (message?.mpp === 'message' ? message.data : undefined)),
+      ).toEqual(['first', 'second'])
+    },
+  )
+
+  test('prefers onChargeCommitted over the deprecated settlement callback', async () => {
+    const socket = new MockSocket()
+    const store = memoryChannelStore()
+    const callbacks: string[] = []
+    await seedChannel(store, 1n)
+
+    await Ws.serve({
+      socket,
+      store,
+      url: 'ws://example.test/stream',
+      route: acceptingRoute(1n),
+      generate: (async function* () {
+        yield 'message'
+      })(),
+      onChargeCommitted() {
+        callbacks.push('current')
+      },
+      async settleScheduled() {
+        callbacks.push('deprecated')
+        return undefined
+      },
+    })
+
+    socket.receive(
+      Ws.formatAuthorizationMessage(
+        makeCredential({
+          action: 'open',
+          channelId,
+          cumulativeAmount: '1',
+          signature: `0x${'77'.repeat(65)}`,
+          transaction: '0x01',
+          type: 'transaction',
+        }),
+      ),
+    )
+
+    await sleep(10)
+
+    expect(callbacks).toEqual(['current'])
+  })
+
+  test('closes without emitting a charged message when the post-commit hook fails', async () => {
+    const socket = new MockSocket()
+    const store = memoryChannelStore()
+    await seedChannel(store, 1n)
+
+    await Ws.serve({
+      socket,
+      store,
+      url: 'ws://example.test/stream',
+      route: acceptingRoute(1n),
+      generate: (async function* () {
+        yield 'blocked'
+      })(),
+      onChargeCommitted() {
+        throw new Error('settlement failed')
+      },
+    })
+
+    socket.receive(
+      Ws.formatAuthorizationMessage(
+        makeCredential({
+          action: 'open',
+          channelId,
+          cumulativeAmount: '1',
+          signature: `0x${'77'.repeat(65)}`,
+          transaction: '0x01',
+          type: 'transaction',
+        }),
+      ),
+    )
+
+    await sleep(10)
+
+    expect(socket.closed).toBe(true)
+    expect(socket.sent.some((message) => message.includes('settlement failed'))).toBe(true)
+    expect(
+      socket.sent.some((message) => {
+        const parsed = Ws.parseMessage(message)
+        return parsed?.mpp === 'message' && parsed.data === 'blocked'
+      }),
+    ).toBe(false)
+    expect(await store.getChannel(channelId)).toMatchObject({ spent: 1n, units: 1 })
+  })
+
   test('does not meter or emit application messages after close is requested on-chain', async () => {
     const socket = new MockSocket()
     const store = memoryChannelStore()

package/src/tempo/session/server/Ws.ts

@@ -15,7 +15,8 @@ import {
   type SessionReceipt,
 } from '../precompile/Protocol.js'
 import * as ChannelStore from './ChannelStore.js'
-import type { SessionController } from './MeteredStream.js'
+import type { MeteredStreamOptions, SessionController } from './MeteredStream.js'
+import type { SettleChargedSessionChannel } from './Settlement.js'
 export type { SessionController } from './MeteredStream.js'
 export type { Socket } from './Transports.js'
 import { meterIterable } from './MeteredStream.js'
@@ -152,6 +153,7 @@ export async function serve(options: serve.Options): Promise<void> {
         channelId: context.channelId,
         tickCost: context.tickCost,
         generate,
+        onChargeCommitted: options.onChargeCommitted ?? options.settleScheduled,
         pollIntervalMs,
         signal: abortController.signal,
         emitNeedVoucher: (message) => send(socket, message),
@@ -332,6 +334,10 @@ export declare namespace serve {
     /** Payment route handler. Receives synthetic `POST` requests with only
      *  the `Authorization` header — no cookies, bodies, or upgrade headers. */
     route: SessionRoute
+    /** Optional low-level hook invoked after each committed stream charge. */
+    onChargeCommitted?: MeteredStreamOptions['onChargeCommitted']
+    /** @deprecated Use `onChargeCommitted`. */
+    settleScheduled?: SettleChargedSessionChannel | undefined
     socket: Socket
     store: ChannelStore.ChannelStore | import('../../../Store.js').Store
     url: string | URL

package/src/web-bot-auth/Constants.ts

@@ -0,0 +1,24 @@
+import { Constants as HttpMessageSignature } from '../attestation/internal/HttpMessageSignature.js'
+
+/** Web Bot Auth values for the supported HTTPS-directory signature profile. */
+export const Constants = {
+  /** Stable identifier for Web Bot Auth signers and replay storage. */
+  protocol: 'web-bot-auth',
+  /** Web Bot Auth discovery type supported by this adapter. */
+  discoveryType: 'directory',
+  /** RFC 9421 signature label used when no label is configured. */
+  label: 'webbot',
+  /** Tag identifying a Web Bot Auth request signature. */
+  tag: 'web-bot-auth',
+  /** Structured HTTP header linking a bot signature to its HTTPS directory origin. */
+  signatureAgentHeader: 'Signature-Agent',
+  /** Default lifetime, in seconds, for a bot request signature. */
+  defaultSignatureLifetime: 60,
+  /** Default verifier limit, following the draft's recommended 24-hour maximum. */
+  defaultMaximumSignatureLifetime: 24 * 60 * 60,
+  /** HTTP components required by this directory profile. */
+  requiredComponents: [
+    HttpMessageSignature.components.authority,
+    HttpMessageSignature.components.signatureAgent,
+  ],
+} as const