@effect/platform 0.58.27 → 0.59.1

package/src/Error.ts

@@ -54,44 +54,6 @@ export const TypeIdError = <const TypeId extends symbol, const Tag extends strin
   return Base as any
 }
 
-/**
- * @since 1.0.0
- * @category error
- */
-export const RefailError = <const TypeId extends symbol, const Tag extends string>(
-  typeId: TypeId,
-  tag: Tag
-): new<A extends Record<string, any>>(
-  args: Simplify<A & { readonly error: unknown }>
-) =>
-  & Cause.YieldableError
-  & Record<TypeId, TypeId>
-  & { readonly _tag: Tag; readonly error: unknown }
-  & Readonly<A> =>
-{
-  class Base extends Data.Error<{
-    readonly error: unknown
-  }> {
-    readonly _tag = tag
-    constructor(props: any) {
-      super(props)
-      if (Predicate.hasProperty(this.error, "stack")) {
-        ;(this as any).stack = this.error.stack
-      }
-    }
-    get message() {
-      return Predicate.hasProperty(this.error, "message")
-        ? this.error.message as string
-        : Predicate.hasProperty(this.error, "toJSON") && typeof this.error.toJSON === "function"
-        ? JSON.stringify(this.error.toJSON())
-        : String(this.error)
-    }
-  }
-  ;(Base.prototype as any)[typeId] = typeId
-  ;(Base.prototype as any).name = tag
-  return Base as any
-}
-
 /**
  * @since 1.0.0
  */

package/src/HttpApp.ts

@@ -138,12 +138,12 @@ export const withPreResponseHandler = dual<
  */
 export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
   const run = Runtime.runFork(runtime)
-  return <E>(self: Default<E, R | Scope.Scope>, middleware: HttpMiddleware | undefined) =>
+  return <E>(self: Default<E, R | Scope.Scope>, middleware?: HttpMiddleware | undefined) =>
   (request: Request): Promise<Response> =>
     new Promise((resolve) => {
       const fiber = run(Effect.provideService(
         toHandled(self, (request, response) => {
-          resolve(ServerResponse.toWeb(response, request.method === "HEAD"))
+          resolve(ServerResponse.toWeb(response, { withoutBody: request.method === "HEAD", runtime }))
           return Effect.void
         }, middleware),
         ServerRequest.HttpServerRequest,

package/src/HttpClientError.ts

@@ -28,17 +28,20 @@ export type HttpClientError = RequestError | ResponseError
  * @since 1.0.0
  * @category error
  */
-export class RequestError extends Error.RefailError(TypeId, "RequestError")<{
+export class RequestError extends Error.TypeIdError(TypeId, "RequestError")<{
   readonly request: ClientRequest.HttpClientRequest
   readonly reason: "Transport" | "Encode" | "InvalidUrl"
+  readonly cause?: unknown
+  readonly description?: string
 }> {
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
 
   get message() {
-    const errorString = super.message
-    return `${this.reason} error (${this.methodAndUrl}): ${errorString}`
+    return this.description ?
+      `${this.reason}: ${this.description} (${this.methodAndUrl})` :
+      `${this.reason} error (${this.methodAndUrl})`
   }
 }
 
@@ -46,17 +49,21 @@ export class RequestError extends Error.RefailError(TypeId, "RequestError")<{
  * @since 1.0.0
  * @category error
  */
-export class ResponseError extends Error.RefailError(TypeId, "ResponseError")<{
+export class ResponseError extends Error.TypeIdError(TypeId, "ResponseError")<{
   readonly request: ClientRequest.HttpClientRequest
   readonly response: ClientResponse.HttpClientResponse
   readonly reason: "StatusCode" | "Decode" | "EmptyBody"
+  readonly cause?: unknown
+  readonly description?: string
 }> {
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
 
   get message() {
-    const errorString = super.message
-    return `${this.reason} error (${this.response.status} ${this.methodAndUrl}): ${errorString}`
+    const info = `${this.response.status} ${this.methodAndUrl}`
+    return this.description ?
+      `${this.reason}: ${this.description} (${info})` :
+      `${this.reason} error (${info})`
   }
 }

package/src/HttpServerError.ts

@@ -6,7 +6,7 @@ import type * as Effect from "effect/Effect"
 import type * as Exit from "effect/Exit"
 import type * as FiberId from "effect/FiberId"
 import type * as Option from "effect/Option"
-import { RefailError, TypeIdError } from "./Error.js"
+import { TypeIdError } from "./Error.js"
 import type * as ServerRequest from "./HttpServerRequest.js"
 import * as Respondable from "./HttpServerRespondable.js"
 import * as ServerResponse from "./HttpServerResponse.js"
@@ -34,9 +34,11 @@ export type HttpServerError = RequestError | ResponseError | RouteNotFound | Ser
  * @since 1.0.0
  * @category error
  */
-export class RequestError extends RefailError(TypeId, "RequestError")<{
+export class RequestError extends TypeIdError(TypeId, "RequestError")<{
   readonly request: ServerRequest.HttpServerRequest
   readonly reason: "Transport" | "Decode"
+  readonly cause?: unknown
+  readonly description?: string
 }> implements Respondable.Respondable {
   /**
    * @since 1.0.0
@@ -50,7 +52,9 @@ export class RequestError extends RefailError(TypeId, "RequestError")<{
   }
 
   get message() {
-    return `${this.reason} error (${this.methodAndUrl}): ${super.message}`
+    return this.description ?
+      `${this.reason}: ${this.description} (${this.methodAndUrl})` :
+      `${this.reason} error (${this.methodAndUrl})`
   }
 }
 
@@ -86,10 +90,12 @@ export class RouteNotFound extends TypeIdError(TypeId, "RouteNotFound")<{
  * @since 1.0.0
  * @category error
  */
-export class ResponseError extends RefailError(TypeId, "ResponseError")<{
+export class ResponseError extends TypeIdError(TypeId, "ResponseError")<{
   readonly request: ServerRequest.HttpServerRequest
   readonly response: ServerResponse.HttpServerResponse
   readonly reason: "Decode"
+  readonly cause?: unknown
+  readonly description?: string
 }> {
   /**
    * @since 1.0.0
@@ -103,7 +109,10 @@ export class ResponseError extends RefailError(TypeId, "ResponseError")<{
   }
 
   get message() {
-    return `${this.reason} error (${this.response.status} ${this.methodAndUrl}): ${super.message}`
+    const info = `${this.response.status} ${this.methodAndUrl}`
+    return this.description ?
+      `${this.description} (${info})` :
+      `${this.reason} error (${info})`
   }
 }
 
@@ -111,7 +120,9 @@ export class ResponseError extends RefailError(TypeId, "ResponseError")<{
  * @since 1.0.0
  * @category error
  */
-export class ServeError extends RefailError(TypeId, "ServeError")<{}> {}
+export class ServeError extends TypeIdError(TypeId, "ServeError")<{
+  readonly cause: unknown
+}> {}
 
 /**
  * @since 1.0.0

package/src/HttpServerResponse.ts

@@ -5,6 +5,7 @@ import type { ParseOptions } from "@effect/schema/AST"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type { Inspectable } from "effect/Inspectable"
+import type * as Runtime from "effect/Runtime"
 import type * as Stream from "effect/Stream"
 import type { Cookie, Cookies, CookiesError } from "./Cookies.js"
 import type * as PlatformError from "./Error.js"
@@ -353,4 +354,10 @@ export const setStatus: {
  * @since 1.0.0
  * @category conversions
  */
-export const toWeb: (response: HttpServerResponse, withoutBody?: boolean | undefined) => Response = internal.toWeb
+export const toWeb: (
+  response: HttpServerResponse,
+  options?: {
+    readonly withoutBody?: boolean | undefined
+    readonly runtime?: Runtime.Runtime<never> | undefined
+  }
+) => Response = internal.toWeb

package/src/Multipart.ts

@@ -137,7 +137,8 @@ export interface MultipartError extends YieldableError {
   readonly [ErrorTypeId]: ErrorTypeId
   readonly _tag: "MultipartError"
   readonly reason: "FileTooLarge" | "FieldTooLarge" | "BodyTooLarge" | "TooManyParts" | "InternalError" | "Parse"
-  readonly error: unknown
+  readonly message: string
+  readonly cause: unknown
 }
 
 /**
@@ -147,7 +148,7 @@ export interface MultipartError extends YieldableError {
 export const MultipartError: new(
   options: {
     readonly reason: MultipartError["reason"]
-    readonly error: unknown
+    readonly cause: unknown
   }
 ) => MultipartError = internal.MultipartError
 

package/src/Socket.ts

@@ -18,7 +18,7 @@ import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
 import * as Scope from "effect/Scope"
 import type * as AsyncProducer from "effect/SingleProducerAsyncInput"
-import { RefailError, TypeIdError } from "./Error.js"
+import { TypeIdError } from "./Error.js"
 
 /**
  * @since 1.0.0
@@ -125,11 +125,12 @@ export type SocketError = SocketGenericError | SocketCloseError
  * @since 1.0.0
  * @category errors
  */
-export class SocketGenericError extends RefailError(SocketErrorTypeId, "SocketError")<{
+export class SocketGenericError extends TypeIdError(SocketErrorTypeId, "SocketError")<{
   readonly reason: "Write" | "Read" | "Open" | "OpenTimeout"
+  readonly cause: unknown
 }> {
   get message() {
-    return `${this.reason}: ${super.message}`
+    return `An error occurred during ${this.reason}`
   }
 }
 
@@ -383,10 +384,10 @@ export const fromWebSocket = <R>(
                   )
                 )
               }
-              ws.onerror = (error) => {
+              ws.onerror = (cause) => {
                 Deferred.unsafeDone(
                   fiberSet.deferred,
-                  Effect.fail(new SocketGenericError({ reason: open ? "Read" : "Open", error }))
+                  Effect.fail(new SocketGenericError({ reason: open ? "Read" : "Open", cause }))
                 )
               }
 
@@ -407,7 +408,7 @@ export const fromWebSocket = <R>(
                   Effect.timeoutFail({
                     duration: options?.openTimeout ?? 10000,
                     onTimeout: () =>
-                      new SocketGenericError({ reason: "OpenTimeout", error: "timeout waiting for \"open\"" })
+                      new SocketGenericError({ reason: "OpenTimeout", cause: "timeout waiting for \"open\"" })
                   }),
                   Effect.raceFirst(FiberSet.join(fiberSet))
                 )
@@ -430,7 +431,7 @@ export const fromWebSocket = <R>(
                     Effect.try({
                       try: () =>
                         ws.send(chunk),
-                      catch: (error) => new SocketGenericError({ reason: "Write", error })
+                      catch: (cause) => new SocketGenericError({ reason: "Write", cause })
                     })
                 ),
                 Effect.forever,
@@ -585,7 +586,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
                         writer.write(chunk)
                       }
                     },
-                    catch: (error) => new SocketGenericError({ reason: "Write", error })
+                    catch: (cause) => new SocketGenericError({ reason: "Write", cause })
                   })
                 }),
                 Effect.forever,
@@ -595,7 +596,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
             Effect.tap(({ fiberSet, reader }) =>
               Effect.tryPromise({
                 try: () => reader.read(),
-                catch: (error) => new SocketGenericError({ reason: "Read", error })
+                catch: (cause) => new SocketGenericError({ reason: "Read", cause })
               }).pipe(
                 Effect.tap((result) => {
                   if (result.done) {

package/src/Worker.ts

@@ -5,17 +5,14 @@ import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Serializable from "@effect/schema/Serializable"
 import type * as Context from "effect/Context"
+import type * as Deferred from "effect/Deferred"
 import type * as Duration from "effect/Duration"
 import type * as Effect from "effect/Effect"
-import type * as Fiber from "effect/Fiber"
 import type { LazyArg } from "effect/Function"
 import type * as Layer from "effect/Layer"
-import type * as Option from "effect/Option"
 import type * as Pool from "effect/Pool"
-import type * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
-import type * as Tracer from "effect/Tracer"
 import * as internal from "./internal/worker.js"
 import type { WorkerError, WorkerErrorFrom } from "./WorkerError.js"
 
@@ -24,9 +21,10 @@ import type { WorkerError, WorkerErrorFrom } from "./WorkerError.js"
  * @category models
  */
 export interface BackingWorker<I, O> {
-  readonly fiber: Fiber.Fiber<never, WorkerError>
   readonly send: (message: I, transfers?: ReadonlyArray<unknown>) => Effect.Effect<void, WorkerError>
-  readonly queue: Queue.Dequeue<BackingWorker.Message<O>>
+  readonly run: <A, E, R>(
+    handler: (_: BackingWorker.Message<O>) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<never, E | WorkerError, R>
 }
 
 /**
@@ -59,9 +57,28 @@ export type PlatformWorkerTypeId = typeof PlatformWorkerTypeId
  */
 export interface PlatformWorker {
   readonly [PlatformWorkerTypeId]: PlatformWorkerTypeId
-  readonly spawn: <I, O>(worker: unknown) => Effect.Effect<BackingWorker<I, O>, WorkerError, Scope.Scope>
+  readonly spawn: <I, O>(id: number) => Effect.Effect<BackingWorker<I, O>, WorkerError, Spawner>
 }
 
+/**
+ * @since 1.0.0
+ */
+export const makePlatform: <W>() => <
+  P extends { readonly postMessage: (message: any, transfers?: any | undefined) => void }
+>(
+  options: {
+    readonly setup: (options: { readonly worker: W; readonly scope: Scope.Scope }) => Effect.Effect<P>
+    readonly listen: (
+      options: {
+        readonly port: P
+        readonly emit: (data: any) => void
+        readonly deferred: Deferred.Deferred<never, WorkerError>
+        readonly scope: Scope.Scope
+      }
+    ) => Effect.Effect<void>
+  }
+) => PlatformWorker = internal.makePlatform
+
 /**
  * @since 1.0.0
  * @category tags
@@ -86,6 +103,12 @@ export interface Spawner {
   readonly _: unique symbol
 }
 
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const Spawner: Context.Tag<Spawner, SpawnerFn<unknown>> = internal.Spawner
+
 /**
  * @since 1.0.0
  * @category models
@@ -105,8 +128,6 @@ export declare namespace Worker {
    */
   export interface Options<I> {
     readonly encode?: ((message: I) => Effect.Effect<unknown, WorkerError>) | undefined
-    readonly transfers?: ((message: I) => ReadonlyArray<unknown>) | undefined
-    readonly queue?: WorkerQueue<I> | undefined
     readonly initialMessage?: LazyArg<I> | undefined
   }
 
@@ -173,16 +194,6 @@ export declare namespace WorkerPool {
     })
 }
 
-/**
- * @category models
- * @since 1.0.0
- */
-export interface WorkerQueue<I> {
-  readonly offer: (id: number, item: I, span: Option.Option<Tracer.Span>) => Effect.Effect<void>
-  readonly take: Effect.Effect<readonly [id: number, item: I, span: Option.Option<Tracer.Span>]>
-  readonly shutdown: Effect.Effect<void>
-}
-
 /**
  * @since 1.0.0
  * @category type ids
@@ -268,20 +279,12 @@ export declare namespace SerializedWorker {
    * @since 1.0.0
    * @category models
    */
-  export type Options<I> = Extract<I, { readonly _tag: "InitialMessage" }> extends never ? BaseOptions<I> & {
+  export type Options<I> = Extract<I, { readonly _tag: "InitialMessage" }> extends never ? {
       readonly initialMessage?: LazyArg<I>
     }
-    : BaseOptions<I> & {
+    : {
       readonly initialMessage: LazyArg<Extract<I, { readonly _tag: "InitialMessage" }>>
     }
-
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export interface BaseOptions<I> {
-    readonly queue?: WorkerQueue<I> | undefined
-  }
 }
 
 /**

package/src/WorkerError.ts

@@ -3,7 +3,6 @@
  */
 import * as Schema from "@effect/schema/Schema"
 import type * as Cause from "effect/Cause"
-import * as Inspectable from "effect/Inspectable"
 import * as Predicate from "effect/Predicate"
 import * as internal from "./internal/workerError.js"
 
@@ -31,7 +30,7 @@ export const isWorkerError = (u: unknown): u is WorkerError => Predicate.hasProp
  */
 export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError", {
   reason: Schema.Literal("spawn", "decode", "send", "unknown", "encode"),
-  error: Schema.CauseDefectUnknown
+  cause: Schema.CauseDefectUnknown
 }) {
   /**
    * @since 1.0.0
@@ -61,11 +60,19 @@ export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError"
   /**
    * @since 1.0.0
    */
-  get message() {
-    const message = Predicate.hasProperty(this.error, "message")
-      ? this.error.message
-      : Inspectable.toStringUnknown(this.error, undefined)
-    return `${this.reason}: ${message}`
+  get message(): string {
+    switch (this.reason) {
+      case "send":
+        return "An error occurred calling .postMessage"
+      case "spawn":
+        return "An error occurred while spawning a worker"
+      case "decode":
+        return "An error occurred during decoding"
+      case "encode":
+        return "An error occurred during encoding"
+      case "unknown":
+        return "An unexpected error occurred"
+    }
   }
 }
 
@@ -76,5 +83,5 @@ export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError"
 export interface WorkerErrorFrom {
   readonly _tag: "WorkerError"
   readonly reason: "spawn" | "decode" | "send" | "unknown" | "encode"
-  readonly error: unknown
+  readonly cause: unknown
 }

package/src/WorkerRunner.ts

@@ -6,7 +6,6 @@ import type * as Serializable from "@effect/schema/Serializable"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
 import type * as Layer from "effect/Layer"
-import type * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import * as internal from "./internal/workerRunner.js"
@@ -17,7 +16,9 @@ import type { WorkerError } from "./WorkerError.js"
  * @category models
  */
 export interface BackingRunner<I, O> {
-  readonly queue: Queue.Dequeue<readonly [portId: number, message: I]>
+  readonly run: <A, E, R>(
+    handler: (portId: number, message: I) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<never, E | WorkerError, R>
   readonly send: (
     portId: number,
     message: O,
@@ -55,9 +56,7 @@ export type PlatformRunnerTypeId = typeof PlatformRunnerTypeId
  */
 export interface PlatformRunner {
   readonly [PlatformRunnerTypeId]: PlatformRunnerTypeId
-  readonly start: <I, O>(
-    shutdown: Effect.Effect<void>
-  ) => Effect.Effect<BackingRunner<I, O>, WorkerError, Scope.Scope>
+  readonly start: <I, O>() => Effect.Effect<BackingRunner<I, O>, WorkerError>
 }
 
 /**
@@ -87,18 +86,26 @@ export declare namespace Runner {
       request: I,
       error: E
     ) => Effect.Effect<unknown, WorkerError>
-    readonly transfers?: (message: O | E) => ReadonlyArray<unknown>
   }
 }
 
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const run: <I, E, R, O>(
+  process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
+  options?: Runner.Options<I, O, E>
+) => Effect.Effect<never, WorkerError, PlatformRunner | R> = internal.run
+
 /**
  * @since 1.0.0
  * @category constructors
  */
 export const make: <I, E, R, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: Runner.Options<I, O, E> | undefined
-) => Effect.Effect<void, WorkerError, Scope.Scope | R | PlatformRunner> = internal.make
+  options?: Runner.Options<I, O, E>
+) => Effect.Effect<void, WorkerError, PlatformRunner | R | Scope.Scope> = internal.make
 
 /**
  * @since 1.0.0

package/src/internal/httpClient.ts

@@ -128,7 +128,7 @@ export const makeDefault = (
         const addAbort = Scope.addFinalizer(scope, Effect.sync(() => controller.abort()))
         const urlResult = UrlParams.makeUrl(request.url, request.urlParams, request.hash)
         if (urlResult._tag === "Left") {
-          return Effect.fail(new Error.RequestError({ request, reason: "InvalidUrl", error: urlResult.left }))
+          return Effect.fail(new Error.RequestError({ request, reason: "InvalidUrl", cause: urlResult.left }))
         }
         const url = urlResult.right
         const tracerDisabled = !fiber.getFiberRef(FiberRef.currentTracerEnabled) ||
@@ -211,11 +211,11 @@ export const fetch: Client.HttpClient.Default = makeDefault((request, url, signa
             duplex: request.body._tag === "Stream" ? "half" : undefined,
             signal
           } as any),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request,
             reason: "Transport",
-            error
+            cause
           })
       }),
       (response) => internalResponse.fromWeb(request, response)
@@ -276,7 +276,7 @@ export const filterStatus = dual<
           request,
           response,
           reason: "StatusCode",
-          error: "invalid status code"
+          description: "invalid status code"
         })
     )))
 
@@ -293,7 +293,7 @@ export const filterStatusOk = <E, R>(
           request,
           response,
           reason: "StatusCode",
-          error: "non 2xx status code"
+          description: "non 2xx status code"
         })
     ))
 
@@ -675,11 +675,11 @@ export const schemaFunction = dual<
     Effect.flatMap(
       Effect.tryMap(encode(a), {
         try: (body) => new TextEncoder().encode(JSON.stringify(body)),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request,
             reason: "Encode",
-            error
+            cause
           })
       }),
       (body) =>

package/src/internal/httpClientResponse.ts

@@ -67,19 +67,19 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
 
   get stream(): Stream.Stream<Uint8Array, Error.ResponseError> {
     return this.source.body
-      ? Stream.fromReadableStream(() => this.source.body!, (_) =>
+      ? Stream.fromReadableStream(() => this.source.body!, (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         }))
       : Stream.fail(
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "EmptyBody",
-          error: "can not create stream from empty body"
+          description: "can not create stream from empty body"
         })
       )
   }
@@ -87,12 +87,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
   get json(): Effect.Effect<unknown, Error.ResponseError> {
     return Effect.tryMap(this.text, {
       try: (text) => text === "" ? null : JSON.parse(text) as unknown,
-      catch: (_) =>
+      catch: (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         })
     })
   }
@@ -101,12 +101,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
   get text(): Effect.Effect<string, Error.ResponseError> {
     return this.textBody ??= Effect.tryPromise({
       try: () => this.source.text(),
-      catch: (_) =>
+      catch: (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         })
     }).pipe(Effect.cached, Effect.runSync)
   }
@@ -115,12 +115,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
     return Effect.flatMap(this.text, (_) =>
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
-        catch: (_) =>
+        catch: (cause) =>
           new Error.ResponseError({
             request: this.request,
             response: this,
             reason: "Decode",
-            error: _
+            cause
           })
       }))
   }
@@ -129,12 +129,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
   get formData(): Effect.Effect<FormData, Error.ResponseError> {
     return this.formDataBody ??= Effect.tryPromise({
       try: () => this.source.formData(),
-      catch: (_) =>
+      catch: (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         })
     }).pipe(Effect.cached, Effect.runSync)
   }
@@ -143,12 +143,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
   get arrayBuffer(): Effect.Effect<ArrayBuffer, Error.ResponseError> {
     return this.arrayBufferBody ??= Effect.tryPromise({
       try: () => this.source.arrayBuffer(),
-      catch: (_) =>
+      catch: (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         })
     }).pipe(Effect.cached, Effect.runSync)
   }