mppx 0.4.7 → 0.4.9

package/src/Errors.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'vitest'
+
 import {
   AmountExceedsDepositError,
   BadRequestError,
@@ -41,9 +42,8 @@ describe('MalformedCredentialError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new MalformedCredentialError({ reason: 'invalid base64url' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new MalformedCredentialError({ reason: 'invalid base64url' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Credential is malformed: invalid base64url.",
           "name": "MalformedCredentialError",
@@ -89,9 +89,8 @@ describe('InvalidChallengeError', () => {
   })
 
   test('with id and reason', () => {
-    expect(
-      errorSnapshot(new InvalidChallengeError({ id: 'abc123', reason: 'already used' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new InvalidChallengeError({ id: 'abc123', reason: 'already used' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Challenge "abc123" is invalid: already used.",
           "name": "InvalidChallengeError",
@@ -115,9 +114,8 @@ describe('VerificationFailedError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new VerificationFailedError({ reason: 'invalid signature' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new VerificationFailedError({ reason: 'invalid signature' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Payment verification failed: invalid signature.",
           "name": "VerificationFailedError",
@@ -141,9 +139,8 @@ describe('PaymentExpiredError', () => {
   })
 
   test('with expires', () => {
-    expect(
-      errorSnapshot(new PaymentExpiredError({ expires: '2025-01-26T12:00:00Z' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new PaymentExpiredError({ expires: '2025-01-26T12:00:00Z' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Payment expired at 2025-01-26T12:00:00Z.",
           "name": "PaymentExpiredError",
@@ -167,9 +164,8 @@ describe('PaymentRequiredError', () => {
   })
 
   test('with description', () => {
-    expect(
-      errorSnapshot(new PaymentRequiredError({ description: 'API access fee' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new PaymentRequiredError({ description: 'API access fee' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Payment is required (API access fee).",
           "name": "PaymentRequiredError",
@@ -193,9 +189,8 @@ describe('InvalidPayloadError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new InvalidPayloadError({ reason: 'missing signature field' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new InvalidPayloadError({ reason: 'missing signature field' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Credential payload is invalid: missing signature field.",
           "name": "InvalidPayloadError",
@@ -219,9 +214,8 @@ describe('BadRequestError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new BadRequestError({ reason: 'cannot combine hash type with feePayer' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new BadRequestError({ reason: 'cannot combine hash type with feePayer' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Bad request: cannot combine hash type with feePayer.",
           "name": "BadRequestError",
@@ -245,9 +239,8 @@ describe('PaymentInsufficientError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new PaymentInsufficientError({ reason: 'expected 1000, received 500' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new PaymentInsufficientError({ reason: 'expected 1000, received 500' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Payment insufficient: expected 1000, received 500.",
           "name": "PaymentInsufficientError",
@@ -271,9 +264,8 @@ describe('PaymentMethodUnsupportedError', () => {
   })
 
   test('with method', () => {
-    expect(
-      errorSnapshot(new PaymentMethodUnsupportedError({ method: 'bitcoin' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new PaymentMethodUnsupportedError({ method: 'bitcoin' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Payment method "bitcoin" is not supported.",
           "name": "PaymentMethodUnsupportedError",
@@ -297,9 +289,8 @@ describe('InsufficientBalanceError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new InsufficientBalanceError({ reason: 'requested 500, available 100' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new InsufficientBalanceError({ reason: 'requested 500, available 100' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Insufficient balance: requested 500, available 100.",
           "name": "InsufficientBalanceError",
@@ -323,9 +314,8 @@ describe('InvalidSignatureError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new InvalidSignatureError({ reason: 'ECDSA recovery failed' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new InvalidSignatureError({ reason: 'ECDSA recovery failed' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Invalid signature: ECDSA recovery failed.",
           "name": "InvalidSignatureError",
@@ -401,9 +391,8 @@ describe('ChannelClosedError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new ChannelClosedError({ reason: 'channel is finalized on-chain' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new ChannelClosedError({ reason: 'channel is finalized on-chain' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Channel closed: channel is finalized on-chain.",
           "name": "ChannelClosedError",
@@ -427,9 +416,8 @@ describe('PaymentActionRequiredError', () => {
   })
 
   test('with reason', () => {
-    expect(
-      errorSnapshot(new PaymentActionRequiredError({ reason: 'requires_action' })),
-    ).toMatchInlineSnapshot(`
+    expect(errorSnapshot(new PaymentActionRequiredError({ reason: 'requires_action' })))
+      .toMatchInlineSnapshot(`
         {
           "message": "Payment requires action: requires_action.",
           "name": "PaymentActionRequiredError",

package/src/Expires.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
 import * as Expires from './Expires.js'
 
 const FIXED_NOW = new Date('2025-06-15T12:00:00.000Z').getTime()

package/src/PaymentRequest.ts

@@ -1,4 +1,5 @@
 import { Base64, Json } from 'ox'
+
 import type { Compute } from './internal/types.js'
 import type * as Method from './Method.js'
 import type * as z from './zod.js'

package/src/Receipt.ts

@@ -1,4 +1,5 @@
 import { Base64 } from 'ox'
+
 import * as z from './zod.js'
 
 /**

package/src/Store.test-d.ts

@@ -0,0 +1,59 @@
+import { expectTypeOf, test } from 'vitest'
+
+import * as Store from './Store.js'
+
+test('default Store accepts any string key', () => {
+  const store = Store.memory()
+  expectTypeOf(store.get).parameter(0).toBeString()
+  expectTypeOf(store.put).parameter(0).toBeString()
+  expectTypeOf(store.delete).parameter(0).toBeString()
+})
+
+test('default Store get returns unknown', async () => {
+  const store = Store.memory()
+  const value = await store.get('anything')
+  expectTypeOf(value).toEqualTypeOf<unknown>()
+})
+
+test('typed Store constrains keys', () => {
+  type ItemMap = { [key: `mppx:charge:${string}`]: number }
+  const store = {} as Store.Store<ItemMap>
+
+  expectTypeOf(store.get).parameter(0).toEqualTypeOf<`mppx:charge:${string}`>()
+  expectTypeOf(store.put).parameter(0).toEqualTypeOf<`mppx:charge:${string}`>()
+  expectTypeOf(store.delete).parameter(0).toEqualTypeOf<`mppx:charge:${string}`>()
+})
+
+test('typed Store infers value from key', async () => {
+  type ItemMap = { [key: `mppx:charge:${string}`]: number }
+  const store = {} as Store.Store<ItemMap>
+
+  const value = await store.get('mppx:charge:0x123')
+  expectTypeOf(value).toEqualTypeOf<number | null>()
+})
+
+test('typed Store enforces value type on put', () => {
+  type ItemMap = { [key: `mppx:charge:${string}`]: number }
+  const store = {} as Store.Store<ItemMap>
+
+  // @ts-expect-error — value must be number, not string
+  store.put('mppx:charge:0x123', 'wrong')
+})
+
+test('cloudflare returns generic Store', () => {
+  const store = Store.cloudflare({
+    get: async () => null,
+    put: async () => {},
+    delete: async () => {},
+  })
+  expectTypeOf(store).toEqualTypeOf<Store.Store>()
+})
+
+test('upstash returns generic Store', () => {
+  const store = Store.upstash({
+    get: async () => null,
+    set: async () => null,
+    del: async () => null,
+  })
+  expectTypeOf(store).toEqualTypeOf<Store.Store>()
+})

package/src/Store.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'vitest'
+
 import * as Store from './Store.js'
 
 const nested = {
@@ -7,16 +8,16 @@ const nested = {
   meta: { active: true, tags: ['a', 'b'] },
 }
 
-function fakeKv(): Store.cloudflare.Parameters {
+function fakeKv() {
   const map = new Map<string, string>()
   return {
-    async get(key) {
+    async get(key: string) {
       return map.get(key) ?? null
     },
-    async put(key, value) {
+    async put(key: string, value: string) {
       map.set(key, value)
     },
-    async delete(key) {
+    async delete(key: string) {
       map.delete(key)
     },
   }
@@ -25,6 +26,17 @@ function fakeKv(): Store.cloudflare.Parameters {
 describe.each([
   { label: 'memory', create: () => Store.memory() },
   { label: 'cloudflare', create: () => Store.cloudflare(fakeKv()) },
+  {
+    label: 'redis',
+    create: () => {
+      const kv = fakeKv()
+      return Store.redis({
+        get: kv.get,
+        set: kv.put,
+        del: (key) => kv.delete(key),
+      })
+    },
+  },
   {
     label: 'upstash',
     create: () => {
@@ -64,6 +76,20 @@ describe.each([
 })
 
 describe('json roundtrip behavior', () => {
+  test('cloudflare json-roundtrips nested objects', async () => {
+    const store = Store.cloudflare(fakeKv())
+    const value = { a: [1, { b: 'c' }], d: null }
+    await store.put('k', value)
+    expect(await store.get('k')).toEqual(value)
+  })
+
+  test('cloudflare roundtrips BigInt values', async () => {
+    const store = Store.cloudflare(fakeKv())
+    const value = { amount: 1000000000000000000n, nested: { big: 42n } }
+    await store.put('k', value)
+    expect(await store.get('k')).toEqual(value)
+  })
+
   test('memory json-roundtrips nested objects', async () => {
     const store = Store.memory()
     const value = { a: [1, { b: 'c' }], d: null }
@@ -71,13 +97,37 @@ describe('json roundtrip behavior', () => {
     expect(await store.get('k')).toEqual(value)
   })
 
-  test('cloudflare json-roundtrips nested objects', async () => {
-    const store = Store.cloudflare(fakeKv())
+  test('memory roundtrips BigInt values', async () => {
+    const store = Store.memory()
+    const value = { amount: 1000000000000000000n, nested: { big: 42n } }
+    await store.put('k', value)
+    expect(await store.get('k')).toEqual(value)
+  })
+
+  test('redis json-roundtrips nested objects', async () => {
+    const kv = fakeKv()
+    const store = Store.redis({
+      get: kv.get,
+      set: kv.put,
+      del: (key) => kv.delete(key),
+    })
     const value = { a: [1, { b: 'c' }], d: null }
     await store.put('k', value)
     expect(await store.get('k')).toEqual(value)
   })
 
+  test('redis roundtrips BigInt values', async () => {
+    const kv = fakeKv()
+    const store = Store.redis({
+      get: kv.get,
+      set: kv.put,
+      del: (key) => kv.delete(key),
+    })
+    const value = { amount: 1000000000000000000n, nested: { big: 42n } }
+    await store.put('k', value)
+    expect(await store.get('k')).toEqual(value)
+  })
+
   test('upstash passes values through without json serialization', async () => {
     const kv = fakeKv()
     const store = Store.upstash({

package/src/Store.ts

@@ -6,10 +6,12 @@
  */
 import { Json } from 'ox'
 
-export type Store = {
-  get: <value = unknown>(key: string) => Promise<value | null>
-  put: (key: string, value: unknown) => Promise<void>
-  delete: (key: string) => Promise<void>
+export type StoreItemMap = Record<string, unknown>
+
+export type Store<itemMap extends StoreItemMap = StoreItemMap> = {
+  get: <key extends keyof itemMap & string>(key: key) => Promise<itemMap[key] | null>
+  put: <key extends keyof itemMap & string>(key: key, value: itemMap[key]) => Promise<void>
+  delete: <key extends keyof itemMap & string>(key: key) => Promise<void>
 }
 
 /** Creates a {@link Store} from an existing implementation. */
@@ -60,6 +62,31 @@ export function memory(): Store {
   })
 }
 
+/** Wraps a standard Redis client (ioredis, node-redis, Valkey). */
+export function redis(client: redis.Parameters): Store {
+  return from({
+    async get(key) {
+      const raw = await client.get(key)
+      if (raw == null) return null as any
+      return Json.parse(raw)
+    },
+    async put(key, value) {
+      await client.set(key, Json.stringify(value))
+    },
+    async delete(key) {
+      await client.del(key)
+    },
+  })
+}
+
+export declare namespace redis {
+  export type Parameters = {
+    get: (key: string) => Promise<string | null>
+    set: (key: string, value: string) => Promise<unknown>
+    del: (key: string) => Promise<unknown>
+  }
+}
+
 /** Wraps an Upstash Redis instance (e.g. Vercel KV). */
 export function upstash(redis: upstash.Parameters): Store {
   return from({

package/src/cli/account.ts

@@ -55,50 +55,85 @@ export function createKeychain(account = 'main') {
     async list(): Promise<string[]> {
       const platform = os.platform()
       if (platform === 'darwin') {
-          const { stdout, error } = await execCommand('security', ['dump-keychain'])
-          if (error) return []
-          const accounts: string[] = []
-          const blocks = stdout.split('keychain:')
-          for (const block of blocks) {
-            const serviceMatch = block.match(/"svce"<blob>="([^"]*)"/)
-            const accountMatch = block.match(/"acct"<blob>="([^"]*)"/)
-            if (serviceMatch?.[1] === service && accountMatch?.[1]) accounts.push(accountMatch[1])
-          }
-          return accounts
+        const { stdout, error } = await execCommand('security', ['dump-keychain'])
+        if (error) return []
+        const accounts: string[] = []
+        const blocks = stdout.split('keychain:')
+        for (const block of blocks) {
+          const serviceMatch = block.match(/"svce"<blob>="([^"]*)"/)
+          const accountMatch = block.match(/"acct"<blob>="([^"]*)"/)
+          if (serviceMatch?.[1] === service && accountMatch?.[1]) accounts.push(accountMatch[1])
+        }
+        return accounts
       }
       if (platform === 'linux') {
-          const { stdout, stderr, error } = await execCommand('secret-tool', ['search', '--all', '--unlock', 'service', service])
-          if (error) return []
-          const combined = `${stdout}\n${stderr}`
-          const accounts: string[] = []
-          const matches = combined.matchAll(/\baccount = (.+)/g)
-          for (const match of matches) if (match[1]) accounts.push(match[1])
-          return accounts
+        const { stdout, stderr, error } = await execCommand('secret-tool', [
+          'search',
+          '--all',
+          '--unlock',
+          'service',
+          service,
+        ])
+        if (error) return []
+        const combined = `${stdout}\n${stderr}`
+        const accounts: string[] = []
+        const matches = combined.matchAll(/\baccount = (.+)/g)
+        for (const match of matches) if (match[1]) accounts.push(match[1])
+        return accounts
       }
       throw new Error(`Unsupported platform: ${platform}`)
     },
     async get(): Promise<string | undefined> {
       const platform = os.platform()
       if (platform === 'darwin') {
-          const { stdout, error } = await execCommand('security', ['find-generic-password', '-s', service, '-a', account, '-w'])
-          return error ? undefined : stdout
+        const { stdout, error } = await execCommand('security', [
+          'find-generic-password',
+          '-s',
+          service,
+          '-a',
+          account,
+          '-w',
+        ])
+        return error ? undefined : stdout
       }
       if (platform === 'linux') {
-          const { stdout, error } = await execCommand('secret-tool', ['lookup', 'service', service, 'account', account])
-          return error ? undefined : stdout || undefined
+        const { stdout, error } = await execCommand('secret-tool', [
+          'lookup',
+          'service',
+          service,
+          'account',
+          account,
+        ])
+        return error ? undefined : stdout || undefined
       }
       throw new Error(`Unsupported platform: ${platform}`)
     },
     async set(value: string): Promise<void> {
       const platform = os.platform()
       if (platform === 'darwin') {
-          await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
-          const { error } = await execCommand('security', ['add-generic-password', '-s', service, '-a', account, '-w', value])
-          if (error) throw error
-          return
+        await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
+        const { error } = await execCommand('security', [
+          'add-generic-password',
+          '-s',
+          service,
+          '-a',
+          account,
+          '-w',
+          value,
+        ])
+        if (error) throw error
+        return
       }
       if (platform === 'linux') {
-        const proc = child.execFile('secret-tool', ['store', '--label', `${service} ${account}`, 'service', service, 'account', account])
+        const proc = child.execFile('secret-tool', [
+          'store',
+          '--label',
+          `${service} ${account}`,
+          'service',
+          service,
+          'account',
+          account,
+        ])
         proc.stdin?.write(value)
         proc.stdin?.end()
         return new Promise((resolve, reject) => {
@@ -114,12 +149,12 @@ export function createKeychain(account = 'main') {
     async delete(): Promise<void> {
       const platform = os.platform()
       if (platform === 'darwin') {
-          await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
-          return
+        await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
+        return
       }
       if (platform === 'linux') {
-          await execCommand('secret-tool', ['clear', 'service', service, 'account', account])
-          return
+        await execCommand('secret-tool', ['clear', 'service', service, 'account', account])
+        return
       }
       throw new Error(`Unsupported platform: ${platform}`)
     },

package/src/cli/cli.test.ts

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process'
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
+
 import { parseUnits } from 'viem'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { Addresses } from 'viem/tempo'
@@ -10,11 +11,14 @@ import * as Http from '~test/Http.js'
 import { rpcUrl } from '~test/tempo/prool.js'
 import { deployEscrow } from '~test/tempo/session.js'
 import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
-import * as Store from '../Store.js'
+
+import * as Credential from '../Credential.js'
 import * as Mppx_server from '../server/Mppx.js'
 import { toNodeListener } from '../server/Mppx.js'
+import * as Store from '../Store.js'
 import { stripe as stripe_server } from '../stripe/server/Methods.js'
 import { tempo } from '../tempo/server/Methods.js'
+import type { SessionCredentialPayload } from '../tempo/session/Types.js'
 import cli from './cli.js'
 
 const testPrivateKey = generatePrivateKey()
@@ -192,6 +196,128 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
     }
   })
 
+  test('bug: non-SSE open should not double-charge tick amount', { timeout: 120_000 }, async () => {
+    await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
+    await fundAccount({ address: testAccount.address, token: asset })
+
+    const escrow = await deployEscrow()
+    const store = Store.memory()
+    const tickAmount = '0.001'
+    const server = Mppx_server.create({
+      methods: [
+        tempo.session({
+          account: accounts[0],
+          store,
+          getClient: () => client,
+          currency: asset,
+          escrowContract: escrow,
+          chainId: client.chain.id,
+          feePayer: true,
+        }),
+      ],
+      realm: 'cli-test-double-charge',
+      secretKey: 'cli-test-secret',
+    })
+
+    // Track voucher cumulative amounts from credential payloads
+    const voucherAmounts: string[] = []
+
+    const httpServer = await Http.createServer(async (req, res) => {
+      const authHeader = req.headers.authorization
+      if (authHeader) {
+        try {
+          const cred = Credential.deserialize<SessionCredentialPayload>(authHeader)
+          if (cred.payload.action === 'voucher' && 'cumulativeAmount' in cred.payload) {
+            voucherAmounts.push(cred.payload.cumulativeAmount)
+          }
+        } catch {}
+      }
+
+      const result = await toNodeListener(
+        server.session({
+          amount: tickAmount,
+          recipient: accounts[0].address,
+          unitType: 'page',
+        }),
+      )(req, res)
+      if (result.status === 402) return
+      // Non-SSE: plain text response (not text/event-stream)
+      res.end('scraped-content')
+    })
+
+    try {
+      await serve([httpServer.url, '--rpc-url', rpcUrl, '-s', '-M', 'deposit=10'], {
+        env: { MPPX_PRIVATE_KEY: testPrivateKey },
+      })
+
+      // No follow-up voucher should be sent after a non-SSE open.
+      // The open credential already paid for this unit, so the CLI
+      // should NOT send a redundant voucher that would double-charge.
+      expect(voucherAmounts.length).toBe(0)
+    } finally {
+      httpServer.close()
+    }
+  })
+
+  test('bug: closeChannel sends action "close" not "voucher"', { timeout: 120_000 }, async () => {
+    await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
+    await fundAccount({ address: testAccount.address, token: asset })
+
+    const escrow = await deployEscrow()
+    const store = Store.memory()
+    const server = Mppx_server.create({
+      methods: [
+        tempo.session({
+          account: accounts[0],
+          store,
+          getClient: () => client,
+          currency: asset,
+          escrowContract: escrow,
+          chainId: client.chain.id,
+          feePayer: true,
+        }),
+      ],
+      realm: 'cli-test-close-action',
+      secretKey: 'cli-test-secret',
+    })
+
+    // Track the credential payload action from the close request
+    const credentialActions: string[] = []
+
+    const httpServer = await Http.createServer(async (req, res) => {
+      // Capture credential action from every request with Authorization header
+      const authHeader = req.headers.authorization
+      if (authHeader) {
+        try {
+          const cred = Credential.deserialize<SessionCredentialPayload>(authHeader)
+          credentialActions.push(cred.payload.action)
+        } catch {}
+      }
+
+      const result = await toNodeListener(
+        server.session({
+          amount: '0.001',
+          recipient: accounts[0].address,
+          unitType: 'page',
+        }),
+      )(req, res)
+      if (result.status === 402) return
+      res.end('scraped-content')
+    })
+
+    try {
+      await serve([httpServer.url, '--rpc-url', rpcUrl, '-s', '-M', 'deposit=10'], {
+        env: { MPPX_PRIVATE_KEY: testPrivateKey },
+      })
+
+      // The last credential sent should be the close request with action: 'close'
+      const lastAction = credentialActions[credentialActions.length - 1]
+      expect(lastAction).toBe('close')
+    } finally {
+      httpServer.close()
+    }
+  })
+
   test('error: --fail exits on server error', { timeout: 60_000 }, async () => {
     const httpServer = await Http.createServer(async (_req, res) => {
       res.writeHead(500)