mppx 0.3.3 → 0.3.4

package/src/tempo/client/SessionManager.test.ts

@@ -1,8 +1,8 @@
 import type { Hex } from 'viem'
 import { describe, expect, test, vi } from 'vitest'
 import * as Challenge from '../../Challenge.js'
-import { formatNeedVoucherEvent, parseEvent } from '../stream/Sse.js'
-import type { NeedVoucherEvent, StreamReceipt } from '../stream/Types.js'
+import { formatNeedVoucherEvent, parseEvent } from '../session/Sse.js'
+import type { NeedVoucherEvent, SessionReceipt } from '../session/Types.js'
 import { sessionManager } from './SessionManager.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
@@ -139,7 +139,7 @@ describe('Session', () => {
           acceptedCumulative: '2000000',
           spent: '2000000',
           units: 2,
-        } satisfies StreamReceipt)}\n\n`,
+        } satisfies SessionReceipt)}\n\n`,
       ]
 
       let callCount = 0

package/src/tempo/client/SessionManager.ts

@@ -4,9 +4,9 @@ import type * as Challenge from '../../Challenge.js'
 import * as Fetch from '../../client/internal/Fetch.js'
 import type * as Account from '../../viem/Account.js'
 import type * as Client from '../../viem/Client.js'
-import { deserializeStreamReceipt } from '../stream/Receipt.js'
-import { parseEvent } from '../stream/Sse.js'
-import type { StreamReceipt } from '../stream/Types.js'
+import { deserializeSessionReceipt } from '../session/Receipt.js'
+import { parseEvent } from '../session/Sse.js'
+import type { SessionReceipt } from '../session/Types.js'
 import type { ChannelEntry } from './ChannelOps.js'
 import { session as sessionPlugin } from './Session.js'
 
@@ -20,15 +20,15 @@ export type SessionManager = {
   sse(
     input: RequestInfo | URL,
     init?: RequestInit & {
-      onReceipt?: ((receipt: StreamReceipt) => void) | undefined
+      onReceipt?: ((receipt: SessionReceipt) => void) | undefined
       signal?: AbortSignal | undefined
     },
   ): Promise<AsyncIterable<string>>
-  close(): Promise<StreamReceipt | undefined>
+  close(): Promise<SessionReceipt | undefined>
 }
 
 export type PaymentResponse = Response & {
-  receipt: StreamReceipt | null
+  receipt: SessionReceipt | null
   challenge: Challenge.Challenge | null
   channelId: Hex.Hex | null
   cumulative: bigint
@@ -83,7 +83,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
 
   function toPaymentResponse(response: Response): PaymentResponse {
     const receiptHeader = response.headers.get('Payment-Receipt')
-    const receipt = receiptHeader ? deserializeStreamReceipt(receiptHeader) : null
+    const receipt = receiptHeader ? deserializeSessionReceipt(receiptHeader) : null
     return Object.assign(response, {
       receipt,
       challenge: lastChallenge,
@@ -241,14 +241,14 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
         },
       })
 
-      let receipt: StreamReceipt | undefined
+      let receipt: SessionReceipt | undefined
       if (lastUrl) {
         const response = await fetchFn(lastUrl, {
           method: 'POST',
           headers: { Authorization: credential },
         })
         const receiptHeader = response.headers.get('Payment-Receipt')
-        if (receiptHeader) receipt = deserializeStreamReceipt(receiptHeader)
+        if (receiptHeader) receipt = deserializeSessionReceipt(receiptHeader)
       }
 
       return receipt

package/src/tempo/index.ts

@@ -1,2 +1,2 @@
 export * as Methods from './Methods.js'
-export * as Stream from './stream/index.js'
+export * as Session from './session/index.js'

package/src/tempo/server/Charge.ts

@@ -67,7 +67,7 @@ export function charge<const parameters extends charge.Parameters>(
       recipient,
     } as unknown as Defaults,
 
-    // TODO: dedupe `{charge,stream}.request`
+    // TODO: dedupe `{charge,session}.request`
     async request({ credential, request }) {
       const chainId = await (async () => {
         if (request.chainId) return request.chainId

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

@@ -8,7 +8,7 @@ import {
   signOpenChannel,
   signTopUpChannel,
   topUpChannel,
-} from '~test/tempo/stream.js'
+} from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount, http } from '~test/tempo/viem.js'
 import {
   ChannelClosedError,
@@ -18,9 +18,9 @@ import {
 } from '../../Errors.js'
 import * as Store from '../../Store.js'
 import type * as Methods from '../Methods.js'
-import * as ChannelStore from '../stream/ChannelStore.js'
-import type { StreamReceipt } from '../stream/Types.js'
-import { signVoucher } from '../stream/Voucher.js'
+import * as ChannelStore from '../session/ChannelStore.js'
+import type { SessionReceipt } from '../session/Types.js'
+import { signVoucher } from '../session/Voucher.js'
 import { charge, session, settle } from './Session.js'
 
 const payer = accounts[2]
@@ -367,7 +367,7 @@ describe('session', () => {
       })
 
       expect(receipt.status).toBe('success')
-      expect((receipt as StreamReceipt).acceptedCumulative).toBe('1000000')
+      expect((receipt as SessionReceipt).acceptedCumulative).toBe('1000000')
     })
 
     test('rejects voucher exceeding deposit', async () => {
@@ -520,7 +520,7 @@ describe('session', () => {
           },
         },
         request: makeRequest(),
-      })) as StreamReceipt
+      })) as SessionReceipt
 
       expect(receipt.status).toBe('success')
       expect(receipt.spent).toBe('800000')
@@ -748,7 +748,7 @@ describe('session', () => {
       })
 
       expect(receipt.status).toBe('success')
-      expect((receipt as StreamReceipt).txHash).toMatch(/^0x/)
+      expect((receipt as SessionReceipt).txHash).toMatch(/^0x/)
 
       const ch = await store.getChannel(channelId)
       expect(ch!.finalized).toBe(true)
@@ -1110,7 +1110,7 @@ describe('session', () => {
             currency: asset,
             escrowContract,
             getClient: () => client,
-            stream: true,
+            sse: true,
           }),
         ],
         realm: 'api.example.com',
@@ -1147,7 +1147,7 @@ describe('session', () => {
       }
     })
 
-    test('behavior: non-stream session withReceipt only accepts Response', async () => {
+    test('behavior: non-SSE session withReceipt only accepts Response', async () => {
       const handler = Mppx_server.create({
         methods: [
           tempo_server.session({

package/src/tempo/server/Session.ts

@@ -2,13 +2,13 @@
  * Server-side session payment method for request/response flows.
  *
  * Handles the full channel lifecycle (open, voucher, top-up, close) and
- * one-shot settlement. Each incoming request carries a stream credential
+ * one-shot settlement. Each incoming request carries a session credential
  * with a cumulative voucher that the server validates and records.
  *
  * Use `session()` for standard HTTP request/response patterns where each
  * request is a discrete paid unit (for example, a page scrape or API call).
  * For long-lived connections that emit multiple paid events over a single
- * request, use {@link ../stream/Sse} instead.
+ * request, use {@link ../session/Sse} instead.
  */
 import {
   type Address,
@@ -44,15 +44,15 @@ import {
   getOnChainChannel,
   type OnChainChannel,
   settleOnChain,
-} from '../stream/Chain.js'
-import * as ChannelStore from '../stream/ChannelStore.js'
-import { createStreamReceipt } from '../stream/Receipt.js'
-import type { SignedVoucher, StreamCredentialPayload, StreamReceipt } from '../stream/Types.js'
-import { parseVoucherFromPayload, verifyVoucher } from '../stream/Voucher.js'
+} from '../session/Chain.js'
+import * as ChannelStore from '../session/ChannelStore.js'
+import { createSessionReceipt } from '../session/Receipt.js'
+import type { SessionCredentialPayload, SessionReceipt, SignedVoucher } from '../session/Types.js'
+import { parseVoucherFromPayload, verifyVoucher } from '../session/Voucher.js'
 import * as Transport from './internal/transport.js'
 
-/** Challenge methodDetails shape for stream methods. */
-type StreamMethodDetails = {
+/** Challenge methodDetails shape for session methods. */
+type SessionMethodDetails = {
   escrowContract: Address
   chainId: number
   channelId?: Hex | undefined
@@ -61,7 +61,7 @@ type StreamMethodDetails = {
 }
 
 /**
- * Creates a stream payment server using the Method.toServer() pattern.
+ * Creates a session payment server using the Method.toServer() pattern.
  *
  * @example
  * ```ts
@@ -101,11 +101,11 @@ export function session<const parameters extends session.Parameters>(p?: paramet
   })
   const { account, recipient, feePayer } = Account.resolve(parameters)
 
-  type Transport = parameters['stream'] extends false | undefined ? undefined : Transport.Sse
-  const transport = parameters.stream
+  type Transport = parameters['sse'] extends false | undefined ? undefined : Transport.Sse
+  const transport = parameters.sse
     ? Transport.sse({
         store,
-        ...(typeof parameters.stream === 'object' ? parameters.stream : undefined),
+        ...(typeof parameters.sse === 'object' ? parameters.sse : undefined),
       })
     : undefined
 
@@ -122,7 +122,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
 
     transport: transport as never,
 
-    // TODO: dedupe `{charge,stream}.request`
+    // TODO: dedupe `{charge,session}.request`
     async request({ credential, request }) {
       // Extract chainId from request or default.
       const chainId = await (async () => {
@@ -160,9 +160,9 @@ export function session<const parameters extends session.Parameters>(p?: paramet
     },
 
     async verify({ credential }) {
-      const { challenge, payload } = credential as Credential.Credential<StreamCredentialPayload>
+      const { challenge, payload } = credential as Credential.Credential<SessionCredentialPayload>
 
-      const methodDetails = challenge.request.methodDetails as StreamMethodDetails
+      const methodDetails = challenge.request.methodDetails as SessionMethodDetails
       const client = await getClient({ chainId: methodDetails.chainId })
 
       const resolvedFeePayer = methodDetails.feePayer === true ? feePayer : undefined
@@ -171,11 +171,11 @@ export function session<const parameters extends session.Parameters>(p?: paramet
         ? BigInt(methodDetails.minVoucherDelta)
         : minVoucherDelta
 
-      let streamReceipt: StreamReceipt
+      let sessionReceipt: SessionReceipt
 
       switch (payload.action) {
         case 'open':
-          streamReceipt = await handleOpen(
+          sessionReceipt = await handleOpen(
             store,
             client,
             challenge,
@@ -186,7 +186,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
           break
 
         case 'topUp':
-          streamReceipt = await handleTopUp(
+          sessionReceipt = await handleTopUp(
             store,
             client,
             challenge,
@@ -197,7 +197,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
           break
 
         case 'voucher':
-          streamReceipt = await handleVoucher(
+          sessionReceipt = await handleVoucher(
             store,
             client,
             effectiveMinVoucherDelta,
@@ -208,7 +208,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
           break
 
         case 'close':
-          streamReceipt = await handleClose(
+          sessionReceipt = await handleClose(
             store,
             client,
             challenge,
@@ -224,7 +224,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
           })
       }
 
-      return streamReceipt
+      return sessionReceipt
     },
 
     // This hook acts as a gate: when it returns a Response, `withReceipt()`
@@ -236,14 +236,14 @@ export function session<const parameters extends session.Parameters>(p?: paramet
     // return 204 regardless of request method.
     //
     // Voucher POSTs are gated only when they have no request body, which
-    // signals a mid-stream voucher update (the client is just topping up
+    // signals a mid-session voucher update (the client is just topping up
     // the channel balance). Voucher POSTs WITH a body are content requests
     // (e.g., an API call to a POST endpoint) and fall through to the
     // user's handler. GET requests with vouchers always fall through so
     // auto-mode clients (whose fetch wrapper bundles open+voucher into a
     // single GET retry) receive content as expected.
     respond({ credential, input }) {
-      const { payload } = credential as Credential.Credential<StreamCredentialPayload>
+      const { payload } = credential as Credential.Credential<SessionCredentialPayload>
 
       if (payload.action === 'close') return new Response(null, { status: 204 })
 
@@ -253,7 +253,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
       const isVoucher = payload.action === 'voucher'
       if (!isVoucher) return undefined
 
-      // Only gate voucher POSTs with no body (mid-stream balance updates).
+      // Only gate voucher POSTs with no body (mid-session balance updates).
       // POSTs with a body are content requests that should reach the handler.
       if (input.method !== 'POST') return undefined
       const contentLength = input.headers.get('content-length')
@@ -279,10 +279,10 @@ export declare namespace session {
      * Enable SSE streaming.
      *
      * Pass `true` to enable with defaults, or an options object
-     * to configure the stream (e.g. `{ poll: true }` for
+     * to configure SSE (e.g. `{ poll: true }` for
      * Cloudflare Workers compatibility).
      */
-    stream?: boolean | Transport.sse.Options | undefined
+    sse?: boolean | Transport.sse.Options | undefined
     /** Testnet mode. */
     testnet?: boolean | undefined
   } & Account.resolve.Parameters &
@@ -332,7 +332,7 @@ export async function settle(
 /**
  * Charge against a channel's balance.
  *
- * Exported so consumers can deduct from a channel outside the `stream()`
+ * Exported so consumers can deduct from a channel outside the `session()`
  * handler (e.g., custom middleware, the SSE `serve()` loop, or direct tests).
  *
  * Delegates to the shared `deductFromChannel` atomic helper and translates
@@ -403,8 +403,8 @@ async function verifyAndAcceptVoucher(parameters: {
   channelId: Hex
   voucher: SignedVoucher
   onChain: OnChainChannel
-  methodDetails: StreamMethodDetails
-}): Promise<StreamReceipt> {
+  methodDetails: SessionMethodDetails
+}): Promise<SessionReceipt> {
   const { store, minVoucherDelta, challenge, channel, channelId, voucher, onChain, methodDetails } =
     parameters
 
@@ -426,7 +426,7 @@ async function verifyAndAcceptVoucher(parameters: {
   }
 
   if (voucher.cumulativeAmount <= channel.highestVoucherAmount) {
-    return createStreamReceipt({
+    return createSessionReceipt({
       challengeId: challenge.id,
       channelId,
       acceptedCumulative: channel.highestVoucherAmount,
@@ -467,7 +467,7 @@ async function verifyAndAcceptVoucher(parameters: {
   })
   if (!updated) throw new ChannelNotFoundError({ reason: 'channel not found' })
 
-  return createStreamReceipt({
+  return createSessionReceipt({
     challengeId: challenge.id,
     channelId,
     acceptedCumulative: updated.highestVoucherAmount,
@@ -483,10 +483,10 @@ async function handleOpen(
   store: ChannelStore.ChannelStore,
   client: viem_Client,
   challenge: Challenge.Challenge,
-  payload: StreamCredentialPayload & { action: 'open' },
-  methodDetails: StreamMethodDetails,
+  payload: SessionCredentialPayload & { action: 'open' },
+  methodDetails: SessionMethodDetails,
   feePayer: viem_Account | undefined,
-): Promise<StreamReceipt> {
+): Promise<SessionReceipt> {
   const voucher = parseVoucherFromPayload(
     payload.channelId,
     payload.cumulativeAmount,
@@ -579,7 +579,7 @@ async function handleOpen(
 
   if (!updated) throw new VerificationFailedError({ reason: 'failed to create channel' })
 
-  return createStreamReceipt({
+  return createSessionReceipt({
     challengeId: challenge.id,
     channelId: payload.channelId,
     acceptedCumulative: updated.highestVoucherAmount,
@@ -600,10 +600,10 @@ async function handleTopUp(
   store: ChannelStore.ChannelStore,
   client: viem_Client,
   challenge: Challenge.Challenge,
-  payload: StreamCredentialPayload & { action: 'topUp' },
-  methodDetails: StreamMethodDetails,
+  payload: SessionCredentialPayload & { action: 'topUp' },
+  methodDetails: SessionMethodDetails,
   feePayer: viem_Account | undefined,
-): Promise<StreamReceipt> {
+): Promise<SessionReceipt> {
   const channel = await store.getChannel(payload.channelId)
   if (!channel) {
     throw new ChannelNotFoundError({ reason: 'channel not found' })
@@ -626,7 +626,7 @@ async function handleTopUp(
     return { ...current, deposit: onChainDeposit }
   })
 
-  return createStreamReceipt({
+  return createSessionReceipt({
     challengeId: challenge.id,
     channelId: payload.channelId,
     acceptedCumulative: updated?.highestVoucherAmount ?? channel.highestVoucherAmount,
@@ -643,9 +643,9 @@ async function handleVoucher(
   _client: viem_Client,
   minVoucherDelta: bigint,
   challenge: Challenge.Challenge,
-  payload: StreamCredentialPayload & { action: 'voucher' },
-  methodDetails: StreamMethodDetails,
-): Promise<StreamReceipt> {
+  payload: SessionCredentialPayload & { action: 'voucher' },
+  methodDetails: SessionMethodDetails,
+): Promise<SessionReceipt> {
   const channel = await store.getChannel(payload.channelId)
   if (!channel) {
     throw new ChannelNotFoundError({ reason: 'channel not found' })
@@ -696,10 +696,10 @@ async function handleClose(
   store: ChannelStore.ChannelStore,
   client: viem_Client,
   challenge: Challenge.Challenge,
-  payload: StreamCredentialPayload & { action: 'close' },
-  methodDetails: StreamMethodDetails,
+  payload: SessionCredentialPayload & { action: 'close' },
+  methodDetails: SessionMethodDetails,
   account?: viem_Account,
-): Promise<StreamReceipt> {
+): Promise<SessionReceipt> {
   const channel = await store.getChannel(payload.channelId)
   if (!channel) {
     throw new ChannelNotFoundError({ reason: 'channel not found' })
@@ -762,7 +762,7 @@ async function handleClose(
     }
   })
 
-  return createStreamReceipt({
+  return createSessionReceipt({
     challengeId: challenge.id,
     channelId: payload.channelId,
     acceptedCumulative: voucher.cumulativeAmount,

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

@@ -1,7 +1,7 @@
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
-import type * as ChannelStore from '../stream/ChannelStore.js'
-import { serve, toResponse } from '../stream/Sse.js'
+import type * as ChannelStore from '../session/ChannelStore.js'
+import { serve, toResponse } from '../session/Sse.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
 const challengeId = 'test-challenge-id'
@@ -58,7 +58,7 @@ async function readStream(stream: ReadableStream<Uint8Array>): Promise<string> {
 }
 
 describe('Sse.serve', () => {
-  test('emits message events for each yielded value (StreamController)', async () => {
+  test('emits message events for each yielded value (SessionController)', async () => {
     const store = memoryStore()
     await seedChannel(store, 3000000n)
 

package/src/tempo/server/index.ts

@@ -1,5 +1,5 @@
-export * as ChannelStore from '../stream/ChannelStore.js'
-export * as Sse from '../stream/Sse.js'
+export * as ChannelStore from '../session/ChannelStore.js'
+export * as Sse from '../session/Sse.js'
 export { charge } from './Charge.js'
 export { tempo } from './Methods.js'
 export { session, settle } from './Session.js'

package/src/tempo/server/internal/transport.ts

@@ -6,11 +6,11 @@
  * @internal
  */
 import * as Transport from '../../../server/Transport.js'
-import type * as ChannelStore from '../../stream/ChannelStore.js'
-import * as Sse_core from '../../stream/Sse.js'
+import type * as ChannelStore from '../../session/ChannelStore.js'
+import * as Sse_core from '../../session/Sse.js'
 
-/** SSE transport with Tempo stream controller. */
-export type Sse = Transport.Sse<Sse_core.StreamController>
+/** SSE transport with Tempo session controller. */
+export type Sse = Transport.Sse<Sse_core.SessionController>
 
 /**
  * Creates a Tempo-metered SSE transport.
@@ -46,7 +46,7 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
           const ctx = Sse_core.fromRequest(request)
           contextMap.set(ctx.challengeId, { ...ctx, signal: request.signal })
         } catch {
-          // ignore — non-SSE credentials won't have stream context
+          // ignore — non-SSE credentials won't have session context
         }
       }
       return credential
@@ -72,7 +72,7 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
         contextMap.delete(challengeId)
 
         // Pass async generator functions directly so Sse.serve gives them
-        // a StreamController for manual charge(). Pass raw AsyncIterables
+        // a SessionController for manual charge(). Pass raw AsyncIterables
         // as-is so Sse.serve auto-charges per yielded value.
         const generate: Sse_core.serve.Options['generate'] = isAsyncGeneratorFunction(resolved)
           ? (resolved as Sse_core.serve.Options['generate'])

package/src/tempo/{stream → session}/Chain.test.ts

@@ -8,7 +8,7 @@ import {
   signOpenChannel,
   signTopUpChannel,
   topUpChannel,
-} from '~test/tempo/stream.js'
+} from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
 import {
   broadcastOpenTransaction,

package/src/tempo/{stream → session}/Receipt.test.ts

@@ -1,12 +1,16 @@
 import type { Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
-import { createStreamReceipt, deserializeStreamReceipt, serializeStreamReceipt } from './Receipt.js'
+import {
+  createSessionReceipt,
+  deserializeSessionReceipt,
+  serializeSessionReceipt,
+} from './Receipt.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
 
 describe('Receipt', () => {
-  test('createStreamReceipt', () => {
-    const receipt = createStreamReceipt({
+  test('createSessionReceipt', () => {
+    const receipt = createSessionReceipt({
       challengeId: 'test-challenge-id',
       channelId,
       acceptedCumulative: 5000000n,
@@ -27,9 +31,9 @@ describe('Receipt', () => {
     expect(receipt.txHash).toBeUndefined()
   })
 
-  test('createStreamReceipt with txHash', () => {
+  test('createSessionReceipt with txHash', () => {
     const txHash = '0xabcdef' as Hex
-    const receipt = createStreamReceipt({
+    const receipt = createSessionReceipt({
       challengeId: 'test-challenge-id',
       channelId,
       acceptedCumulative: 5000000n,
@@ -41,8 +45,8 @@ describe('Receipt', () => {
     expect(receipt.units).toBeUndefined()
   })
 
-  test('createStreamReceipt omits optional fields when undefined', () => {
-    const receipt = createStreamReceipt({
+  test('createSessionReceipt omits optional fields when undefined', () => {
+    const receipt = createSessionReceipt({
       challengeId: 'test-challenge-id',
       channelId,
       acceptedCumulative: 1000n,
@@ -54,7 +58,7 @@ describe('Receipt', () => {
   })
 
   test('serialize and deserialize round-trip', () => {
-    const receipt = createStreamReceipt({
+    const receipt = createSessionReceipt({
       challengeId: 'test-challenge-id',
       channelId,
       acceptedCumulative: 5000000n,
@@ -62,22 +66,22 @@ describe('Receipt', () => {
       units: 42,
     })
 
-    const encoded = serializeStreamReceipt(receipt)
+    const encoded = serializeSessionReceipt(receipt)
     expect(typeof encoded).toBe('string')
 
-    const decoded = deserializeStreamReceipt(encoded)
+    const decoded = deserializeSessionReceipt(encoded)
     expect(decoded).toEqual(receipt)
   })
 
   test('serialize produces base64url without padding', () => {
-    const receipt = createStreamReceipt({
+    const receipt = createSessionReceipt({
       challengeId: 'test-challenge-id',
       channelId,
       acceptedCumulative: 1n,
       spent: 0n,
     })
 
-    const encoded = serializeStreamReceipt(receipt)
+    const encoded = serializeSessionReceipt(receipt)
     // base64url uses - and _ instead of + and /, no = padding
     expect(encoded).not.toMatch(/[+/=]/)
   })

package/src/tempo/{stream → session}/Receipt.ts

@@ -1,18 +1,18 @@
 import { Base64 } from 'ox'
 import type { Hex } from 'viem'
-import type { StreamReceipt } from './Types.js'
+import type { SessionReceipt } from './Types.js'
 
 /**
- * Create a stream receipt.
+ * Create a session receipt.
  */
-export function createStreamReceipt(params: {
+export function createSessionReceipt(params: {
   challengeId: string
   channelId: Hex
   acceptedCumulative: bigint
   spent: bigint
   units?: number | undefined
   txHash?: Hex | undefined
-}): StreamReceipt {
+}): SessionReceipt {
   return {
     method: 'tempo',
     intent: 'session',
@@ -29,17 +29,17 @@ export function createStreamReceipt(params: {
 }
 
 /**
- * Serialize a stream receipt to the Payment-Receipt header format.
+ * Serialize a session receipt to the Payment-Receipt header format.
  */
-export function serializeStreamReceipt(receipt: StreamReceipt): string {
+export function serializeSessionReceipt(receipt: SessionReceipt): string {
   const json = JSON.stringify(receipt)
   return Base64.fromString(json, { pad: false, url: true })
 }
 
 /**
- * Deserialize a Payment-Receipt header value to a stream receipt.
+ * Deserialize a Payment-Receipt header value to a session receipt.
  */
-export function deserializeStreamReceipt(encoded: string): StreamReceipt {
+export function deserializeSessionReceipt(encoded: string): SessionReceipt {
   const json = Base64.toString(encoded)
-  return JSON.parse(json) as StreamReceipt
+  return JSON.parse(json) as SessionReceipt
 }