effect 4.0.0-beta.2 → 4.0.0-beta.21

package/src/unstable/http/HttpClient.ts

@@ -61,11 +61,11 @@ export declare namespace HttpClient {
 
     readonly get: (
       url: string | URL,
-      options?: HttpClientRequest.Options.NoBody
+      options?: HttpClientRequest.Options.NoUrl
     ) => Effect.Effect<HttpClientResponse.HttpClientResponse, E, R>
     readonly head: (
       url: string | URL,
-      options?: HttpClientRequest.Options.NoBody
+      options?: HttpClientRequest.Options.NoUrl
     ) => Effect.Effect<HttpClientResponse.HttpClientResponse, E, R>
     readonly post: (
       url: string | URL,
@@ -132,7 +132,7 @@ export const execute: (
  * @since 4.0.0
  * @category accessors
  */
-export const get: (url: string | URL, options?: HttpClientRequest.Options.NoBody | undefined) => Effect.Effect<
+export const get: (url: string | URL, options?: HttpClientRequest.Options.NoUrl | undefined) => Effect.Effect<
   HttpClientResponse.HttpClientResponse,
   Error.HttpClientError,
   HttpClient
@@ -142,7 +142,7 @@ export const get: (url: string | URL, options?: HttpClientRequest.Options.NoBody
  * @since 4.0.0
  * @category accessors
  */
-export const head: (url: string | URL, options?: HttpClientRequest.Options.NoBody | undefined) => Effect.Effect<
+export const head: (url: string | URL, options?: HttpClientRequest.Options.NoUrl | undefined) => Effect.Effect<
   HttpClientResponse.HttpClientResponse,
   Error.HttpClientError,
   HttpClient
@@ -928,7 +928,7 @@ export const retry: {
 /**
  * Retries common transient errors, such as rate limiting, timeouts or network issues.
  *
- * Use `mode` to focus on retrying errors, transient responses, or both.
+ * Use `retryOn` to focus on retrying errors, transient responses, or both.
  *
  * Specifying a `while` predicate allows you to consider other errors as
  * transient, and is ignored in "response-only" mode.
@@ -940,7 +940,7 @@ export const retryTransient: {
   /**
    * Retries common transient errors, such as rate limiting, timeouts or network issues.
    *
-   * Use `mode` to focus on retrying errors, transient responses, or both.
+   * Use `retryOn` to focus on retrying errors, transient responses, or both.
    *
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
@@ -949,26 +949,29 @@ export const retryTransient: {
    * @category error handling
    */
   <
-    B,
     E,
+    B = never,
     ES = never,
     R1 = never,
-    const Mode extends "errors-only" | "response-only" | "both" = never,
-    Input = "errors-only" extends Mode ? E
-      : "response-only" extends Mode ? HttpClientResponse.HttpClientResponse
+    const RetryOn extends "errors-only" | "response-only" | "errors-and-responses" =
+      | "errors-only"
+      | "response-only"
+      | "errors-and-responses",
+    Input = RetryOn extends "errors-only" ? E
+      : RetryOn extends "response-only" ? HttpClientResponse.HttpClientResponse
       : HttpClientResponse.HttpClientResponse | E
   >(
     options: {
-      readonly mode?: Mode | undefined
+      readonly retryOn?: RetryOn | undefined
       readonly while?: Predicate.Predicate<NoInfer<E | ES>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<Input>, ES, R1>
       readonly times?: number
-    } | Schedule.Schedule<B, NoInfer<Input>, ES, R1>
+    }
   ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E | ES, R1 | R>
   /**
    * Retries common transient errors, such as rate limiting, timeouts or network issues.
    *
-   * Use `mode` to focus on retrying errors, transient responses, or both.
+   * Use `retryOn` to focus on retrying errors, transient responses, or both.
    *
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
@@ -979,21 +982,53 @@ export const retryTransient: {
   <
     E,
     R,
-    B,
+    B = never,
     ES = never,
     R1 = never,
-    const Mode extends "errors-only" | "response-only" | "both" = never,
-    Input = "errors-only" extends Mode ? E
-      : "response-only" extends Mode ? HttpClientResponse.HttpClientResponse
+    const RetryOn extends "errors-only" | "response-only" | "errors-and-responses" =
+      | "errors-only"
+      | "response-only"
+      | "errors-and-responses",
+    Input = RetryOn extends "errors-only" ? E
+      : RetryOn extends "response-only" ? HttpClientResponse.HttpClientResponse
       : HttpClientResponse.HttpClientResponse | E
   >(
     self: HttpClient.With<E, R>,
     options: {
-      readonly mode?: Mode | undefined
+      readonly retryOn?: RetryOn | undefined
       readonly while?: Predicate.Predicate<NoInfer<E | ES>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<Input>, ES, R1>
       readonly times?: number
-    } | Schedule.Schedule<B, NoInfer<Input>, ES, R1>
+    }
+  ): HttpClient.With<E | ES, R1 | R>
+  /**
+   * Retries common transient errors, such as rate limiting, timeouts or network issues.
+   *
+   * Use `retryOn` to focus on retrying errors, transient responses, or both.
+   *
+   * Specifying a `while` predicate allows you to consider other errors as
+   * transient, and is ignored in "response-only" mode.
+   *
+   * @since 4.0.0
+   * @category error handling
+   */
+  <B, E, ES = never, R1 = never>(
+    options: Schedule.Schedule<B, NoInfer<HttpClientResponse.HttpClientResponse | E>, ES, R1>
+  ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E | ES, R1 | R>
+  /**
+   * Retries common transient errors, such as rate limiting, timeouts or network issues.
+   *
+   * Use `retryOn` to focus on retrying errors, transient responses, or both.
+   *
+   * Specifying a `while` predicate allows you to consider other errors as
+   * transient, and is ignored in "response-only" mode.
+   *
+   * @since 4.0.0
+   * @category error handling
+   */
+  <E, R, B, ES = never, R1 = never>(
+    self: HttpClient.With<E, R>,
+    options: Schedule.Schedule<B, NoInfer<HttpClientResponse.HttpClientResponse | E>, ES, R1>
   ): HttpClient.With<E | ES, R1 | R>
 } = dual(
   2,
@@ -1006,26 +1041,26 @@ export const retryTransient: {
   >(
     self: HttpClient.With<E, R>,
     options: {
-      readonly mode?: "errors-only" | "response-only" | "both" | undefined
+      readonly retryOn?: "errors-only" | "response-only" | "errors-and-responses" | undefined
       readonly while?: Predicate.Predicate<E | ES>
       readonly schedule?: Schedule.Schedule<B, any, ES, R1>
       readonly times?: number
     } | Schedule.Schedule<B, any, ES, R1>
   ): HttpClient.With<E | ES, R1 | R> => {
     const isOnlySchedule = Schedule.isSchedule(options)
-    const mode = isOnlySchedule ? "both" : options.mode ?? "both"
+    const retryOn = isOnlySchedule ? "errors-and-responses" : options.retryOn ?? "errors-and-responses"
     const schedule = isOnlySchedule ? options : options.schedule
     const passthroughSchedule = schedule && Schedule.passthrough(schedule)
     const times = isOnlySchedule ? undefined : options.times
     return transformResponse(
       self,
       flow(
-        mode === "errors-only" ? identity : Effect.repeat({
+        retryOn === "errors-only" ? identity : Effect.repeat({
           schedule: passthroughSchedule!,
           times,
           while: isTransientResponse
         }),
-        mode === "response-only" ? identity : Effect.retry({
+        retryOn === "response-only" ? identity : Effect.retry({
           while: isOnlySchedule || options.while === undefined
             ? isTransientError
             : Predicate.or(isTransientError, options.while),

package/src/unstable/http/HttpClientRequest.ts

@@ -61,12 +61,6 @@ export interface Options {
  * @since 4.0.0
  */
 export declare namespace Options {
-  /**
-   * @since 4.0.0
-   * @category models
-   */
-  export interface NoBody extends Omit<Options, "method" | "url" | "body"> {}
-
   /**
    * @since 4.0.0
    * @category models
@@ -133,7 +127,7 @@ export const make = <M extends HttpMethod>(
 ) =>
 (
   url: string | URL,
-  options?: (M extends "GET" | "HEAD" ? Options.NoBody : Options.NoUrl) | undefined
+  options?: Options.NoUrl | undefined
 ): HttpClientRequest =>
   modify(empty, {
     method,
@@ -145,7 +139,7 @@ export const make = <M extends HttpMethod>(
  * @since 4.0.0
  * @category constructors
  */
-export const get: (url: string | URL, options?: Options.NoBody) => HttpClientRequest = make("GET")
+export const get: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("GET")
 
 /**
  * @since 4.0.0
@@ -165,23 +159,33 @@ export const patch: (url: string | URL, options?: Options.NoUrl) => HttpClientRe
  */
 export const put: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("PUT")
 
+const del: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("DELETE")
+
+export {
+  /**
+   * @since 4.0.0
+   * @category constructors
+   */
+  del as delete
+}
+
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const del: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("DELETE")
+export const head: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("HEAD")
 
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const head: (url: string | URL, options?: Options.NoBody) => HttpClientRequest = make("HEAD")
+export const options: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("OPTIONS")
 
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const options: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("OPTIONS")
+export const trace: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("TRACE")
 
 /**
  * @since 4.0.0
@@ -661,7 +665,7 @@ export const setBody: {
   (self: HttpClientRequest, body: HttpBody.HttpBody): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, body: HttpBody.HttpBody): HttpClientRequest => {
   let headers = self.headers
-  if (body._tag === "Empty") {
+  if (body._tag === "Empty" || body._tag === "FormData") {
     headers = Headers.remove(Headers.remove(headers, "Content-Type"), "Content-length")
   } else {
     if (body.contentType) {
@@ -826,7 +830,28 @@ export const bodyFormData: {
    * @category combinators
    */
   (self: HttpClientRequest, body: FormData): HttpClientRequest
-} = dual(2, (self: HttpClientRequest, body: FormData): HttpClientRequest => setBody(self, HttpBody.makeFormData(body)))
+} = dual(2, (self: HttpClientRequest, body: FormData): HttpClientRequest => setBody(self, HttpBody.formData(body)))
+
+/**
+ * @since 4.0.0
+ * @category combinators
+ */
+export const bodyFormDataRecord: {
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (entries: HttpBody.FormDataInput): (self: HttpClientRequest) => HttpClientRequest
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: HttpClientRequest, entries: HttpBody.FormDataInput): HttpClientRequest
+} = dual(
+  2,
+  (self: HttpClientRequest, entries: HttpBody.FormDataInput): HttpClientRequest =>
+    setBody(self, HttpBody.formDataRecord(entries))
+)
 
 /**
  * @since 4.0.0

package/src/unstable/http/HttpEffect.ts

@@ -1,24 +1,24 @@
 /**
  * @since 4.0.0
  */
-import type { Cause } from "../../Cause.ts"
+import type * as Cause from "../../Cause.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { dual } from "../../Function.ts"
-import { effectIsExit } from "../../internal/effect.ts"
+import { reportCauseUnsafe } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as HttpBody from "./HttpBody.ts"
 import { type HttpMiddleware, tracer } from "./HttpMiddleware.ts"
-import { causeResponse, clientAbortFiberId, HttpServerError, InternalError } from "./HttpServerError.ts"
+import { causeResponse, ClientAbort, HttpServerError, InternalError } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as Response from "./HttpServerResponse.ts"
+import { appendPreResponseHandlerUnsafe, requestPreResponseHandlers } from "./internal/preResponseHandler.ts"
 
 /**
  * @since 4.0.0
@@ -32,35 +32,12 @@ export const toHandled = <E, R, EH, RH>(
   ) => Effect.Effect<unknown, EH, RH>,
   middleware?: HttpMiddleware | undefined
 ): Effect.Effect<void, never, Exclude<R | RH | HttpServerRequest, Scope.Scope>> => {
-  const responded = Effect.flatMap(self, (response) => {
-    const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-    const handler = fiber.getRef(PreResponseHandlers)
-    if (handler === undefined) {
-      ;(request as any)[handledSymbol] = true
-      const eff = handleResponse(request, response)
-      if (effectIsExit(eff)) {
-        return eff._tag === "Success" ? Effect.succeed(response) : handleCause(eff.cause)
-      }
-      return Effect.matchCauseEffect(eff, {
-        onFailure: handleCause,
-        onSuccess: () => Effect.succeed(response)
-      })
-    }
-    return Effect.flatMapEager(handler(request, response), (sentResponse) => {
-      ;(request as any)[handledSymbol] = true
-      return Effect.matchCauseEffectEager(handleResponse(request, sentResponse), {
-        onSuccess: () => Effect.succeed(response),
-        onFailure: handleCause
-      })
-    })
-  })
-
-  const handleCause = (cause: Cause<E | EH | HttpServerError>) =>
+  const handleCause = (cause: Cause.Cause<E | EH | HttpServerError>) =>
     Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
+      reportCauseUnsafe(fiber, cause)
       const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-      const handler = fiber.getRef(PreResponseHandlers)
+      const handler = requestPreResponseHandlers.get(request.source)
       const cont = cause.reasons.length === 0 ? Effect.succeed(response) : Effect.failCause(cause)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
@@ -79,6 +56,23 @@ export const toHandled = <E, R, EH, RH>(
       )
     })
 
+  const responded = Effect.matchCauseEffect(self, {
+    onSuccess: (response) => {
+      const fiber = Fiber.getCurrent()!
+      const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+      const handler = requestPreResponseHandlers.get(request.source)
+      if (handler === undefined) {
+        ;(request as any)[handledSymbol] = true
+        return Effect.mapEager(handleResponse(request, response), () => response)
+      }
+      return Effect.flatMapEager(handler(request, response), (sentResponse) => {
+        ;(request as any)[handledSymbol] = true
+        return Effect.mapEager(handleResponse(request, sentResponse), () => response)
+      })
+    },
+    onFailure: handleCause
+  })
+
   const withMiddleware: Effect.Effect<
     unknown,
     E | EH | HttpServerError,
@@ -88,13 +82,16 @@ export const toHandled = <E, R, EH, RH>(
     Effect.matchCauseEffect(tracer(middleware(responded)), {
       onFailure(cause): Effect.Effect<void, EH, RH> {
         const fiber = Fiber.getCurrent()!
+        reportCauseUnsafe(fiber, cause)
         const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-        if (handledSymbol in request) {
-          return Effect.void
-        }
+        if (handledSymbol in request) return Effect.void
         return Effect.matchCauseEffectEager(causeResponse(cause), {
-          onFailure: (_cause) => handleResponse(request, Response.empty({ status: 500 })),
-          onSuccess: ([response]) => handleResponse(request, response)
+          onFailure(_) {
+            return handleResponse(request, Response.empty({ status: 500 }))
+          },
+          onSuccess([response]) {
+            return handleResponse(request, response)
+          }
         })
       },
       onSuccess(response): Effect.Effect<void, EH, RH> {
@@ -148,10 +145,10 @@ const scopeEjected = Symbol.for("effect/http/HttpEffect/scopeEjected")
 const scoped = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
   Effect.withFiber((fiber) => {
     const scope = Scope.makeUnsafe()
-    const prev = ServiceMap.getOption(fiber.services, Scope.Scope)
+    const prevServices = fiber.services
     fiber.setServices(ServiceMap.add(fiber.services, Scope.Scope, scope))
     return Effect.onExitPrimitive(effect, (exit) => {
-      fiber.setServices(ServiceMap.addOrOmit(fiber.services, Scope.Scope, prev))
+      fiber.setServices(prevServices)
       if (scopeEjected in scope) return undefined
       return Scope.closeUnsafe(scope, exit)
     }, true)
@@ -166,27 +163,13 @@ export type PreResponseHandler = (
   response: HttpServerResponse
 ) => Effect.Effect<HttpServerResponse, HttpServerError>
 
-/**
- * @since 4.0.0
- * @category Pre-response handlers
- */
-export const PreResponseHandlers = ServiceMap.Reference<PreResponseHandler | undefined>(
-  "effect/http/HttpEffect/PreResponseHandlers",
-  { defaultValue: () => undefined }
-)
-
 /**
  * @since 4.0.0
  * @category fiber refs
  */
-export const appendPreResponseHandler = (handler: PreResponseHandler): Effect.Effect<void> =>
-  Effect.withFiber((fiber) => {
-    const next = UndefinedOr.match(fiber.getRef(PreResponseHandlers), {
-      onUndefined: () => handler,
-      onDefined: (prev) => (request, response) =>
-        Effect.flatMap(prev(request, response), (response) => handler(request, response))
-    })
-    fiber.setServices(ServiceMap.add(fiber.services, PreResponseHandlers, next))
+export const appendPreResponseHandler = (handler: PreResponseHandler): Effect.Effect<void, never, HttpServerRequest> =>
+  HttpServerRequest.use((request) => {
+    appendPreResponseHandlerUnsafe(request, handler)
     return Effect.void
   })
 
@@ -199,33 +182,28 @@ export const withPreResponseHandler: {
    * @since 4.0.0
    * @category fiber refs
    */
-  (handler: PreResponseHandler): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  (handler: PreResponseHandler): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler): Effect.Effect<A, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler): Effect.Effect<A, E, R | HttpServerRequest>
 } = dual<
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  (handler: PreResponseHandler) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  (handler: PreResponseHandler) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>,
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler) => Effect.Effect<A, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler) => Effect.Effect<A, E, R | HttpServerRequest>
 >(2, (self, handler) =>
-  Effect.updateService(
-    self,
-    PreResponseHandlers,
-    UndefinedOr.match({
-      onUndefined: () => handler,
-      onDefined: (prev) => (request, response) =>
-        Effect.flatMap(prev(request, response), (response) => handler(request, response))
-    })
-  ))
+  HttpServerRequest.use((request) => {
+    appendPreResponseHandlerUnsafe(request, handler)
+    return self
+  }))
 
 /**
  * @since 4.0.0
@@ -262,7 +240,7 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
       ;(httpServerRequest as any)[resolveSymbol] = resolve
       const fiber = Effect.runForkWith(ServiceMap.makeUnsafe(contextMap))(httpApp as any)
       request.signal?.addEventListener("abort", () => {
-        fiber.interruptUnsafe(clientAbortFiberId)
+        fiber.interruptUnsafe(undefined, ClientAbort.annotation)
       }, { once: true })
     })
 }

package/src/unstable/http/HttpMethod.ts

@@ -14,6 +14,7 @@ export type HttpMethod =
   | "PATCH"
   | "HEAD"
   | "OPTIONS"
+  | "TRACE"
 
 /**
  * @since 4.0.0
@@ -24,7 +25,7 @@ export declare namespace HttpMethod {
    * @since 4.0.0
    * @category models
    */
-  export type NoBody = "GET" | "HEAD" | "OPTIONS"
+  export type NoBody = "GET" | "HEAD" | "OPTIONS" | "TRACE"
 
   /**
    * @since 4.0.0
@@ -36,12 +37,22 @@ export declare namespace HttpMethod {
 /**
  * @since 4.0.0
  */
-export const hasBody = (method: HttpMethod): boolean => method !== "GET" && method !== "HEAD" && method !== "OPTIONS"
+export const hasBody = (method: HttpMethod): method is HttpMethod.WithBody =>
+  method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE"
 
 /**
  * @since 4.0.0
  */
-export const all: ReadonlySet<HttpMethod> = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+export const all: ReadonlySet<HttpMethod> = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "TRACE"
+])
 
 /**
  * @since 4.0.0
@@ -53,7 +64,8 @@ export const allShort = [
   ["DELETE", "del"],
   ["PATCH", "patch"],
   ["HEAD", "head"],
-  ["OPTIONS", "options"]
+  ["OPTIONS", "options"],
+  ["TRACE", "trace"]
 ] as const
 
 /**

package/src/unstable/http/HttpMiddleware.ts

@@ -12,13 +12,13 @@ import { TracerEnabled } from "../../References.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import { ParentSpan } from "../../Tracer.ts"
 import * as Headers from "./Headers.ts"
-import type { PreResponseHandler } from "./HttpEffect.ts"
 import { causeResponseStripped, exitResponse } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import * as Response from "./HttpServerResponse.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
+import { appendPreResponseHandlerUnsafe } from "./internal/preResponseHandler.ts"
 
 /**
  * @since 4.0.0
@@ -46,21 +46,16 @@ export declare namespace HttpMiddleware {
  */
 export const make = <M extends HttpMiddleware>(middleware: M): M => middleware
 
-/**
- * @since 4.0.0
- * @category Logger
- */
-export const LoggerDisabled = ServiceMap.Reference<boolean>("effect/http/HttpMiddleware/LoggerDisabled", {
-  defaultValue: constFalse
-})
+const loggerDisabledRequests = new WeakSet<object>()
 
 /**
  * @since 4.0.0
  * @category Logger
  */
-export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | HttpServerRequest> =>
   Effect.withFiber((fiber) => {
-    fiber.setServices(ServiceMap.add(fiber.services, LoggerDisabled, true))
+    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    loggerDisabledRequests.add(request.source)
     return self
   })
 
@@ -102,7 +97,7 @@ export const logger: <E, R>(
     const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
     return Effect.withLogSpan(
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
-        if (fiber.getRef(LoggerDisabled)) {
+        if (loggerDisabledRequests.has(request.source)) {
           return exit
         } else if (exit._tag === "Failure") {
           const [response, cause] = causeResponseStripped(exit.cause)
@@ -147,10 +142,10 @@ export const tracer: <E, R>(
       parent: TraceContext.fromHeaders(request.headers),
       kind: "server"
     })
-    const prevSpan = ServiceMap.getOption(fiber.services, ParentSpan)
+    const prevServices = fiber.services
     fiber.setServices(ServiceMap.add(fiber.services, ParentSpan, span))
     return Effect.onExitPrimitive(httpApp, (exit) => {
-      fiber.setServices(ServiceMap.addOrOmit(fiber.services, ParentSpan, prevSpan))
+      fiber.setServices(prevServices)
       const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe()
       fiber.currentScheduler.scheduleTask(() => {
         const url = Request.toURL(request)
@@ -343,17 +338,7 @@ export const cors = (options?: {
           headers: headersFromRequestOptions(request)
         }))
       }
-      const prev = fiber.getRef(PreResponseHandlers)
-      const next = prev
-        ? ((req: HttpServerRequest, res: HttpServerResponse) =>
-          Effect.flatMap(prev(req, res), (res) => preResponseHandler(req, res)))
-        : preResponseHandler
-      fiber.setServices(ServiceMap.add(fiber.services, PreResponseHandlers, next))
+      appendPreResponseHandlerUnsafe(request, preResponseHandler)
       return httpApp
     })
 }
-
-const PreResponseHandlers = ServiceMap.Reference<PreResponseHandler | undefined>(
-  "effect/http/HttpEffect/PreResponseHandlers",
-  { defaultValue: () => undefined }
-)