mppx 0.3.3 → 0.3.5

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)
@@ -1099,6 +1099,58 @@ describe('session', () => {
       } as any)
       expect(result).toBeUndefined()
     })
+
+    test('returns undefined for voucher POST with content-length > 0 (content request)', () => {
+      const server = createServer()
+      const result = server.respond!({
+        credential: {
+          challenge: makeChallenge({
+            channelId: '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex,
+          }),
+          payload: { action: 'voucher' },
+        },
+        input: new Request('http://localhost', {
+          method: 'POST',
+          headers: { 'content-length': '42' },
+        }),
+      } as any)
+      expect(result).toBeUndefined()
+    })
+
+    test('returns undefined for voucher POST with transfer-encoding header (content request)', () => {
+      const server = createServer()
+      const result = server.respond!({
+        credential: {
+          challenge: makeChallenge({
+            channelId: '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex,
+          }),
+          payload: { action: 'voucher' },
+        },
+        input: new Request('http://localhost', {
+          method: 'POST',
+          headers: { 'transfer-encoding': 'chunked' },
+        }),
+      } as any)
+      expect(result).toBeUndefined()
+    })
+
+    test('returns 204 for voucher POST with content-length: 0', () => {
+      const server = createServer()
+      const result = server.respond!({
+        credential: {
+          challenge: makeChallenge({
+            channelId: '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex,
+          }),
+          payload: { action: 'voucher' },
+        },
+        input: new Request('http://localhost', {
+          method: 'POST',
+          headers: { 'content-length': '0' },
+        }),
+      } as any)
+      expect(result).toBeInstanceOf(Response)
+      expect((result as Response).status).toBe(204)
+    })
   })
 
   describe('SSE', () => {
@@ -1110,7 +1162,7 @@ describe('session', () => {
             currency: asset,
             escrowContract,
             getClient: () => client,
-            stream: true,
+            sse: true,
           }),
         ],
         realm: 'api.example.com',
@@ -1147,7 +1199,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'