effect 4.0.0-beta.5 → 4.0.0-beta.51

package/src/unstable/rpc/RpcSerialization.ts

@@ -2,17 +2,17 @@
  * @since 4.0.0
  */
 import * as Msgpackr from "msgpackr"
+import * as Context from "../../Context.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import { hasProperty } from "../../Predicate.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as RpcMessage from "./RpcMessage.ts"
 
 /**
  * @since 4.0.0
  * @category serialization
  */
-export class RpcSerialization extends ServiceMap.Service<RpcSerialization, {
+export class RpcSerialization extends Context.Service<RpcSerialization, {
   makeUnsafe(): Parser
   readonly contentType: string
   readonly includesFraming: boolean
@@ -37,7 +37,10 @@ export const json: RpcSerialization["Service"] = RpcSerialization.of({
   makeUnsafe: () => {
     const decoder = new TextDecoder()
     return {
-      decode: (bytes) => [JSON.parse(typeof bytes === "string" ? bytes : decoder.decode(bytes))],
+      decode: (bytes) => {
+        const decoded = JSON.parse(typeof bytes === "string" ? bytes : decoder.decode(bytes))
+        return Array.isArray(decoded) ? decoded : [decoded]
+      },
       encode: (response) => JSON.stringify(response)
     }
   }
@@ -107,11 +110,7 @@ export const jsonRpc = (options?: {
           return decodeJsonRpcRaw(decoded, batches)
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            if (response.length === 0) return undefined
-            return JSON.stringify(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && JSON.stringify(encoded)
         }
       }
@@ -146,10 +145,7 @@ export const ndJsonRpc = (options?: {
           return messages
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            return parser.encode(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && parser.encode(encoded)
         }
       })
@@ -171,6 +167,7 @@ function decodeJsonRpcRaw(
     const messages: Array<RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded> = []
     for (let i = 0; i < decoded.length; i++) {
       const message = decodeJsonRpcMessage(decoded[i])
+      messages.push(message)
       if (message._tag === "Request") {
         batch.size++
         batches.set(message.id, batch)
@@ -178,12 +175,12 @@ function decodeJsonRpcRaw(
     }
     return messages
   }
-  return Array.isArray(decoded) ? decoded.map(decodeJsonRpcMessage) : [decodeJsonRpcMessage(decoded)]
+  return [decodeJsonRpcMessage(decoded)]
 }
 
 function decodeJsonRpcMessage(decoded: JsonRpcMessage): RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded {
   if ("method" in decoded) {
-    if (!decoded.id && decoded.method.startsWith("@effect/rpc/")) {
+    if (Predicate.isNullish(decoded.id) && decoded.method.startsWith("@effect/rpc/")) {
       const tag = decoded.method.slice("@effect/rpc/".length) as
         | RpcMessage.FromServerEncoded["_tag"]
         | Exclude<RpcMessage.FromClientEncoded["_tag"], "Request">
@@ -197,7 +194,7 @@ function decodeJsonRpcMessage(decoded: JsonRpcMessage): RpcMessage.FromClientEnc
     }
     return {
       _tag: "Request",
-      id: decoded.id ? String(decoded.id) : "",
+      id: Predicate.isNotNullish(decoded.id) ? String(decoded.id) : "",
       tag: decoded.method,
       payload: decoded.params ?? null,
       headers: decoded.headers ?? [],
@@ -263,6 +260,47 @@ function encodeJsonRpcRaw(
   return encodeJsonRpcMessage(response)
 }
 
+function encodeJsonRpcResponse(
+  response:
+    | RpcMessage.FromServerEncoded
+    | RpcMessage.FromClientEncoded
+    | Array<RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded>,
+  batches: Map<string, {
+    readonly size: number
+    readonly responses: Map<string, RpcMessage.FromServerEncoded>
+  }>
+) {
+  if (Array.isArray(response) === false) {
+    return encodeJsonRpcRaw(response, batches)
+  }
+  if (response.length === 0) {
+    return undefined
+  }
+  const encoded: Array<JsonRpcMessage | Array<JsonRpcMessage>> = []
+  for (let i = 0; i < response.length; i++) {
+    const current = encodeJsonRpcRaw(response[i], batches)
+    if (current !== undefined) {
+      encoded.push(current)
+    }
+  }
+  if (encoded.length === 0) {
+    return undefined
+  }
+  if (encoded.length === 1) {
+    return encoded[0]
+  }
+  const messages: Array<JsonRpcMessage> = []
+  for (let i = 0; i < encoded.length; i++) {
+    const current = encoded[i]
+    if (Array.isArray(current)) {
+      messages.push(...current)
+    } else {
+      messages.push(current)
+    }
+  }
+  return messages
+}
+
 function encodeJsonRpcMessage(response: RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded): JsonRpcMessage {
   switch (response._tag) {
     case "Request":
@@ -270,7 +308,7 @@ function encodeJsonRpcMessage(response: RpcMessage.FromServerEncoded | RpcMessag
         jsonrpc: "2.0",
         method: response.tag,
         params: response.payload,
-        id: response.id && Number(response.id),
+        id: response.id !== "" ? Number(response.id) : "",
         headers: response.headers,
         traceId: response.traceId,
         spanId: response.spanId,
@@ -297,14 +335,14 @@ function encodeJsonRpcMessage(response: RpcMessage.FromServerEncoded | RpcMessag
       if (response.exit._tag === "Success") {
         return {
           jsonrpc: "2.0",
-          id: response.requestId ? Number(response.requestId) : undefined,
+          id: response.requestId !== "" ? Number(response.requestId) : undefined,
           result: response.exit.value
         } as any
       }
       const error = response.exit.cause.find((failure) => failure._tag === "Fail")
       return {
         jsonrpc: "2.0",
-        id: response.requestId ? Number(response.requestId) : undefined,
+        id: response.requestId !== "" ? Number(response.requestId) : undefined,
         error: response.exit._tag === "Failure" ?
           {
             _tag: "Cause",
@@ -362,47 +400,52 @@ interface JsonRpcResponse {
 type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse
 
 /**
+ * Create a MessagePack serialization with custom msgpackr options.
+ *
  * @since 4.0.0
  * @category serialization
  */
-export const msgPack: RpcSerialization["Service"] = RpcSerialization.of({
-  contentType: "application/msgpack",
-  includesFraming: true,
-  makeUnsafe: () => {
-    const unpackr = new Msgpackr.Unpackr({
-      useRecords: true
-    })
-    const packr = new Msgpackr.Packr({
-      useRecords: true
-    })
-    const encoder = new TextEncoder()
-    let incomplete: Uint8Array | undefined = undefined
-    return {
-      decode: (bytes) => {
-        let buf = typeof bytes === "string" ? encoder.encode(bytes) : bytes
-        if (incomplete !== undefined) {
-          const prev = buf
-          bytes = new Uint8Array(incomplete.length + buf.length)
-          bytes.set(incomplete)
-          bytes.set(prev, incomplete.length)
-          buf = bytes
-          incomplete = undefined
-        }
-        try {
-          return unpackr.unpackMultiple(buf)
-        } catch (error_) {
-          const error = error_ as any
-          if (error.incomplete) {
-            incomplete = buf.subarray(error.lastPosition)
-            return error.values ?? []
+export const makeMsgPack = (options?: Msgpackr.Options | undefined): RpcSerialization["Service"] =>
+  RpcSerialization.of({
+    contentType: "application/msgpack",
+    includesFraming: true,
+    makeUnsafe: () => {
+      const unpackr = new Msgpackr.Unpackr(options)
+      const packr = new Msgpackr.Packr(options)
+      const encoder = new TextEncoder()
+      let incomplete: Uint8Array | undefined = undefined
+      return {
+        decode(bytes) {
+          let buf = typeof bytes === "string" ? encoder.encode(bytes) : bytes
+          if (incomplete !== undefined) {
+            const prev = buf
+            bytes = new Uint8Array(incomplete.length + buf.length)
+            bytes.set(incomplete)
+            bytes.set(prev, incomplete.length)
+            buf = bytes
+            incomplete = undefined
           }
-          return []
-        }
-      },
-      encode: (response) => packr.pack(response)
+          try {
+            return unpackr.unpackMultiple(buf)
+          } catch (error_) {
+            const error = error_ as any
+            if (error.incomplete) {
+              incomplete = buf.subarray(error.lastPosition)
+              return error.values ?? []
+            }
+            throw error_
+          }
+        },
+        encode: (response) => packr.pack(response)
+      }
     }
-  }
-})
+  })
+
+/**
+ * @since 4.0.0
+ * @category serialization
+ */
+export const msgPack: RpcSerialization["Service"] = makeMsgPack({ useRecords: true })
 
 /**
  * A rpc serialization layer that uses JSON for serialization.

package/src/unstable/rpc/RpcServer.ts

@@ -3,21 +3,23 @@
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant, constTrue, constVoid, identity } from "../../Function.ts"
+import { reportCauseUnsafe } from "../../internal/effect.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
-import type * as Option from "../../Option.ts"
+import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Pull from "../../Pull.ts"
 import * as Queue from "../../Queue.ts"
-import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import { Stdio } from "../../Stdio.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
@@ -96,23 +98,24 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const spanPrefix = options.spanPrefix ?? "RpcServer"
   const concurrency = options.concurrency ?? "unbounded"
   const disableFatalDefects = options.disableFatalDefects ?? false
-  const services = yield* Effect.services<Rpc.ToHandler<Rpcs> | Scope.Scope>()
-  const scope = ServiceMap.get(services, Scope.Scope)
+  const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Scope.Scope>()
+  const scope = Context.get(services, Scope.Scope)
   const trackFiber = Fiber.runIn(Scope.forkUnsafe(scope, "parallel"))
   const concurrencySemaphore = concurrency === "unbounded"
     ? undefined
-    : yield* Effect.makeSemaphore(concurrency)
+    : yield* Semaphore.make(concurrency)
 
   type Client = {
     readonly id: number
-    readonly latches: Map<RequestId, Effect.Latch>
+    readonly latches: Map<RequestId, Latch.Latch>
     readonly fibers: Map<RequestId, Fiber.Fiber<unknown, any>>
+    readonly serverClient: Rpc.ServerClient
     ended: boolean
   }
 
   const clients = new Map<number, Client>()
   let isShutdown = false
-  const shutdownLatch = Effect.makeLatchUnsafe(false)
+  const shutdownLatch = Latch.makeUnsafe(false)
   yield* Scope.addFinalizer(
     scope,
     Effect.withFiber((parent) => {
@@ -155,7 +158,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
             id: clientId,
             latches: new Map(),
             fibers: new Map(),
-            ended: false
+            ended: false,
+            serverClient: new Rpc.ServerClient(clientId)
           }
           clients.set(clientId, client)
         } else if (client.ended) {
@@ -172,17 +176,16 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           }
           case "Interrupt": {
             const fiber = client.fibers.get(message.requestId)
-            return fiber
-              ? Effect.forkDetach(
-                Fiber.interruptAs(fiber, fiberIdClientInterrupt),
-                { startImmediately: true }
-              )
-              : options.onFromServer({
-                _tag: "Exit",
-                clientId,
-                requestId: message.requestId,
-                exit: Exit.interrupt()
-              })
+            if (fiber) {
+              fiber.interruptUnsafe(requestFiber.id, RpcSchema.ClientAbort.annotation)
+              return Effect.void
+            }
+            return options.onFromServer({
+              _tag: "Exit",
+              clientId,
+              requestId: message.requestId,
+              exit: Exit.interrupt()
+            })
           }
           case "Eof": {
             client.ended = true
@@ -235,7 +238,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     const isStream = RpcSchema.isStreamSchema(rpc.successSchema)
     const metadata = {
       rpc,
-      clientId: client.id,
+      client: client.serverClient,
       requestId: request.id,
       headers: request.headers,
       payload: request.payload
@@ -249,32 +252,52 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     // unwrap the fork data type
     const streamOrEffect = isWrapper ? result.value : result
     const handler = isStream
-      ? (streamEffect(client, request, streamOrEffect) as Effect.Effect<any>)
-      : (streamOrEffect as Effect.Effect<any>)
+      ? (streamEffect(client, request, streamOrEffect) as Effect.Effect<{} | Deferred.Deferred<any, any>>)
+      : (streamOrEffect as Effect.Effect<{} | Deferred.Deferred<any, any>>)
 
     const withMiddleware = rpc.middlewares.size > 0
       ? applyMiddleware(services, handler, metadata)
       : handler
     let responded = false
     const scope = Scope.makeUnsafe()
+    let deferred: Deferred.Deferred<unknown, unknown> | undefined = undefined
     let effect = Effect.onExit(withMiddleware, (exit) => {
       responded = true
-      const close = Scope.closeUnsafe(scope, exit)
-      const write = exit._tag === "Failure" &&
-          !disableFatalDefects &&
-          Cause.hasDies(exit.cause) &&
-          !Cause.hasInterrupts(exit.cause)
-        ? sendDefect(client, Cause.squash(exit.cause))
-        : options.onFromServer({
+      let write: Effect.Effect<void>
+      if (exit._tag === "Success") {
+        if (Deferred.isDeferred(exit.value)) {
+          deferred = exit.value
+          write = Effect.void
+        } else {
+          write = options.onFromServer({
+            _tag: "Exit",
+            clientId: client.id,
+            requestId: request.id,
+            exit: exit as any
+          })
+        }
+      } else if (
+        !disableFatalDefects &&
+        Cause.hasDies(exit.cause) &&
+        !Cause.hasInterrupts(exit.cause)
+      ) {
+        write = sendDefect(client, Cause.squash(exit.cause))
+      } else {
+        write = options.onFromServer({
           _tag: "Exit",
           clientId: client.id,
           requestId: request.id,
-          exit
+          exit: exit as any
         })
+      }
+      const close = Scope.closeUnsafe(scope, exit)
+      if (exit._tag === "Failure") {
+        reportCauseUnsafe(Fiber.getCurrent()!, exit.cause)
+      }
       return close ? Effect.ensuring(write, close) : write
     })
     if (enableTracing) {
-      const parentSpan = requestFiber.services.mapUnsafe.get(
+      const parentSpan = requestFiber.context.mapUnsafe.get(
         Tracer.ParentSpan.key
       ) as Tracer.AnySpan | undefined
       effect = Effect.withSpan(effect, `${spanPrefix}.${request.tag}`, {
@@ -298,12 +321,12 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       })
     }
     if (!isFork && concurrencySemaphore) {
-      effect = concurrencySemaphore.withPermits(1)(effect)
+      effect = concurrencySemaphore.withPermit(effect)
     }
-    const serviceMap = new Map(entry.services.mapUnsafe)
-    serviceMap.forEach((value, key) => serviceMap.set(key, value))
-    serviceMap.set(Scope.Scope.key, scope)
-    const runFork = Effect.runForkWith(ServiceMap.makeUnsafe(serviceMap))
+    const context = new Map(entry.context.mapUnsafe)
+    requestFiber.context.mapUnsafe.forEach((value, key) => context.set(key, value))
+    context.set(Scope.Scope.key, scope)
+    const runFork = Effect.runForkWith(Context.makeUnsafe(context))
     const fiber = trackFiber(
       runFork(
         effect,
@@ -311,7 +334,20 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       )
     )
     client.fibers.set(request.id, fiber)
-    fiber.addObserver((exit) => {
+    fiber.addObserver(function onExit(exit: Exit.Exit<any, any>): void {
+      if (deferred) {
+        const fiber = trackFiber(runFork(Effect.onExit(Deferred.await(deferred), (exit) =>
+          options.onFromServer({
+            _tag: "Exit",
+            clientId: client.id,
+            requestId: request.id,
+            exit: exit as any
+          }))))
+        client.fibers.set(request.id, fiber)
+        deferred = undefined
+        fiber.addObserver(onExit)
+        return
+      }
       if (!responded && exit._tag === "Failure") {
         trackFiber(
           runFork(
@@ -342,7 +378,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   ) => {
     let latch = client.latches.get(request.id)
     if (supportsAck && !latch) {
-      latch = Effect.makeLatchUnsafe(false)
+      latch = Latch.makeUnsafe(false)
       client.latches.set(request.id, latch)
     }
     if (Effect.isEffect(stream)) {
@@ -402,18 +438,18 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
 })
 
 const applyMiddleware = <A, E, R>(
-  services: ServiceMap.ServiceMap<never>,
+  context: Context.Context<never>,
   handler: Effect.Effect<A, E, R>,
   options: {
     readonly rpc: Rpc.AnyWithProps
-    readonly clientId: number
+    readonly client: Rpc.ServerClient
     readonly requestId: RequestId
     readonly headers: Headers.Headers
-    readonly payload: A
+    readonly payload: unknown
   }
 ) => {
   for (const service of options.rpc.middlewares) {
-    const middleware = ServiceMap.getUnsafe(services, service)
+    const middleware = Context.getUnsafe(context, service)
     handler = middleware(handler as any, options) as any
   }
 
@@ -461,7 +497,7 @@ export const make: <Rpcs extends Rpc.Any>(
     supportsSpanPropagation,
     supportsTransferables
   } = yield* Protocol
-  const services = yield* Effect.services<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
+  const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
   const scope = yield* Scope.make()
 
   const server = yield* makeNoSerialization(group, {
@@ -480,7 +516,7 @@ export const make: <Rpcs extends Rpc.Any>(
             response.requestId,
             schemas.encodeDefect,
             schemas.collector,
-            Effect.provideServices(schemas.encodeChunk(response.values), schemas.services),
+            Effect.provideContext(schemas.encodeChunk(response.values), schemas.context),
             (values) => ({ _tag: "Chunk", requestId: String(response.requestId), values })
           )
         }
@@ -493,7 +529,7 @@ export const make: <Rpcs extends Rpc.Any>(
             response.requestId,
             schemas.encodeDefect,
             schemas.collector,
-            Effect.provideServices(schemas.encodeExit(response.exit), schemas.services),
+            Effect.provideContext(schemas.encodeExit(response.exit), schemas.context),
             (exit) => ({ _tag: "Exit", requestId: String(response.requestId), exit })
           )
         }
@@ -529,7 +565,7 @@ export const make: <Rpcs extends Rpc.Any>(
     ) => Effect.Effect<NonEmptyReadonlyArray<unknown>, Schema.SchemaError>
     readonly encodeExit: (u: unknown) => Effect.Effect<ResponseExitEncoded["exit"], Schema.SchemaError>
     readonly encodeDefect: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
     readonly collector?: Transferable.Collector["Service"] | undefined
   }
 
@@ -543,12 +579,12 @@ export const make: <Rpcs extends Rpc.Any>(
         decode: Schema.decodeUnknownEffect(Schema.toCodecJson(rpc.payloadSchema)) as any,
         encodeChunk: Schema.encodeUnknownEffect(
           Schema.toCodecJson(
-            Schema.Array(streamSchemas ? streamSchemas.success : Schema.Any)
+            Schema.Array(Option.isSome(streamSchemas) ? streamSchemas.value.success : Schema.Any)
           )
         ) as any,
         encodeExit: Schema.encodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any))) as any,
         encodeDefect: Schema.encodeUnknownEffect(Schema.toCodecJson(rpc.defectSchema)) as any,
-        services: entry.services
+        context: entry.context
       }
       schemasCache.set(rpc, schemas)
     }
@@ -644,7 +680,7 @@ export const make: <Rpcs extends Rpc.Any>(
         }
         const schemas = getSchemas(rpc as any)
         return Effect.matchEffect(
-          Effect.provideServices(schemas.decode(request.payload), schemas.services),
+          Effect.provideContext(schemas.decode(request.payload), schemas.context),
           {
             onFailure: (error) => sendRequestDefect(client, requestId, schemas.encodeDefect, error.issue.toString()),
             onSuccess: (payload) => {
@@ -735,6 +771,7 @@ export const layerHttp = <Rpcs extends Rpc.Any>(options: {
   readonly spanPrefix?: string | undefined
   readonly spanAttributes?: Record<string, unknown> | undefined
   readonly concurrency?: number | "unbounded" | undefined
+  readonly disableFatalDefects?: boolean | undefined
 }): Layer.Layer<
   never,
   never,
@@ -756,7 +793,7 @@ export const layerHttp = <Rpcs extends Rpc.Any>(options: {
  * @since 4.0.0
  * @category protocol
  */
-export class Protocol extends ServiceMap.Service<
+export class Protocol extends Context.Service<
   Protocol,
   {
     readonly run: (
@@ -915,8 +952,8 @@ export const makeProtocolWithHttpEffect: Effect.Effect<
     Scope.Scope | HttpServerRequest.HttpServerRequest
   > = Effect.gen(function*() {
     const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest.HttpServerRequest)
-    const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest.HttpServerRequest)
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope)
     const requestHeaders = Object.entries(request.headers)
     const data = yield* Effect.orDie<string | Uint8Array, any, never>(
       isBinary ? Effect.map(request.arrayBuffer, (buf) => new Uint8Array(buf)) : request.text
@@ -1076,6 +1113,7 @@ export const toHttpEffect: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   } | undefined
 ) => Effect.Effect<
   Effect.Effect<HttpServerResponse.HttpServerResponse, never, Scope.Scope | HttpServerRequest.HttpServerRequest>,
@@ -1091,6 +1129,7 @@ export const toHttpEffect: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   }
 ) {
   const { httpEffect, protocol } = yield* makeProtocolWithHttpEffect
@@ -1112,6 +1151,7 @@ export const toHttpEffectWebsocket: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   } | undefined
 ) => Effect.Effect<
   Effect.Effect<HttpServerResponse.HttpServerResponse, never, Scope.Scope | HttpServerRequest.HttpServerRequest>,
@@ -1127,6 +1167,7 @@ export const toHttpEffectWebsocket: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   }
 ) {
   const { httpEffect, protocol } = yield* makeProtocolWithHttpEffectWebsocket
@@ -1172,7 +1213,7 @@ export const makeProtocolStdio = Effect.gen(function*() {
     )
 
     yield* Stream.fromQueue(queue).pipe(
-      Stream.run(stdio.stdout),
+      Stream.run(stdio.stdout()),
       Effect.retry(Schedule.spaced(500)),
       Effect.forkScoped
     )
@@ -1236,7 +1277,7 @@ export const makeProtocolWorkerRunner: Effect.Effect<
     Effect.tapCause(Effect.logError),
     Effect.onExit(() =>
       Effect.sync(() => {
-        fiber.currentScheduler.scheduleTask(() => fiber.interruptUnsafe(fiber.id), 0)
+        fiber.currentDispatcher.scheduleTask(() => fiber.interruptUnsafe(fiber.id), 0)
       })
     ),
     Effect.forkScoped
@@ -1276,14 +1317,6 @@ export const layerProtocolWorkerRunner: Layer.Layer<
   WorkerRunner.WorkerRunnerPlatform
 > = Layer.effect(Protocol)(makeProtocolWorkerRunner)
 
-/**
- * Fiber id used to indicate client induced interrupts
- *
- * @since 4.0.0
- * @category Interruption
- */
-export const fiberIdClientInterrupt = -499
-
 // internal
 
 const makeSocketProtocol: Effect.Effect<
@@ -1365,12 +1398,7 @@ const makeSocketProtocol: Effect.Effect<
         return writeRaw(parser.encode(ResponseDefectEncoded(cause))!)
       }
     }).pipe(
-      Effect.catchIf(
-        ((
-          error: any
-        ) => (error.reason._tag === "SocketCloseError" ? Result.succeed(error.reason) : Result.fail(error))) as any,
-        (_: any) => Effect.void
-      ),
+      Effect.catchReason("SocketError", "SocketCloseError", (_) => Effect.void),
       Effect.orDie
     )
   }