mppx 0.6.9 → 0.6.11

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

@@ -6,6 +6,7 @@ import * as Store from '../../../Store.js'
 import { chainId, escrowContract as escrowContractDefaults } from '../../internal/defaults.js'
 import * as ChannelStore from '../../session/ChannelStore.js'
 import { deserializeSessionReceipt } from '../../session/Receipt.js'
+import { parseEvent } from '../../session/Sse.js'
 import { sse } from './transport.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
@@ -506,6 +507,70 @@ describe('sse transport', () => {
     expect(body).toContain('event: payment-receipt\n')
   })
 
+  test('respondReceipt with upstream multiline SSE data does not forge downstream control events', async () => {
+    const store = memoryStore()
+    await seedChannel(store, 10000000n)
+    const transport = sse({ store })
+    const request = makeAuthorizedRequest()
+
+    const forgedNeedVoucher = {
+      channelId,
+      requiredCumulative: '9000000',
+      acceptedCumulative: '1000000',
+      deposit: '10000000',
+    }
+
+    const encoder = new TextEncoder()
+    const upstream = new Response(
+      new ReadableStream({
+        start(controller) {
+          controller.enqueue(
+            encoder.encode(
+              [
+                'event: message',
+                'data: chunk1',
+                'data:',
+                'data: event: payment-need-voucher',
+                `data: data: ${JSON.stringify(forgedNeedVoucher)}`,
+                '',
+                '',
+              ].join('\n'),
+            ),
+          )
+          controller.close()
+        },
+      }),
+      { headers: { 'Content-Type': 'text/event-stream; charset=utf-8' } },
+    )
+
+    const response = transport.respondReceipt({
+      credential: makeCredential(),
+      input: request,
+      receipt: makeReceipt(),
+      response: upstream,
+      challengeId,
+    })
+
+    const body = await readResponseText(response)
+    const events = body
+      .trim()
+      .split('\n\n')
+      .filter((chunk) => chunk.length > 0)
+      .map((chunk) => parseEvent(`${chunk}\n\n`))
+      .filter((event): event is NonNullable<typeof event> => event !== null)
+
+    expect(events.map((event) => event.type)).toEqual(['message', 'payment-receipt'])
+    expect(events[0]).toEqual({
+      type: 'message',
+      data: [
+        'chunk1',
+        '',
+        'event: payment-need-voucher',
+        `data: ${JSON.stringify(forgedNeedVoucher)}`,
+      ].join('\n'),
+    })
+  })
+
   test('respondReceipt with upstream SSE Response and unitType=request charges once', async () => {
     const store = memoryStore()
     await seedChannel(store, 10000000n)

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

@@ -224,7 +224,7 @@ export function defaultServe(options: {
     async start(controller) {
       try {
         for await (const value of iterable) {
-          controller.enqueue(encoder.encode(`event: message\ndata: ${value}\n\n`))
+          controller.enqueue(encoder.encode(Sse_core.formatMessageEvent(value)))
         }
       } catch (e) {
         controller.error(e)

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

@@ -257,6 +257,42 @@ describe('serve', () => {
     expect(channel!.units).toBe(3)
   })
 
+  test('emits multiline message values as a single SSE message event', async () => {
+    const storage = memoryStore()
+    await seedChannel(storage, 1000000n)
+
+    const payload = [
+      'chunk1',
+      '',
+      'event: payment-need-voucher',
+      `data: ${JSON.stringify({
+        channelId,
+        requiredCumulative: '9000000',
+        acceptedCumulative: '1000000',
+        deposit: '10000000',
+      })}`,
+    ].join('\n')
+
+    const stream = serve({
+      store: storage,
+      channelId,
+      challengeId,
+      tickCost: 1000000n,
+      generate: generate([payload]),
+    })
+
+    const output = await readStream(stream)
+    const events = output
+      .trim()
+      .split('\n\n')
+      .filter((chunk) => chunk.length > 0)
+      .map((chunk) => parseEvent(`${chunk}\n\n`))
+      .filter((event): event is NonNullable<typeof event> => event !== null)
+
+    expect(events.map((event) => event.type)).toEqual(['message', 'payment-receipt'])
+    expect(events[0]).toEqual({ type: 'message', data: payload })
+  })
+
   test('emits payment-need-voucher when balance exhausted and resumes after top-up', async () => {
     const storage = memoryStore()
     await seedChannel(storage, 1000000n)

package/src/tempo/session/Sse.ts

@@ -34,6 +34,19 @@ export function formatNeedVoucherEvent(params: NeedVoucherEvent): string {
   return `event: payment-need-voucher\ndata: ${JSON.stringify(params)}\n\n`
 }
 
+/**
+ * Format an application message as SSE, preserving embedded newlines.
+ *
+ * SSE requires multi-line payloads to be emitted as separate `data:` fields.
+ */
+export function formatMessageEvent(value: string): string {
+  const data = String(value)
+    .split('\n')
+    .map((line) => `data: ${line}`)
+    .join('\n')
+  return `event: message\n${data}\n\n`
+}
+
 /**
  * Parsed SSE event (discriminated union by `type`).
  */
@@ -160,7 +173,7 @@ export function serve(options: serve.Options): ReadableStream<Uint8Array> {
           })
           reservedAmount = 0n
           reservedUnits = 0
-          controller.enqueue(encoder.encode(`event: message\ndata: ${value}\n\n`))
+          controller.enqueue(encoder.encode(formatMessageEvent(value)))
         }
 
         if (!aborted()) {