@livestore/common-cf 0.4.0 → 0.5.0-dev.0

package/src/do-rpc/server.ts

@@ -1,26 +1,43 @@
 import {
-  Chunk,
   Effect,
   Exit,
   Headers,
   type Layer,
-  type NonEmptyArray,
   Option,
+  type ReadonlyArray,
   Rpc,
   type RpcGroup,
-  type RpcMessage,
+  RpcMessage,
   RpcSchema,
   RpcSerialization,
+  Result,
   Schema,
+  SchemaIssue,
   type Scope,
   Stream,
 } from '@livestore/utils/effect'
 
 import type * as CfTypes from '../cf-types.ts'
 
+/**
+ * The erased dynamic RPC schemas (`Rpc.exitSchema(...) as Schema.Top`, `rpc.payloadSchema`) are
+ * plain data — they need NO decoding/encoding services. `Schema.Top` types those service channels
+ * as `unknown`, which surfaces as `unknown` in the requirements channel of `encode/decodeUnknownEffect`
+ * (anyUnknownInErrorContext / TS377030). Assert the true `never` services in ONE place.
+ *
+ * TODO(effect): revisit if a cleaner/idiomatic API lands — https://github.com/Effect-TS/effect/issues/6489
+ */
+const erasedJsonCodec = (schema: Schema.Top) =>
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- erased RPC data schemas require no codec services
+  Schema.toCodecJson(schema as Schema.Codec<unknown, unknown, never, never>)
+
 export interface ClientDoWithRpcCallback {
   __DURABLE_OBJECT_BRAND: never
-  syncUpdateRpc: (payload: RpcMessage.ResponseChunkEncoded) => Promise<void>
+  /**
+   * The sync backend calls this to deliver a live update; `storeId` lets a rebuilt DO reload its
+   * store before delivering. See the Cloudflare Durable Object adapter docs for the recovery options.
+   */
+  syncUpdateRpc: (payload: Uint8Array<ArrayBuffer>, storeId: string) => Promise<void>
 }
 
 /**
@@ -41,13 +58,13 @@ export const toDurableObjectHandler =
   ) => Effect.Effect<Uint8Array<ArrayBuffer> | CfTypes.ReadableStream>) =>
   (serializedPayload) =>
     Effect.gen(function* () {
-      const parser = RpcSerialization.msgPack.unsafeMake()
+      const parser = RpcSerialization.msgPack.makeUnsafe()
 
       // Decode incoming requests - client sends array of requests
       const decoded = parser.decode(serializedPayload)
 
       // Handle potential nested array from client serialization
-      let requests: RpcMessage.FromClient<Rpcs>[]
+      let requests: RpcMessage.FromClientEncoded[]
       if (Array.isArray(decoded) === true && decoded.length === 1 && Array.isArray(decoded[0]) === true) {
         // Double-wrapped array [[{...}]] -> [{...}]
         requests = decoded[0]
@@ -68,57 +85,83 @@ export const toDurableObjectHandler =
         if (request._tag !== 'Request') {
           continue
         }
+        const requestId = RpcMessage.RequestId(request.id)
 
         // Find the RPC handler
         // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- RpcGroup.requests map returns Rpc.Any; narrowing to AnyWithProps for property access
         const rpc = group.requests.get(request.tag)! as unknown as Rpc.AnyWithProps
-        // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- context.unsafeMap dynamic lookup; type safety ensured by RpcGroup registration
-        const entry = context.unsafeMap.get(rpc.key) as Rpc.Handler<Rpcs['_tag']>
+        // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- context.mapUnsafe dynamic lookup; type safety ensured by RpcGroup registration
+        const entry = context.mapUnsafe.get(rpc.key) as Rpc.Handler<Rpcs['_tag']>
 
         if (rpc == null || entry == null) {
           responses.push({
             _tag: 'Exit',
-            requestId: request.id,
+            requestId,
             exit: Exit.die(`Unknown request tag: ${request.tag}`),
           })
           continue
         }
 
+        const payloadResult = yield* Schema.decodeUnknownEffect(erasedJsonCodec(rpc.payloadSchema))(
+          request.payload,
+        ).pipe(Effect.provideContext(entry.context), Effect.result)
+
+        if (Result.isFailure(payloadResult) === true) {
+          // Request payloads are encoded with the JSON codec by Effect's RPC client. Decode them
+          // before dispatch so JSON-only representations such as `null` become their schema values.
+          // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Rpc.exitSchema requires AnyWithProps; type narrowing already done above
+          const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Top
+          const rawExit = Exit.die(SchemaIssue.makeFormatterDefault()(payloadResult.failure.issue))
+          const encodedExit = yield* Schema.encodeUnknownEffect(erasedJsonCodec(exitSchema))(rawExit).pipe(
+            Effect.provideContext(entry.context),
+          )
+          responses.push({
+            _tag: 'Exit',
+            requestId,
+            exit: encodedExit,
+          })
+          continue
+        }
+
+        const payload = payloadResult.success
+
         // Check if this is a streaming RPC
-        // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Rpc.Handler doesn't expose successSchema publicly; see https://github.com/Effect-TS/effect/issues/6064
-        const isStream = RpcSchema.isStreamSchema((rpc as any).successSchema)
+        const isStream = RpcSchema.isStreamSchema(rpc.successSchema)
 
         // For streaming RPCs with only one request, return ReadableStream directly
         if (isStream === true && requests.length === 1) {
-          return yield* createStreamingResponse(rpc, entry, request, parser, options.layer)
+          return yield* createStreamingResponse(rpc, entry, requestId, payload, parser, options.layer)
         }
 
         // Execute the handler
         const result = yield* Effect.gen(function* () {
-          const handlerResult = entry.handler(request.payload, {
-            clientId: 0, // TODO: add proper clientId if needed
+          const handlerResult = entry.handler(payload, {
+            client: new Rpc.ServerClient(0), // TODO: add proper clientId if needed
+            requestId,
             headers: Headers.fromInput({
-              'x-rpc-request-id': request.id.toString(),
+              'x-rpc-request-id': requestId.toString(),
             }),
+            rpc,
           })
+          const effectOrStream = Rpc.isWrapper(handlerResult) === true ? handlerResult.value : handlerResult
 
           let value: any
-          if (Effect.isEffect(handlerResult) === true) {
+          if (Effect.isEffect(effectOrStream) === true) {
             // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- `Rpc.Handler.handler` returns `Effect<any, any>` due to dynamic dispatch
-            value = yield* handlerResult
+            value = yield* effectOrStream
           } else {
-            value = handlerResult
+            value = effectOrStream
           }
 
           // Get the exit schema for this RPC
           // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Rpc.exitSchema requires AnyWithProps; type narrowing already done above
-          const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Schema<any>
+          const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Top
 
           let encodedExit: any
           if (exitSchema !== undefined) {
             // Use schema encoding for proper serialization
             const rawExit = Exit.succeed(value)
-            encodedExit = yield* Schema.encodeUnknown(exitSchema)(rawExit)
+            encodedExit = yield* Schema.encodeUnknownEffect(erasedJsonCodec(exitSchema))(rawExit)
           } else {
             // Fallback to direct exit
             encodedExit = Exit.succeed(value)
@@ -126,21 +169,21 @@ export const toDurableObjectHandler =
 
           return {
             _tag: 'Exit' as const,
-            requestId: request.id,
+            requestId,
             exit: encodedExit,
           }
         }).pipe(
-          Effect.catchAllCause((cause) => {
+          Effect.catchCause((cause) => {
             // Get the exit schema for this RPC
             // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Rpc.exitSchema requires AnyWithProps; type narrowing already done above
-            const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Schema<any>
+            const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Top
 
             return Effect.gen(function* () {
               let encodedExit: any
               if (exitSchema !== undefined) {
                 // Use schema encoding for proper serialization
                 const rawExit = Exit.failCause(cause)
-                encodedExit = yield* Schema.encodeUnknown(exitSchema)(rawExit)
+                encodedExit = yield* Schema.encodeUnknownEffect(erasedJsonCodec(exitSchema))(rawExit)
               } else {
                 // Fallback to direct exit
                 encodedExit = Exit.failCause(cause)
@@ -148,7 +191,7 @@ export const toDurableObjectHandler =
 
               return {
                 _tag: 'Exit' as const,
-                requestId: request.id,
+                requestId,
                 exit: encodedExit,
               }
             })
@@ -161,19 +204,23 @@ export const toDurableObjectHandler =
       // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- msgPack parser.encode returns unknown; cast to expected wire format
       const encoded = parser.encode(responses) as Uint8Array<ArrayBuffer>
       return encoded
-    }).pipe(Effect.provide(options.layer), Effect.scoped, Effect.orDie)
+    }).pipe(Effect.provide(options.layer), Effect.scoped, Effect.orDie) as Effect.Effect<
+      Uint8Array<ArrayBuffer> | CfTypes.ReadableStream
+    >
 
 /** Out-of-band RPC stream response emission back to the caller DO */
 export const emitStreamResponse = Effect.fn('do-rpc/emitStreamResponse')(function* ({
   callerContext,
   env,
   requestId,
+  storeId,
   values,
 }: {
   env: Record<string, any>
   callerContext: { bindingName: string; durableObjectId: string }
   requestId: string
-  values: NonEmptyArray<any>
+  storeId: string
+  values: ReadonlyArray.NonEmptyReadonlyArray<any>
 }) {
   // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- CF worker env bindings are typed as Record<string, any>; narrowing to known DO namespace
   const clientDoNamespace = env[callerContext.bindingName] as
@@ -187,8 +234,13 @@ export const emitStreamResponse = Effect.fn('do-rpc/emitStreamResponse')(functio
   const clientDo = clientDoNamespace.get(clientDoNamespace.idFromString(callerContext.durableObjectId))
 
   const res: RpcMessage.ResponseChunkEncoded = { _tag: 'Chunk', requestId, values }
+  const parser = RpcSerialization.msgPack.makeUnsafe()
+  // Native Cloudflare RPC rejects schema values with custom prototypes. Keep the callback
+  // boundary clone-safe by sending the already-encoded Effect RPC message as bytes.
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- msgPack parser.encode returns unknown; the encoded result is a byte payload
+  const serializedRes = parser.encode(res) as Uint8Array<ArrayBuffer>
 
-  yield* Effect.tryPromise(() => clientDo.syncUpdateRpc(res))
+  yield* Effect.tryPromise(() => clientDo.syncUpdateRpc(serializedRes, storeId))
 })
 
 /**
@@ -198,32 +250,40 @@ export const emitStreamResponse = Effect.fn('do-rpc/emitStreamResponse')(functio
 const createStreamingResponse = <Rpcs extends Rpc.Any, LE>(
   rpc: Rpc.AnyWithProps,
   entry: Rpc.Handler<Rpcs['_tag']>,
-  request: any,
-  parser: ReturnType<typeof RpcSerialization.msgPack.unsafeMake>,
+  requestId: RpcMessage.RequestId,
+  payload: unknown,
+  parser: ReturnType<typeof RpcSerialization.msgPack.makeUnsafe>,
   layer: Layer.Layer<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>, LE>,
 ): Effect.Effect<CfTypes.ReadableStream, never, Scope.Scope> =>
   Effect.gen(function* () {
     // Execute the handler to get the stream
-    const handlerResult = entry.handler(request.payload, {
-      clientId: 0, // TODO: add proper clientId if needed
+    const handlerResult = entry.handler(payload, {
+      client: new Rpc.ServerClient(0), // TODO: add proper clientId if needed
+      requestId,
       headers: Headers.fromInput({
-        'x-rpc-request-id': request.id.toString(),
+        'x-rpc-request-id': requestId.toString(),
       }),
+      rpc,
     })
+    const effectOrStream = Rpc.isWrapper(handlerResult) === true ? handlerResult.value : handlerResult
 
-    // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- `Rpc.Handler.handler` returns `Effect<any, any>` due to dynamic dispatch; orDie converts the error to a defect handled by the downstream catchAllCause
     const stream: Stream.Stream<any, any> =
-      Effect.isEffect(handlerResult) === true ? yield* Effect.orDie(handlerResult) : handlerResult
+      // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- `Rpc.Handler.handler` returns `Effect<any, any>` due to dynamic dispatch; orDie converts the error to a defect handled by the downstream catchCause
+      Effect.isEffect(effectOrStream) === true ? yield* Effect.orDie(effectOrStream) : effectOrStream
 
     // Get the stream schemas for proper chunk-level encoding
     // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Rpc.Handler doesn't expose successSchema publicly; see https://github.com/Effect-TS/effect/issues/6064
-    const streamSchemas = RpcSchema.getStreamSchemas((rpc as any).successSchema.ast)
-    const chunkEncoder =
+    const streamSchemas =
+      RpcSchema.isStreamSchema(rpc.successSchema) === true
+        ? Option.some({
+            success: rpc.successSchema.success,
+            error: rpc.successSchema.error,
+          })
+        : Option.none()
+    const arrayEncoder =
       Option.isSome(streamSchemas) === true
-        ? // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- stream schema success type is inferred as unknown; cast needed for encodeUnknown
-          Schema.encodeUnknown(Schema.Array(streamSchemas.value.success as Schema.Schema<any>))
-        : // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Schema.Any needs explicit cast for Schema.Array compatibility
-          Schema.encodeUnknown(Schema.Array(Schema.Any as Schema.Schema<any>))
+        ? Schema.encodeUnknownEffect(Schema.toCodecJson(Schema.Array(streamSchemas.value.success)))
+        : Schema.encodeUnknownEffect(Schema.toCodecJson(Schema.Array(Schema.Any)))
 
     // Convert stream to ReadableStream
     const readableStream = new ReadableStream({
@@ -231,17 +291,16 @@ const createStreamingResponse = <Rpcs extends Rpc.Any, LE>(
         // Run the stream and send chunks + final exit
         const runStream = Effect.gen(function* () {
           // Process stream chunks - let chunk encoder handle Effect objects properly
-          yield* Stream.runForEachChunk(stream, (chunk) =>
+          yield* Stream.runForEachArray(stream, (array) =>
             Effect.gen(function* () {
-              const chunkArray = Chunk.toReadonlyArray(chunk)
-              if (chunkArray.length === 0) return
+              if (array.length === 0) return
 
               // Encode the chunk using the proper chunk encoder (like official RPC)
-              const encodedValues = yield* chunkEncoder(chunkArray)
+              const encodedValues = yield* arrayEncoder(array)
 
               const chunkMessage = {
                 _tag: 'Chunk' as const,
-                requestId: request.id,
+                requestId,
                 values: encodedValues,
               }
 
@@ -254,12 +313,12 @@ const createStreamingResponse = <Rpcs extends Rpc.Any, LE>(
           // Send final exit message with proper schema encoding
           const rawExit = Exit.void
           // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Rpc.exitSchema requires AnyWithProps; type narrowing already done above
-          const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Schema<any>
-          const encodedExit = yield* Schema.encodeUnknown(exitSchema)(rawExit)
+          const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Top
+          const encodedExit = yield* Schema.encodeUnknownEffect(erasedJsonCodec(exitSchema))(rawExit)
 
           const exitMessage = {
             _tag: 'Exit' as const,
-            requestId: request.id,
+            requestId,
             exit: encodedExit,
           }
 
@@ -268,17 +327,17 @@ const createStreamingResponse = <Rpcs extends Rpc.Any, LE>(
           controller.enqueue(exitSerialized)
           controller.close()
         }).pipe(
-          Effect.catchAllCause((cause) =>
+          Effect.catchCause((cause) =>
             Effect.gen(function* () {
               // Send error exit with proper schema encoding
               const rawExit = Exit.failCause(cause)
               // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Rpc.exitSchema requires AnyWithProps; type narrowing already done above
-              const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Schema<any>
-              const encodedExit = yield* Schema.encodeUnknown(exitSchema)(rawExit)
+              const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Top
+              const encodedExit = yield* Schema.encodeUnknownEffect(erasedJsonCodec(exitSchema))(rawExit)
 
               const exitMessage = {
                 _tag: 'Exit' as const,
-                requestId: request.id,
+                requestId,
                 exit: encodedExit,
               }
 
@@ -291,7 +350,13 @@ const createStreamingResponse = <Rpcs extends Rpc.Any, LE>(
         )
 
         // Run the stream processing
-        runStream.pipe(Effect.provide(layer), Effect.scoped, Effect.tapCauseLogPretty, Effect.runPromise)
+        runStream.pipe(
+          Effect.provide(layer),
+          Effect.scoped,
+          Effect.tapCauseLogPretty,
+          (_) => _ as Effect.Effect<void>,
+          Effect.runPromise,
+        )
       },
       // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- bridging standard Web API ReadableStream to Cloudflare Worker ReadableStream type
     }) as any as CfTypes.ReadableStream

package/src/do-rpc/test-fixtures/rpc-schema.ts

@@ -10,8 +10,8 @@ export class TestRpcs extends RpcGroup.make(
     success: Schema.Struct({ echo: Schema.String }),
   }),
   Rpc.make('Add', {
-    payload: Schema.Struct({ a: Schema.Number, b: Schema.Number }),
-    success: Schema.Struct({ result: Schema.Number }),
+    payload: Schema.Struct({ a: Schema.Finite, b: Schema.Finite }),
+    success: Schema.Struct({ result: Schema.Finite }),
   }),
   Rpc.make('Defect', {
     payload: Schema.Struct({ message: Schema.String }),
@@ -25,34 +25,34 @@ export class TestRpcs extends RpcGroup.make(
   Rpc.make('Stream', {
     payload: Schema.Struct({}),
     success: Schema.Struct({
-      maybeNumber: Schema.Option(Schema.Number),
+      maybeNumber: Schema.Option(Schema.Finite),
     }),
     stream: true,
   }),
   Rpc.make('StreamError', {
-    payload: Schema.Struct({ count: Schema.Number, errorAfter: Schema.Number }),
-    success: Schema.Number,
+    payload: Schema.Struct({ count: Schema.Finite, errorAfter: Schema.Finite }),
+    success: Schema.Finite,
     error: Schema.String,
     stream: true,
   }),
   Rpc.make('StreamDefect', {
-    payload: Schema.Struct({ count: Schema.Number, defectAfter: Schema.Number }),
-    success: Schema.Number,
+    payload: Schema.Struct({ count: Schema.Finite, defectAfter: Schema.Finite }),
+    success: Schema.Finite,
     stream: true,
   }),
   Rpc.make('StreamInterruptible', {
-    payload: Schema.Struct({ delay: Schema.Number, interruptAfterCount: Schema.Number }),
-    success: Schema.Number,
+    payload: Schema.Struct({ delay: Schema.Finite, interruptAfterCount: Schema.Finite }),
+    success: Schema.Finite,
     stream: true,
   }),
   Rpc.make('StreamBugScenarioDoServer', {
     payload: Schema.Struct({}),
-    success: Schema.Number,
+    success: Schema.Finite,
     stream: true,
   }),
   Rpc.make('StreamBugScenarioDoClient', {
     payload: Schema.Struct({}),
-    success: Schema.Number,
+    success: Schema.Finite,
   }),
 ) {}
 export type TestRpcsI = RpcGroup.Rpcs<typeof TestRpcs>

package/src/do-rpc/test-fixtures/worker.ts

@@ -5,7 +5,7 @@ import { DurableObject } from 'cloudflare:workers'
 import { layerProtocolDurableObject, toDurableObjectHandler } from '@livestore/common-cf'
 import {
   Effect,
-  HttpApp,
+  HttpEffect,
   Layer,
   Option,
   RpcClient,
@@ -76,7 +76,7 @@ export default {
       const url = new URL(request.url)
 
       // Handle HTTP RPC endpoint
-      if (url.pathname === '/rpc') {
+      if (url.pathname === '/rpc/') {
         // Get the test server DO instance
         const doId = env.TEST_RPC_DO.idFromName('test-server')
         const serverDO = env.TEST_RPC_DO.get(doId)
@@ -106,26 +106,23 @@ export default {
               doRpcClient.StreamBugScenarioDoServer(msg).pipe(
                 Stream.tap(() => Effect.fail('doh')),
                 // observed behaviour: `log1` is still logged
-                Stream.tapErrorCause((cause) => Effect.log('log1', cause)),
+                Stream.tapCause((cause) => Effect.log('log1', cause)),
                 Stream.mapError((cause) => cause.toString()),
                 // observed behaviour: after this error mapping `log2` is never logged
-                Stream.tapErrorCause((cause) => Effect.log('log2', cause)),
+                Stream.tapCause((cause) => Effect.log('log2', cause)),
                 Stream.tapLogWithLabel('stream'),
                 Stream.runCount,
                 Effect.orDie,
                 // observed behaviour: `log3` is also never logged
-                Effect.tapErrorCause((cause) => Effect.log('log3', cause)),
+                Effect.tapCause((cause) => Effect.log('log3', cause)),
               ),
-          }).pipe(
-            Layer.provideMerge(RpcServer.layerProtocolHttp({ path: '/rpc' })),
-            Layer.provideMerge(RpcSerialization.layerJson),
-          )
+          }).pipe(Layer.provideMerge(RpcSerialization.layerJson))
 
-          // Create the HTTP RPC app
-          const httpApp = RpcServer.toHttpApp(TestRpcs).pipe(Effect.provide(handlersLayer))
+          // Create the HTTP RPC effect
+          const httpEffect = yield* RpcServer.toHttpEffect(TestRpcs).pipe(Effect.provide(handlersLayer))
 
           // Run the app and convert to web handler
-          const webHandler = yield* httpApp.pipe(Effect.map(HttpApp.toWebHandler))
+          const webHandler = HttpEffect.toWebHandler(httpEffect)
 
           return yield* Effect.promise(() => webHandler(request))
         }).pipe(

package/src/ws-rpc/test-fixtures/rpc-schema.ts

@@ -10,8 +10,8 @@ export class TestRpcs extends RpcGroup.make(
     success: Schema.Struct({ echo: Schema.String }),
   }),
   Rpc.make('Add', {
-    payload: Schema.Struct({ a: Schema.Number, b: Schema.Number }),
-    success: Schema.Struct({ result: Schema.Number }),
+    payload: Schema.Struct({ a: Schema.Finite, b: Schema.Finite }),
+    success: Schema.Struct({ result: Schema.Finite }),
   }),
   Rpc.make('Defect', {
     payload: Schema.Struct({ message: Schema.String }),
@@ -25,24 +25,24 @@ export class TestRpcs extends RpcGroup.make(
   Rpc.make('Stream', {
     payload: Schema.Struct({}),
     success: Schema.Struct({
-      maybeNumber: Schema.Option(Schema.Number),
+      maybeNumber: Schema.Option(Schema.Finite),
     }),
     stream: true,
   }),
   Rpc.make('StreamError', {
-    payload: Schema.Struct({ count: Schema.Number, errorAfter: Schema.Number }),
-    success: Schema.Number,
+    payload: Schema.Struct({ count: Schema.Finite, errorAfter: Schema.Finite }),
+    success: Schema.Finite,
     error: Schema.String,
     stream: true,
   }),
   Rpc.make('StreamDefect', {
-    payload: Schema.Struct({ count: Schema.Number, defectAfter: Schema.Number }),
-    success: Schema.Number,
+    payload: Schema.Struct({ count: Schema.Finite, defectAfter: Schema.Finite }),
+    success: Schema.Finite,
     stream: true,
   }),
   Rpc.make('StreamInterruptible', {
-    payload: Schema.Struct({ delay: Schema.Number, interruptAfterCount: Schema.Number }),
-    success: Schema.Number,
+    payload: Schema.Struct({ delay: Schema.Finite, interruptAfterCount: Schema.Finite }),
+    success: Schema.Finite,
     stream: true,
   }),
 ) {}