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

package/src/do-rpc/server.ts

@@ -1,25 +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>
 }
 
 /**
@@ -40,17 +58,17 @@ 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>[]
-      if (Array.isArray(decoded) && decoded.length === 1 && Array.isArray(decoded[0])) {
+      let requests: RpcMessage.FromClientEncoded[]
+      if (Array.isArray(decoded) === true && decoded.length === 1 && Array.isArray(decoded[0]) === true) {
         // Double-wrapped array [[{...}]] -> [{...}]
         requests = decoded[0]
-      } else if (Array.isArray(decoded)) {
+      } else if (Array.isArray(decoded) === true) {
         // Single array [{...}]
         requests = decoded
       } else {
@@ -67,52 +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
-        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 || !entry) {
+        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
-        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 && requests.length === 1) {
-          return yield* createStreamingResponse(rpc, entry, request, parser, options.layer)
+        if (isStream === true && requests.length === 1) {
+          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)) {
-            value = yield* handlerResult
+          if (Effect.isEffect(effectOrStream) === true) {
+            // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- `Rpc.Handler.handler` returns `Effect<any, any>` due to dynamic dispatch
+            value = yield* effectOrStream
           } else {
-            value = handlerResult
+            value = effectOrStream
           }
 
           // Get the exit schema for this RPC
-          const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Schema<any>
+          // 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
 
           let encodedExit: any
-          if (exitSchema) {
+          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)
@@ -120,20 +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
-            const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Schema<any>
+            // 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
 
             return Effect.gen(function* () {
               let encodedExit: any
-              if (exitSchema) {
+              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)
@@ -141,7 +191,7 @@ export const toDurableObjectHandler =
 
               return {
                 _tag: 'Exit' as const,
-                requestId: request.id,
+                requestId,
                 exit: encodedExit,
               }
             })
@@ -151,37 +201,47 @@ 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)
+    }).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 = ({
+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>
-}) =>
-  Effect.gen(function* () {
-    const clientDoNamespace = env[callerContext.bindingName] as
-      | CfTypes.DurableObjectNamespace<ClientDoWithRpcCallback>
-      | undefined
-
-    if (clientDoNamespace === undefined) {
-      throw new Error(`Client DO namespace not found: ${callerContext.bindingName}`)
-    }
-
-    const clientDo = clientDoNamespace.get(clientDoNamespace.idFromString(callerContext.durableObjectId))
-
-    const res: RpcMessage.ResponseChunkEncoded = { _tag: 'Chunk', requestId, values }
-
-    yield* Effect.tryPromise(() => clientDo.syncUpdateRpc(res))
-  }).pipe(Effect.withSpan('do-rpc/emitStreamResponse'))
+  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
+    | CfTypes.DurableObjectNamespace<ClientDoWithRpcCallback>
+    | undefined
+
+  if (clientDoNamespace === undefined) {
+    throw new Error(`Client DO namespace not found: ${callerContext.bindingName}`)
+  }
+
+  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(serializedRes, storeId))
+})
 
 /**
  * Creates a ReadableStream response for streaming RPCs.
@@ -190,33 +250,40 @@ export const emitStreamResponse = ({
 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, any, Scope.Scope> =>
+): 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
 
-    let stream: Stream.Stream<any, any, never>
-    if (Effect.isEffect(handlerResult)) {
-      // If handler returns Effect<Stream>, we need to run it to get the stream
-      stream = yield* handlerResult
-    } else {
-      // Direct stream
-      stream = handlerResult
-    }
+    const stream: Stream.Stream<any, any> =
+      // @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
-    const streamSchemas = RpcSchema.getStreamSchemas((rpc as any).successSchema.ast)
-    const chunkEncoder = Option.isSome(streamSchemas)
-      ? Schema.encodeUnknown(Schema.Array(streamSchemas.value.success))
-      : Schema.encodeUnknown(Schema.Array(Schema.Any))
+    // 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.isStreamSchema(rpc.successSchema) === true
+        ? Option.some({
+            success: rpc.successSchema.success,
+            error: rpc.successSchema.error,
+          })
+        : Option.none()
+    const arrayEncoder =
+      Option.isSome(streamSchemas) === true
+        ? 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({
@@ -224,20 +291,20 @@ 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,
               }
 
+              // 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)
             }),
@@ -245,32 +312,36 @@ const createStreamingResponse = <Rpcs extends Rpc.Any, LE>(
 
           // Send final exit message with proper schema encoding
           const rawExit = Exit.void
-          const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Schema<any>
-          const encodedExit = yield* Schema.encodeUnknown(exitSchema)(rawExit)
+          // 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 encodedExit = yield* Schema.encodeUnknownEffect(erasedJsonCodec(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.close()
         }).pipe(
-          Effect.catchAllCause((cause) =>
+          Effect.catchCause((cause) =>
             Effect.gen(function* () {
               // Send error exit with proper schema encoding
               const rawExit = Exit.failCause(cause)
-              const exitSchema = Rpc.exitSchema(rpc as any) as Schema.Schema<any>
-              const encodedExit = yield* Schema.encodeUnknown(exitSchema)(rawExit)
+              // 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 encodedExit = yield* Schema.encodeUnknownEffect(erasedJsonCodec(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.close()
@@ -279,9 +350,15 @@ const createStreamingResponse = <Rpcs extends Rpc.Any, LE>(
         )
 
         // Run the stream processing
-        // @ts-expect-error - Complex context requirements but functionality works correctly
-        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
 
     // yield* Effect.addFinalizer(() => Effect.promise(() => readableStream.cancel()))

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

@@ -1,10 +1,11 @@
 /// <reference types="@cloudflare/workers-types" />
 
 import { DurableObject } from 'cloudflare:workers'
+
 import { layerProtocolDurableObject, toDurableObjectHandler } from '@livestore/common-cf'
 import {
   Effect,
-  HttpApp,
+  HttpEffect,
   Layer,
   Option,
   RpcClient,
@@ -13,6 +14,7 @@ import {
   Schedule,
   Stream,
 } from '@livestore/utils/effect'
+
 import { TestRpcs } from './rpc-schema.ts'
 
 export interface Env {
@@ -20,7 +22,7 @@ export interface Env {
 }
 
 export class TestRpcDurableObject extends DurableObject {
-  __DURABLE_OBJECT_BRAND = 'TestRpcDurableObject' as never
+  override __DURABLE_OBJECT_BRAND = 'TestRpcDurableObject' as never
 
   async rpc(payload: unknown): Promise<unknown> {
     const TestRpcsLive = TestRpcs.toLayer({
@@ -74,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)
@@ -104,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(
@@ -139,7 +138,7 @@ export default {
         headers: { 'Content-Type': 'text/plain' },
       })
     } catch (error) {
-      return new Response(`Error: ${error}`, { status: 500 })
+      return new Response(`Error: ${String(error)}`, { status: 500 })
     }
   },
 }

package/src/ws-rpc/README.md

@@ -19,4 +19,4 @@ This module provides a Effect RPC implementation for WebSocket connections hoste
 
 ```ts
 // See test-fixtures/worker.ts for an example
-```
+```

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,
   }),
 ) {}

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

@@ -1,7 +1,9 @@
 /// <reference types="@cloudflare/workers-types" />
 
 import { DurableObject } from 'cloudflare:workers'
+
 import { Effect, Layer, Option, RpcServer, Schedule, Stream } from '@livestore/utils/effect'
+
 import type * as CfTypes from '../../cf-types.ts'
 import { setupDurableObjectWebSocketRpc } from '../ws-rpc-server.ts'
 import { TestRpcs } from './rpc-schema.ts'
@@ -11,7 +13,7 @@ export interface Env {
 }
 
 export class TestRpcDurableObject extends DurableObject<Env, unknown> {
-  __DURABLE_OBJECT_BRAND = 'TestRpcDurableObject' as never
+  override __DURABLE_OBJECT_BRAND = 'TestRpcDurableObject' as never
 
   constructor(state: DurableObjectState, env: Env) {
     super(state, env)
@@ -59,7 +61,7 @@ export class TestRpcDurableObject extends DurableObject<Env, unknown> {
     })
   }
 
-  async fetch(request: Request): Promise<Response> {
+  override async fetch(request: Request): Promise<Response> {
     const upgradeHeader = request.headers.get('Upgrade')
     if (upgradeHeader === undefined || upgradeHeader !== 'websocket') {
       return new Response('Durable Object expected Upgrade: websocket', { status: 426 })
@@ -81,7 +83,7 @@ export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     try {
       const upgradeHeader = request.headers.get('Upgrade')
-      if (!upgradeHeader || upgradeHeader !== 'websocket') {
+      if (upgradeHeader == null || upgradeHeader !== 'websocket') {
         return new Response('Durable Object expected Upgrade: websocket', { status: 426 })
       }
 
@@ -89,7 +91,7 @@ export default {
 
       return serverDO.fetch(request)
     } catch (error) {
-      return new Response(`Error: ${error}`, { status: 500 })
+      return new Response(`Error: ${String(error)}`, { status: 500 })
     }
   },
 }