effect 4.0.6 → 4.0.7

package/src/persistence/Redis.ts

@@ -2,16 +2,17 @@
  * Redis support shared by persistence modules.
  *
  * This module defines a `Redis` service that can send Redis commands, subscribe
- * to pub/sub channels, and run Lua scripts. It does not create a Redis client
- * itself; callers provide the client-specific operations. The module also
- * provides helpers for describing Lua scripts, loading them once, and running
- * them later by their cached Redis id.
+ * to pub/sub channels, run Lua scripts, and reserve a dedicated connection from
+ * a pool. It does not create a Redis client itself; callers provide the
+ * client-specific operations. The module also provides helpers for describing
+ * Lua scripts, loading them once, and running them later by their cached Redis
+ * id.
  *
  * @stability unstable
  * @since 4.0.0
  */
 import * as Cache from "../Cache.ts"
-import type * as Cause from "../Cause.ts"
+import * as Cause from "../Cause.ts"
 import * as Context from "../Context.ts"
 import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
@@ -19,6 +20,7 @@ import * as Equal from "../Equal.ts"
 import * as Exit from "../Exit.ts"
 import { constant, identity } from "../Function.ts"
 import * as Hash from "../Hash.ts"
+import * as Pool from "../Pool.ts"
 import * as Queue from "../Queue.ts"
 import * as Schema from "../Schema.ts"
 import * as Scope from "../Scope.ts"
@@ -63,8 +65,63 @@ export class Redis extends Context.Service<Redis, {
       readonly result: unknown
     }
   >(script: Script<Config>) => (...params: Config["params"]) => Effect.Effect<Config["result"], RedisError>
+
+  /**
+   * Reserves a pooled connection that no other caller shares for the lifetime
+   * of the current scope.
+   *
+   * Use it for blocking commands such as `XREAD BLOCK`, `XREADGROUP BLOCK`,
+   * `BLPOP`, `BRPOP`, `BLMOVE`, `BLMPOP` and `WAIT`, which would otherwise
+   * hold up every command queued behind them on the shared connection.
+   *
+   * When the scope closes, the connection returns to the pool. If a command on
+   * it failed, was interrupted, or is still running, the connection is closed
+   * instead, because Redis may still be processing the command.
+   */
+  readonly reserve: Effect.Effect<Connection, RedisError, Scope.Scope>
 }>()("effect/persistence/Redis") {}
 
+/**
+ * A dedicated Redis connection obtained from `Redis.reserve`.
+ *
+ * **Details**
+ *
+ * `eval` loads scripts through the shared connection and runs `EVALSHA` on
+ * this connection.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.7
+ */
+export interface Connection {
+  readonly send: Redis["Service"]["send"]
+  readonly eval: Redis["Service"]["eval"]
+}
+
+/**
+ * Options for the pool of connections behind `Redis.reserve`.
+ *
+ * **Details**
+ *
+ * - `maxConnections`: maximum number of reserved connections, default `10`.
+ *   Further `reserve` calls wait for a connection to be released.
+ * - `minConnections`: connections kept open while idle, default `0`.
+ * - `idleTimeout`: how long a connection above `minConnections` stays idle
+ *   before it is closed, default 60 seconds.
+ * - `acquireTimeout`: how long `reserve` waits for a connection before failing
+ *   with a `RedisError`. Unbounded by default.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.7
+ */
+export interface PoolOptions {
+  readonly maxConnections?: number | undefined
+  readonly minConnections?: number | undefined
+  readonly idleTimeout?: Duration.Input | undefined
+  readonly acquireTimeout?: Duration.Input | undefined
+}
+
 /**
  * Creates a `Redis` service from raw command and subscription operations.
  *
@@ -73,6 +130,11 @@ export class Redis extends Context.Service<Redis, {
  * Lua scripts are loaded through `SCRIPT LOAD`, cached, and then invoked with
  * `EVALSHA`.
  *
+ * `connect` opens the dedicated connections behind `reserve`. Its `close` must
+ * fail any command still in flight on that connection. Connections are pooled
+ * according to `pool`, and closing the scope closes every connection,
+ * including reserved ones with a command in flight.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
@@ -84,6 +146,11 @@ export const make = Effect.fnUntraced(function*(
       channel: string,
       onMessage: (message: RedisMessage) => void
     ) => Effect.Effect<Effect.Effect<void, RedisError>, RedisError, Scope.Scope>
+    readonly connect: Effect.Effect<{
+      readonly send: <A = unknown>(command: string, ...args: ReadonlyArray<string>) => Effect.Effect<A, RedisError>
+      readonly close: Effect.Effect<void>
+    }, RedisError>
+    readonly pool?: PoolOptions | undefined
   }
 ) {
   const scriptCache = yield* Cache.makeWith(
@@ -94,7 +161,8 @@ export const make = Effect.fnUntraced(function*(
     }
   )
 
-  const eval_ = <
+  const makeEval = (send: Redis["Service"]["send"]): Redis["Service"]["eval"] =>
+  <
     Config extends {
       readonly params: ReadonlyArray<unknown>
       readonly result: unknown
@@ -104,7 +172,7 @@ export const make = Effect.fnUntraced(function*(
   ) =>
   (...params: Config["params"]): Effect.Effect<Config["result"], RedisError> => {
     const evalSha = (sha: string) =>
-      options.send<Config["result"]>(
+      send<Config["result"]>(
         "EVALSHA",
         sha,
         script.numberOfKeys(...params).toString(),
@@ -119,6 +187,58 @@ export const make = Effect.fnUntraced(function*(
     )
   }
 
+  // Closing a connection fails its in-flight command, which releases the
+  // reservation. The pool waits for reservations on shutdown, so connections
+  // are closed before it shuts down.
+  const connections = new Set<Effect.Effect<void>>()
+  const pool = yield* Pool.makeWithTTL({
+    acquire: Effect.acquireRelease(
+      Effect.map(options.connect, (connection) => {
+        const close: Effect.Effect<void> = Effect.suspend(() =>
+          connections.delete(close) ? connection.close : Effect.void
+        )
+        connections.add(close)
+        return { send: connection.send, close, healthy: true, active: 0 }
+      }),
+      (connection) => connection.close
+    ),
+    min: options.pool?.minConnections ?? 0,
+    max: options.pool?.maxConnections ?? 10,
+    concurrency: 1,
+    timeToLive: options.pool?.idleTimeout ?? Duration.seconds(60)
+  })
+  yield* Effect.addFinalizer(() => Effect.forEach(connections, identity, { discard: true }))
+
+  const acquireTimeout = options.pool?.acquireTimeout
+  const get = acquireTimeout === undefined ? Pool.get(pool) : Pool.get(pool).pipe(
+    Effect.timeoutOrElse({
+      duration: acquireTimeout,
+      orElse: () =>
+        Effect.fail(
+          new RedisError({ cause: new Cause.TimeoutError("Timed out waiting for a reserved Redis connection") })
+        )
+    })
+  )
+
+  const reserve = Effect.gen(function*() {
+    const connection = yield* get
+    yield* Effect.addFinalizer(() =>
+      connection.healthy && connection.active === 0 ? Effect.void : Pool.invalidate(pool, connection)
+    )
+    const send = <A = unknown>(command: string, ...args: ReadonlyArray<string>) =>
+      Effect.suspend(() => {
+        connection.active++
+        return connection.send<A>(command, ...args).pipe(
+          Effect.onExit((exit) => {
+            connection.active--
+            if (Exit.isFailure(exit)) connection.healthy = false
+            return Effect.void
+          })
+        )
+      })
+    return identity<Connection>({ send, eval: makeEval(send) })
+  })
+
   const subscribe = Effect.fnUntraced(function*(channel: string) {
     const queue = yield* Queue.unbounded<RedisMessage, RedisError>()
     yield* Scope.addFinalizer(yield* Effect.scope, Queue.shutdown(queue))
@@ -135,7 +255,8 @@ export const make = Effect.fnUntraced(function*(
   return identity<Redis["Service"]>({
     send: options.send,
     subscribe,
-    eval: eval_
+    eval: makeEval(options.send),
+    reserve
   })
 })
 

package/src/persistence/index.ts

@@ -5,6 +5,12 @@
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
+/**
+ * @stability experimental
+ * @since 4.0.6
+ */
+export * as CircuitBreaker from "./CircuitBreaker.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0

package/src/process/ChildProcess.ts

@@ -319,10 +319,17 @@ export interface StdoutConfig {
    * Can be a string indicating how the operating system should configure the
    * pipe established between the child process `stdout` and the parent process.
    *
-   * A `Sink` can also be passed, which will receive all elements produced by
-   * the `stdout` of the child process.
+   * A `Sink` can also be passed. The output is transduced through the sink as
+   * `handle.stdout` is consumed, and `handle.stdout` emits the results produced by
+   * the sink instead of the raw output.
    *
    * Defaults to "pipe".
+   *
+   * **Gotchas**
+   *
+   * A `Sink` only receives data while `handle.stdout` is being consumed. If
+   * it is never consumed, the sink receives nothing and a child process that
+   * writes more than the pipe buffer can block before it exits.
    */
   readonly stream?: CommandOutput | undefined
 }
@@ -343,10 +350,17 @@ export interface StderrConfig {
    * Can be a string indicating how the operating system should configure the
    * pipe established between the child process `stderr` and the parent process.
    *
-   * A `Sink` can also be passed, which will receive all elements produced by
-   * the `stderr` of the child process.
+   * A `Sink` can also be passed. The output is transduced through the sink as
+   * `handle.stderr` is consumed, and `handle.stderr` emits the results produced by
+   * the sink instead of the raw output.
    *
    * Defaults to "pipe".
+   *
+   * **Gotchas**
+   *
+   * A `Sink` only receives data while `handle.stderr` is being consumed. If
+   * it is never consumed, the sink receives nothing and a child process that
+   * writes more than the pipe buffer can block before it exits.
    */
   readonly stream?: CommandOutput | undefined
 }
@@ -382,6 +396,18 @@ export type AdditionalFdConfig =
     /**
      * For output file descriptors, an optional sink which receives data from
      * the file descriptor.
+     *
+     * **Details**
+     *
+     * The data is transduced through the sink as `handle.getOutputFd(fd)` is
+     * consumed, and that stream emits the results produced by the sink
+     * instead of the raw output.
+     *
+     * **Gotchas**
+     *
+     * The sink only receives data while `handle.getOutputFd(fd)` is being
+     * consumed. If it is never consumed, the sink receives nothing and a child
+     * process that writes more than the pipe buffer can block before it exits.
      */
     readonly sink?: Sink.Sink<Uint8Array, Uint8Array, never, PlatformError.PlatformError> | undefined
   }

package/src/process/ChildProcessSpawner.ts

@@ -230,11 +230,13 @@ export const makeHandle = (params: Omit<ChildProcessHandle, typeof HandleTypeId>
  * @since 4.0.0
  */
 export const make = (spawn: ChildProcessSpawner["Service"]["spawn"]): ChildProcessSpawner["Service"] => {
+  // The helpers own the handle, so they drain any output they do not return
+  // to keep a full pipe from blocking the child.
   const streamString: ChildProcessSpawner["Service"]["streamLines"] = (command, options) =>
     spawn(command).pipe(
       Effect.map((handle) =>
         Stream.decodeText(
-          options?.includeStderr === true ? handle.all : handle.stdout
+          options?.includeStderr === true ? handle.all : Stream.drainFork(handle.stdout, handle.stderr)
         )
       ),
       Stream.unwrap
@@ -244,7 +246,14 @@ export const make = (spawn: ChildProcessSpawner["Service"]["spawn"]): ChildProce
 
   return ChildProcessSpawner.of({
     spawn,
-    exitCode: (command) => Effect.scoped(Effect.flatMap(spawn(command), (handle) => handle.exitCode)),
+    // Return once the process exits, even if descendants keep the pipes open.
+    exitCode: (command) =>
+      Effect.scoped(
+        Effect.flatMap(
+          spawn(command),
+          (handle) => Effect.raceFirst(handle.exitCode, Effect.andThen(Stream.runDrain(handle.all), Effect.never))
+        )
+      ),
     streamString,
     streamLines,
     lines: (command, options) => Stream.runCollect(streamLines(command, options)),
@@ -269,6 +278,12 @@ export class ChildProcessSpawner extends Context.Service<ChildProcessSpawner, {
 
   /**
    * Run a command and return its exit code.
+   *
+   * **Details**
+   *
+   * Piped `stdout` and `stderr` are read and discarded until the process
+   * exits. A read failure before then, such as from an output `Sink`, fails
+   * the effect.
    */
   exitCode(
     command: Command
@@ -277,6 +292,12 @@ export class ChildProcessSpawner extends Context.Service<ChildProcessSpawner, {
   /**
    * Stream the output of a command as strings. Optionally include stderr output
    * interleaved with stdout.
+   *
+   * **Details**
+   *
+   * Without `includeStderr`, piped `stderr` is read and discarded until
+   * `stdout` ends. A read failure before then, such as from an output `Sink`,
+   * fails the result.
    */
   streamString(command: Command, options?: {
     readonly includeStderr?: boolean | undefined
@@ -285,6 +306,12 @@ export class ChildProcessSpawner extends Context.Service<ChildProcessSpawner, {
   /**
    * Stream the output of a command as lines. Optionally include stderr output
    * interleaved with stdout.
+   *
+   * **Details**
+   *
+   * Without `includeStderr`, piped `stderr` is read and discarded until
+   * `stdout` ends. A read failure before then, such as from an output `Sink`,
+   * fails the result.
    */
   streamLines(command: Command, options?: {
     readonly includeStderr?: boolean | undefined
@@ -292,6 +319,12 @@ export class ChildProcessSpawner extends Context.Service<ChildProcessSpawner, {
 
   /**
    * Run a command and return the lines of its output as an array of strings.
+   *
+   * **Details**
+   *
+   * Without `includeStderr`, piped `stderr` is read and discarded until
+   * `stdout` ends. A read failure before then, such as from an output `Sink`,
+   * fails the result.
    */
   lines(command: Command, options?: {
     readonly includeStderr?: boolean | undefined
@@ -299,6 +332,12 @@ export class ChildProcessSpawner extends Context.Service<ChildProcessSpawner, {
 
   /**
    * Run a command and return its output as a string.
+   *
+   * **Details**
+   *
+   * Without `includeStderr`, piped `stderr` is read and discarded until
+   * `stdout` ends. A read failure before then, such as from an output `Sink`,
+   * fails the result.
    */
   string(command: Command, options?: {
     readonly includeStderr?: boolean | undefined

package/src/reactivity/AsyncResult.ts

@@ -309,7 +309,7 @@ export const isFailure = <A, E>(result: AsyncResult<A, E>): result is Failure<A,
  * @category guards
  * @since 4.0.0
  */
-export const isInterrupted = <A, E>(result: AsyncResult<A, E>): result is Failure<A, E> =>
+export const isInterrupted = <A, E>(result: AsyncResult<A, E>): boolean =>
   result._tag === "Failure" && Cause.hasInterruptsOnly(result.cause)
 
 /**

package/src/rpc/RpcClient.ts

@@ -689,9 +689,9 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
     readonly schemas: RpcSchemas
   }
   const entries = new Map<RequestId, ClientEntry>()
-  // Set before the protocol stops running this client, so requests made while
-  // it shuts down are not handed to a transport that is being torn down.
-  let isClosing = false
+  // Completed before the protocol stops running this client, so requests made
+  // while it shuts down are not handed to a transport that is being torn down.
+  const closing = Deferred.makeUnsafe<void>()
 
   const interruptRequest = (requestId: RequestId): Effect.Effect<void, RpcClientError> => {
     if (!entries.has(requestId)) return Effect.void
@@ -723,7 +723,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
             Effect.flatMap((payload) => {
               // Checked after encoding, which can suspend while the client
               // starts shutting down.
-              if (isClosing) {
+              if (Deferred.isDoneUnsafe(closing)) {
                 entries.delete(message.id)
                 return Effect.interrupt
               }
@@ -775,7 +775,14 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           ).pipe(
             Effect.onError((cause) =>
               write({ _tag: "Exit", clientId: 0, requestId, exit: Exit.failCause(cause) }).pipe(
-                Effect.andThen(Cause.hasInterrupts(cause) ? Effect.void : Effect.ignore(interruptRequest(requestId)))
+                Effect.andThen(
+                  Cause.hasInterrupts(cause) ? Effect.void : Effect.raceFirst(
+                    Effect.ignore(interruptRequest(requestId)),
+                    // Best-effort once the client closes: a disconnected transport
+                    // can wait for a reconnect that never comes.
+                    Deferred.await(closing)
+                  )
+                )
               )
             ),
             // a decode failure only ends its own request; interruption still propagates
@@ -821,11 +828,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
     Effect.forkScoped
   )
   // Finalizers run in reverse order, so this runs before `run` is interrupted.
-  yield* Effect.addFinalizer(() =>
-    Effect.sync(() => {
-      isClosing = true
-    })
-  )
+  yield* Effect.addFinalizer(() => Deferred.succeed(closing, void 0))
 
   return client
 })

package/src/rpc/RpcSerialization.ts

@@ -230,18 +230,25 @@ export const ndjson: RpcSerialization["Service"] = makeNdjson()
  * Creates a JSON-RPC 2.0 serialization for RPC protocol messages without
  * additional message framing.
  *
+ * **Details**
+ *
+ * Set `controlMessages` to `false` for plain JSON-RPC peers, so
+ * `@effect/rpc/*` methods are not decoded as RPC control messages.
+ *
  * @stability unstable
  * @category serialization
  * @since 4.0.0
  */
 export const jsonRpc = (options?: {
   readonly contentType?: string | undefined
+  readonly controlMessages?: boolean | undefined
 }): RpcSerialization["Service"] =>
   RpcSerialization.of({
     contentType: options?.contentType ?? "application/json",
     includesFraming: false,
     codecFor: codecForJson,
     makeUnsafe: () => {
+      const controlMessages = options?.controlMessages ?? true
       const batches = new Map<string | number, {
         readonly size: number
         readonly responses: Map<string | number, RpcMessage.FromServerEncoded>
@@ -251,7 +258,7 @@ export const jsonRpc = (options?: {
           const decoded: unknown = JSON.parse(
             typeof bytes === "string" ? bytes : decodeText(bytes)
           )
-          return decodeJsonRpcRaw(decoded, batches)
+          return decodeJsonRpcRaw(decoded, batches, controlMessages)
         },
         encode: (response) => {
           const encoded = encodeJsonRpcResponse(response as any, batches)
@@ -265,6 +272,11 @@ export const jsonRpc = (options?: {
  * Creates a newline-delimited JSON-RPC 2.0 serialization for RPC protocol
  * messages.
  *
+ * **Details**
+ *
+ * Set `controlMessages` to `false` for plain JSON-RPC peers, so
+ * `@effect/rpc/*` methods are not decoded as RPC control messages.
+ *
  * @stability unstable
  * @category serialization
  * @since 4.0.0
@@ -272,6 +284,7 @@ export const jsonRpc = (options?: {
 export const ndJsonRpc = (options?: {
   readonly contentType?: string | undefined
   readonly maxBufferSize?: number | "unbounded" | undefined
+  readonly controlMessages?: boolean | undefined
 }): RpcSerialization["Service"] =>
   RpcSerialization.of({
     contentType: options?.contentType ?? "application/json-rpc",
@@ -279,6 +292,7 @@ export const ndJsonRpc = (options?: {
     codecFor: codecForJson,
     makeUnsafe: () => {
       const parser = makeNdjson({ maxBufferSize: options?.maxBufferSize }).makeUnsafe()
+      const controlMessages = options?.controlMessages ?? true
       const batches = new Map<string, {
         readonly size: number
         readonly responses: Map<string, RpcMessage.FromServerEncoded>
@@ -289,7 +303,7 @@ export const ndJsonRpc = (options?: {
           if (frames.length === 0) return []
           const messages: Array<RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded> = []
           for (let i = 0; i < frames.length; i++) {
-            messages.push(...decodeJsonRpcRaw(frames[i], batches))
+            messages.push(...decodeJsonRpcRaw(frames[i], batches, controlMessages))
           }
           return messages
         },
@@ -306,7 +320,8 @@ function decodeJsonRpcRaw(
   batches: Map<string | number, {
     readonly size: number
     readonly responses: Map<string | number, RpcMessage.FromServerEncoded>
-  }>
+  }>,
+  controlMessages: boolean
 ) {
   if (Array.isArray(decoded)) {
     const batch = {
@@ -317,7 +332,7 @@ function decodeJsonRpcRaw(
     for (let i = 0; i < decoded.length; i++) {
       const item = decoded[i]
       if (!Predicate.isObject(item)) continue
-      const message = decodeJsonRpcMessage(item as unknown as JsonRpcMessage)
+      const message = decodeJsonRpcMessage(item as unknown as JsonRpcMessage, controlMessages)
       messages.push(message)
       if (message._tag === "Request" && !message.isNotification) {
         batch.size++
@@ -326,14 +341,20 @@ function decodeJsonRpcRaw(
     }
     return messages
   }
-  return Predicate.isObject(decoded) ? [decodeJsonRpcMessage(decoded as unknown as JsonRpcMessage)] : []
+  return Predicate.isObject(decoded)
+    ? [decodeJsonRpcMessage(decoded as unknown as JsonRpcMessage, controlMessages)]
+    : []
 }
 
-function decodeJsonRpcMessage(decoded: JsonRpcMessage): RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded {
+function decodeJsonRpcMessage(
+  decoded: JsonRpcMessage,
+  controlMessages: boolean
+): RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded {
   if (Object.hasOwn(decoded, "method")) {
     const request = decoded as JsonRpcRequest
     if (
-      Predicate.isNullish(request.id) && Predicate.isString(request.method) && request.method.startsWith("@effect/rpc/")
+      controlMessages && Predicate.isNullish(request.id) && Predicate.isString(request.method) &&
+      request.method.startsWith("@effect/rpc/")
     ) {
       const tag = request.method.slice("@effect/rpc/".length) as
         | RpcMessage.FromServerEncoded["_tag"]
@@ -403,13 +424,13 @@ function encodeJsonRpcRaw(
     readonly responses: Map<string | number, RpcMessage.FromServerEncoded>
   }>
 ) {
-  if (!("requestId" in response)) {
+  if (response._tag !== "Exit") {
     return encodeJsonRpcMessage(response)
   }
   const batch = batches.get(response.requestId)
   if (batch) {
     batches.delete(response.requestId)
-    batch.responses.set(response.requestId, response as any)
+    batch.responses.set(response.requestId, response)
     if (batch.size === batch.responses.size) {
       return Array.from(batch.responses.values(), encodeJsonRpcMessage)
     }
@@ -644,6 +665,7 @@ export const layerNdjsonWith = (options?: StreamOptions): Layer.Layer<RpcSeriali
  */
 export const layerJsonRpc = (options?: {
   readonly contentType?: string | undefined
+  readonly controlMessages?: boolean | undefined
 }): Layer.Layer<RpcSerialization> => Layer.succeed(RpcSerialization)(jsonRpc(options))
 
 /**
@@ -657,6 +679,7 @@ export const layerJsonRpc = (options?: {
 export const layerNdJsonRpc = (options?: {
   readonly contentType?: string | undefined
   readonly maxBufferSize?: number | "unbounded" | undefined
+  readonly controlMessages?: boolean | undefined
 }): Layer.Layer<RpcSerialization> => Layer.succeed(RpcSerialization)(ndJsonRpc(options))
 
 /**

package/src/rpc/RpcServer.ts

@@ -278,7 +278,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       headers: request.headers,
       payload: request.payload
     }
-    const result = entry.handler(request.payload, metadata)
+    const result = runHandler(entry, request.payload, metadata)
 
     // if the handler requested forking, then we skip the concurrency control
     const isWrapper = Rpc.isWrapper(result)
@@ -574,6 +574,21 @@ const handlerContext = (
   return merged
 }
 
+// a synchronous throw is handled like a returned `Effect.die`, so it goes
+// through the request exit handling. Stream handlers may also return an
+// Effect, so a single `Effect.die` covers both kinds of rpc.
+const runHandler = (
+  entry: Rpc.Handler<string>,
+  payload: unknown,
+  metadata: Parameters<Rpc.Handler<string>["handler"]>[1]
+) => {
+  try {
+    return entry.handler(payload, metadata)
+  } catch (defect) {
+    return Effect.die(defect)
+  }
+}
+
 const applyMiddleware = <A, E, R>(
   context: Context.Context<never>,
   handler: Effect.Effect<A, E, R>,

package/src/rpc/RpcTest.ts

@@ -29,6 +29,7 @@ export const makeClient: <Rpcs extends Rpc.Any, const Flatten extends boolean =
   group: RpcGroup.RpcGroup<Rpcs>,
   options?: {
     readonly flatten?: Flatten | undefined
+    readonly disableFatalDefects?: boolean | undefined
   }
 ) => Effect.Effect<
   Flatten extends true ? RpcClient.RpcClient.Flat<Rpcs> : RpcClient.RpcClient<Rpcs>,
@@ -38,11 +39,13 @@ export const makeClient: <Rpcs extends Rpc.Any, const Flatten extends boolean =
   group: RpcGroup.RpcGroup<Rpcs>,
   options?: {
     readonly flatten?: Flatten | undefined
+    readonly disableFatalDefects?: boolean | undefined
   }
 ) {
   // oxlint-disable-next-line prefer-const
   let client!: Effect.Success<ReturnType<typeof RpcClient.makeNoSerialization<Rpcs, never, Flatten>>>
   const server = yield* RpcServer.makeNoSerialization(group, {
+    disableFatalDefects: options?.disableFatalDefects,
     onFromServer(response) {
       return client.write(response)
     }