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

package/src/do-rpc/server.ts

@@ -1,26 +1,56 @@
 import {
-  Chunk,
   Effect,
   Exit,
+  Fiber,
   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'
 
+const isEncodedRpcMessage = Schema.is(RpcMessage.EncodedSchema)
+
+const isRequestEncoded = (message: unknown): message is RpcMessage.RequestEncoded =>
+  isEncodedRpcMessage(message) === true && message._tag === 'Request'
+
+const erasedCodec = (codecFor: RpcSerialization.CodecFor, schema: Schema.Top) =>
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- erased RPC data schemas require no codec services
+  codecFor(schema as Schema.Codec<unknown, unknown, never, never>)
+
+const schemaBinarySerialization = RpcSerialization.RpcSerialization.pipe(
+  Effect.provide(RpcSerialization.layerSchemaBinary()),
+)
+
+const encodeBytes = (parser: RpcSerialization.Parser, value: unknown): Uint8Array<ArrayBuffer> => {
+  const encoded = parser.encode(value)
+  if (encoded instanceof Uint8Array === false) {
+    throw new TypeError('SchemaBinary RPC serialization did not produce bytes')
+  }
+  if (encoded.buffer instanceof ArrayBuffer === false) {
+    throw new TypeError('SchemaBinary RPC serialization produced shared bytes')
+  }
+  return new Uint8Array(encoded.buffer, encoded.byteOffset, encoded.byteLength)
+}
+
 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,22 +71,10 @@ export const toDurableObjectHandler =
   ) => Effect.Effect<Uint8Array<ArrayBuffer> | CfTypes.ReadableStream>) =>
   (serializedPayload) =>
     Effect.gen(function* () {
-      const parser = RpcSerialization.msgPack.unsafeMake()
-
-      // 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>[]
-      if (Array.isArray(decoded) === true && decoded.length === 1 && Array.isArray(decoded[0]) === true) {
-        // Double-wrapped array [[{...}]] -> [{...}]
-        requests = decoded[0]
-      } else if (Array.isArray(decoded) === true) {
-        // Single array [{...}]
-        requests = decoded
-      } else {
-        requests = []
-      }
+      const serialization = yield* schemaBinarySerialization
+      const parser = serialization.makeUnsafe()
+
+      const requests = parser.decode(serializedPayload).filter(isRequestEncoded)
 
       // Get the context with handlers
       const context = yield* Effect.context<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
@@ -65,60 +83,90 @@ export const toDurableObjectHandler =
       const responses: any[] = []
 
       for (const request of requests) {
-        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(erasedCodec(serialization.codecFor, rpc.payloadSchema))(
+          request.payload,
+        ).pipe(Effect.provideContext(entry.context), Effect.result)
+
+        if (Result.isFailure(payloadResult) === true) {
+          // 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(erasedCodec(serialization.codecFor, 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,
+            serialization.codecFor,
+            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: Effect.Effect<unknown, unknown> | Stream.Stream<unknown, unknown> =
+            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(erasedCodec(serialization.codecFor, exitSchema))(rawExit)
           } else {
             // Fallback to direct exit
             encodedExit = Exit.succeed(value)
@@ -126,21 +174,23 @@ 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(erasedCodec(serialization.codecFor, exitSchema))(
+                  rawExit,
+                )
               } else {
                 // Fallback to direct exit
                 encodedExit = Exit.failCause(cause)
@@ -148,7 +198,7 @@ export const toDurableObjectHandler =
 
               return {
                 _tag: 'Exit' as const,
-                requestId: request.id,
+                requestId,
                 exit: encodedExit,
               }
             })
@@ -158,22 +208,26 @@ export const toDurableObjectHandler =
         responses.push(result)
       }
 
-      // 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)
+      return encodeBytes(parser, responses)
+    }).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,
+  schema,
+  storeId,
   values,
 }: {
   env: Record<string, any>
   callerContext: { bindingName: string; durableObjectId: string }
   requestId: string
-  values: NonEmptyArray<any>
+  storeId: string
+  schema: Schema.Top
+  values: ReadonlyArray.NonEmptyReadonlyArray<unknown>
 }) {
   // 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
@@ -186,9 +240,17 @@ 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 }
-
-  yield* Effect.tryPromise(() => clientDo.syncUpdateRpc(res))
+  const serialization = yield* schemaBinarySerialization
+  const parser = serialization.makeUnsafe()
+  const encodedValues = yield* Schema.encodeUnknownEffect(
+    erasedCodec(serialization.codecFor, Schema.NonEmptyArray(schema)),
+  )(values)
+  const res = { _tag: 'Chunk', requestId, values: encodedValues }
+  // 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.
+  const serializedRes = encodeBytes(parser, res)
+
+  yield* Effect.tryPromise(() => clientDo.syncUpdateRpc(serializedRes, storeId))
 })
 
 /**
@@ -198,100 +260,120 @@ 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: RpcSerialization.Parser,
+  codecFor: RpcSerialization.CodecFor,
   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: Effect.Effect<unknown, unknown> | Stream.Stream<unknown, unknown> =
+      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 -- dynamically dispatched handlers have an unknown error; orDie converts it to a defect handled by the downstream catchCause
+    const result = Effect.isEffect(effectOrStream) === true ? yield* Effect.orDie(effectOrStream) : effectOrStream
+    if (Stream.isStream(result) === false) {
+      return yield* Effect.die(`Streaming RPC ${rpc._tag} did not produce a Stream`)
+    }
+    const stream = result
 
     // 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(erasedCodec(codecFor, Schema.NonEmptyArray(streamSchemas.value.success)))
+        : Schema.encodeUnknownEffect(erasedCodec(codecFor, Schema.NonEmptyArray(Schema.Any)))
 
     // Convert stream to ReadableStream
+    let producer: Fiber.Fiber<void> | undefined
+    let cancelled = false
     const readableStream = new ReadableStream({
       start(controller) {
         // 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,
               }
 
-              // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- msgPack parser.encode returns unknown; cast to expected wire format
-              const serialized = parser.encode([chunkMessage]) as Uint8Array<ArrayBuffer>
-              controller.enqueue(serialized)
+              controller.enqueue(encodeBytes(parser, [chunkMessage]))
             }),
           )
 
           // 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(erasedCodec(codecFor, exitSchema))(rawExit)
 
           const exitMessage = {
             _tag: 'Exit' as const,
-            requestId: request.id,
+            requestId,
             exit: encodedExit,
           }
 
-          // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- msgPack parser.encode returns unknown; cast to expected wire format
-          const exitSerialized = parser.encode([exitMessage]) as Uint8Array<ArrayBuffer>
-          controller.enqueue(exitSerialized)
+          controller.enqueue(encodeBytes(parser, [exitMessage]))
           controller.close()
         }).pipe(
-          Effect.catchAllCause((cause) =>
+          Effect.catchCause((cause) =>
             Effect.gen(function* () {
+              if (cancelled === true) return
               // 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(erasedCodec(codecFor, exitSchema))(rawExit)
 
               const exitMessage = {
                 _tag: 'Exit' as const,
-                requestId: request.id,
+                requestId,
                 exit: encodedExit,
               }
 
-              // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- msgPack parser.encode returns unknown; cast to expected wire format
-              const exitSerialized = parser.encode([exitMessage]) as Uint8Array<ArrayBuffer>
-              controller.enqueue(exitSerialized)
+              controller.enqueue(encodeBytes(parser, [exitMessage]))
               controller.close()
             }),
           ),
         )
 
         // Run the stream processing
-        runStream.pipe(Effect.provide(layer), Effect.scoped, Effect.tapCauseLogPretty, Effect.runPromise)
+        producer = runStream.pipe(
+          Effect.provide(layer),
+          Effect.scoped,
+          Effect.tapCauseLogPretty,
+          (_) => _ as Effect.Effect<void>,
+          Effect.runFork,
+        )
+      },
+      cancel() {
+        cancelled = true
+        // @effect-diagnostics-next-line runEffectInsideEffect:off -- native stream callback runs outside Effect; interruption needs no services
+        return producer === undefined ? undefined : Effect.runPromise(Fiber.interrupt(producer))
       },
       // 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,
   }),
 ) {}