effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/unstable/http/HttpClientRequest.ts

@@ -6,6 +6,7 @@ import type * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
 import * as Inspectable from "../../Inspectable.ts"
 import { stringOrRedacted } from "../../internal/redacted.ts"
+import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import type * as PlatformError from "../../PlatformError.ts"
 import { hasProperty } from "../../Predicate.ts"
@@ -14,10 +15,11 @@ import type * as Redacted from "../../Redacted.ts"
 import * as Result from "../../Result.ts"
 import type * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
-import type * as Stream from "../../Stream.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
+import * as Stream from "../../Stream.ts"
 import * as Headers from "./Headers.ts"
 import * as HttpBody from "./HttpBody.ts"
-import type { HttpMethod } from "./HttpMethod.ts"
+import { hasBody, type HttpMethod } from "./HttpMethod.ts"
 import * as UrlParams from "./UrlParams.ts"
 
 const TypeId = "~effect/http/HttpClientRequest"
@@ -37,7 +39,7 @@ export interface HttpClientRequest extends Inspectable.Inspectable, Pipeable {
   readonly method: HttpMethod
   readonly url: string
   readonly urlParams: UrlParams.UrlParams
-  readonly hash: string | undefined
+  readonly hash: Option.Option<string>
   readonly headers: Headers.Headers
   readonly body: HttpBody.HttpBody
 }
@@ -61,12 +63,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
@@ -93,11 +89,15 @@ const Proto = {
   }
 }
 
-function makeProto(
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export function makeWith(
   method: HttpMethod,
   url: string,
   urlParams: UrlParams.UrlParams,
-  hash: string | undefined,
+  hash: Option.Option<string>,
   headers: Headers.Headers,
   body: HttpBody.HttpBody
 ): HttpClientRequest {
@@ -115,11 +115,11 @@ function makeProto(
  * @since 4.0.0
  * @category constructors
  */
-export const empty: HttpClientRequest = makeProto(
+export const empty: HttpClientRequest = makeWith(
   "GET",
   "",
   UrlParams.empty,
-  undefined,
+  Option.none(),
   Headers.empty,
   HttpBody.empty
 )
@@ -133,7 +133,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 +145,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 +165,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
@@ -247,7 +257,7 @@ export const setMethod: {
 } = dual(
   2,
   (self: HttpClientRequest, method: HttpMethod): HttpClientRequest =>
-    makeProto(method, self.url, self.urlParams, self.hash, self.headers, self.body)
+    makeWith(method, self.url, self.urlParams, self.hash, self.headers, self.body)
 )
 
 /**
@@ -266,7 +276,7 @@ export const setHeader: {
    */
   (self: HttpClientRequest, key: string, value: string): HttpClientRequest
 } = dual(3, (self: HttpClientRequest, key: string, value: string): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     self.url,
     self.urlParams,
@@ -291,7 +301,7 @@ export const setHeaders: {
    */
   (self: HttpClientRequest, input: Headers.Input): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, input: Headers.Input): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     self.url,
     self.urlParams,
@@ -390,7 +400,7 @@ export const setUrl: {
   (self: HttpClientRequest, url: string | URL): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, url: string | URL): HttpClientRequest => {
   if (typeof url === "string") {
-    return makeProto(
+    return makeWith(
       self.method,
       url,
       self.urlParams,
@@ -401,10 +411,10 @@ export const setUrl: {
   }
   const clone = new URL(url.toString())
   const urlParams = UrlParams.fromInput(clone.searchParams)
-  const hash = clone.hash ? clone.hash.slice(1) : undefined
+  const hash = Option.fromNullishOr(clone.hash === "" ? undefined : clone.hash.slice(1))
   clone.search = ""
   clone.hash = ""
-  return makeProto(
+  return makeWith(
     self.method,
     clone.toString(),
     urlParams,
@@ -431,7 +441,7 @@ export const prependUrl: {
   (self: HttpClientRequest, path: string): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, path: string): HttpClientRequest => {
   if (path === "") return self
-  return makeProto(
+  return makeWith(
     self.method,
     joinSegments(path, self.url),
     self.urlParams,
@@ -458,7 +468,7 @@ export const appendUrl: {
   (self: HttpClientRequest, path: string): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, path: string): HttpClientRequest => {
   if (path === "") return self
-  return makeProto(
+  return makeWith(
     self.method,
     joinSegments(self.url, path),
     self.urlParams,
@@ -496,7 +506,7 @@ export const updateUrl: {
    */
   (self: HttpClientRequest, f: (url: string) => string): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, f: (url: string) => string): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     f(self.url),
     self.urlParams,
@@ -521,7 +531,7 @@ export const setUrlParam: {
    */
   (self: HttpClientRequest, key: string, value: string): HttpClientRequest
 } = dual(3, (self: HttpClientRequest, key: string, value: string): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     self.url,
     UrlParams.set(self.urlParams, key, value),
@@ -546,7 +556,7 @@ export const setUrlParams: {
    */
   (self: HttpClientRequest, input: UrlParams.Input): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, input: UrlParams.Input): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     self.url,
     UrlParams.setAll(self.urlParams, input),
@@ -571,7 +581,7 @@ export const appendUrlParam: {
    */
   (self: HttpClientRequest, key: string, value: string): HttpClientRequest
 } = dual(3, (self: HttpClientRequest, key: string, value: string): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     self.url,
     UrlParams.append(self.urlParams, key, value),
@@ -596,7 +606,7 @@ export const appendUrlParams: {
    */
   (self: HttpClientRequest, input: UrlParams.Input): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, input: UrlParams.Input): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     self.url,
     UrlParams.appendAll(self.urlParams, input),
@@ -621,11 +631,11 @@ export const setHash: {
    */
   (self: HttpClientRequest, hash: string): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, hash: string): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     self.url,
     self.urlParams,
-    hash,
+    Option.some(hash),
     self.headers,
     self.body
   ))
@@ -635,11 +645,11 @@ export const setHash: {
  * @category combinators
  */
 export const removeHash = (self: HttpClientRequest): HttpClientRequest =>
-  makeProto(
+  makeWith(
     self.method,
     self.url,
     self.urlParams,
-    undefined,
+    Option.none(),
     self.headers,
     self.body
   )
@@ -671,7 +681,7 @@ export const setBody: {
       headers = Headers.set(headers, "content-length", body.contentLength.toString())
     }
   }
-  return makeProto(
+  return makeWith(
     self.method,
     self.url,
     self.urlParams,
@@ -938,9 +948,111 @@ export const bodyFile: {
  * @since 4.0.0
  * @category combinators
  */
-export function toUrl(self: HttpClientRequest): URL | undefined {
-  const r = UrlParams.makeUrl(self.url, self.urlParams, self.hash)
+export function toUrl(self: HttpClientRequest): Option.Option<URL> {
+  const r = UrlParams.makeUrl(self.url, self.urlParams, Option.getOrUndefined(self.hash))
   if (Result.isSuccess(r)) {
-    return r.success
+    return Option.some(r.success)
   }
+  return Option.none()
+}
+
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const fromWeb = (request: globalThis.Request): HttpClientRequest => {
+  const method = request.method.toUpperCase() as HttpMethod
+  return modify(empty, {
+    method,
+    url: new URL(request.url),
+    headers: request.headers,
+    body: fromWebBody(request, method)
+  })
 }
+
+const fromWebBody = (request: globalThis.Request, method: HttpMethod): HttpBody.HttpBody => {
+  if (!hasBody(method) || request.body === null) {
+    return HttpBody.empty
+  }
+  return HttpBody.raw(request.body, {
+    contentType: request.headers.get("content-type") ?? undefined,
+    contentLength: parseContentLength(request.headers.get("content-length"))
+  })
+}
+
+const parseContentLength = (contentLength: string | null): number | undefined => {
+  if (contentLength === null) {
+    return undefined
+  }
+  const parsed = Number.parseInt(contentLength, 10)
+  return Number.isNaN(parsed) ? undefined : parsed
+}
+
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const toWebResult = (self: HttpClientRequest, options?: {
+  readonly signal?: AbortSignal | undefined
+  readonly services?: ServiceMap.ServiceMap<never> | undefined
+}): Result.Result<Request, UrlParams.UrlParamsError> => {
+  const url = UrlParams.makeUrl(self.url, self.urlParams, Option.getOrUndefined(self.hash))
+  if (Result.isFailure(url)) {
+    return Result.fail(url.failure)
+  }
+  const requestInit: RequestInit = {
+    method: self.method,
+    headers: self.headers
+  }
+  if (options?.signal) {
+    requestInit.signal = options.signal
+  }
+  if (hasBody(self.method)) {
+    switch (self.body._tag) {
+      case "Empty": {
+        break
+      }
+      case "Raw": {
+        requestInit.body = self.body.body as any
+        if (isReadableStream(self.body.body)) {
+          ;(requestInit as any).duplex = "half"
+        }
+        break
+      }
+      case "Uint8Array": {
+        requestInit.body = self.body.body as any
+        break
+      }
+      case "FormData": {
+        requestInit.body = self.body.formData
+        break
+      }
+      case "Stream": {
+        requestInit.body = Stream.toReadableStreamWith(self.body.stream, options?.services ?? ServiceMap.empty())
+        ;(requestInit as any).duplex = "half"
+        break
+      }
+    }
+  }
+  return Result.try({
+    try: () => new Request(url.success, requestInit),
+    catch: (cause) => new UrlParams.UrlParamsError({ cause })
+  })
+}
+
+const isReadableStream = (u: unknown): u is ReadableStream<Uint8Array> =>
+  typeof ReadableStream !== "undefined" && u instanceof ReadableStream
+
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const toWeb = (self: HttpClientRequest, options?: {
+  readonly signal?: AbortSignal | undefined
+}): Effect.Effect<Request, UrlParams.UrlParamsError> =>
+  Effect.servicesWith((services) =>
+    toWebResult(self, {
+      services,
+      signal: options?.signal
+    }).asEffect()
+  )

package/src/unstable/http/HttpClientResponse.ts

@@ -4,6 +4,8 @@
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
 import * as Inspectable from "../../Inspectable.ts"
+import * as Option from "../../Option.ts"
+import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
 import * as Stream from "../../Stream.ts"
@@ -43,7 +45,7 @@ export const TypeId = "~effect/http/HttpClientResponse"
  * @since 4.0.0
  * @category models
  */
-export interface HttpClientResponse extends HttpIncomingMessage.HttpIncomingMessage<Error.HttpClientError> {
+export interface HttpClientResponse extends HttpIncomingMessage.HttpIncomingMessage<Error.HttpClientError>, Pipeable {
   readonly [TypeId]: typeof TypeId
   readonly request: HttpClientRequest.HttpClientRequest
   readonly status: number
@@ -227,7 +229,7 @@ export const filterStatusOk = (self: HttpClientResponse): Effect.Effect<HttpClie
 // internal
 // -----------------------------------------------------------------------------
 
-class WebHttpClientResponse extends Inspectable.Class implements HttpClientResponse {
+class WebHttpClientResponse extends Inspectable.Class implements HttpClientResponse, Pipeable {
   readonly [HttpIncomingMessage.TypeId]: typeof HttpIncomingMessage.TypeId
   readonly [TypeId]: typeof TypeId
 
@@ -269,8 +271,8 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
     return this.cachedCookies = Cookies.fromSetCookie(this.source.headers.getSetCookie())
   }
 
-  get remoteAddress(): string | undefined {
-    return undefined
+  get remoteAddress(): Option.Option<string> {
+    return Option.none()
   }
 
   get stream(): Stream.Stream<Uint8Array, Error.HttpClientError> {
@@ -297,10 +299,10 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
       )
   }
 
-  get json(): Effect.Effect<unknown, Error.HttpClientError> {
+  get json(): Effect.Effect<Schema.Json, Error.HttpClientError> {
     return Effect.flatMap(this.text, (text) =>
       Effect.try({
-        try: () => text === "" ? null : JSON.parse(text) as unknown,
+        try: () => text === "" ? null : JSON.parse(text),
         catch: (cause) =>
           new Error.HttpClientError({
             reason: new Error.DecodeError({
@@ -371,4 +373,8 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
         })
     }).pipe(Effect.cached, Effect.runSync)
   }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }

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,30 +163,24 @@ 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
   })
 
+export {
+  /**
+   * @since 4.0.0
+   * @category fiber refs
+   */
+  appendPreResponseHandlerUnsafe
+}
+
 /**
  * @since 4.0.0
  * @category fiber refs
@@ -199,33 +190,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 +248,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/HttpIncomingMessage.ts

@@ -4,6 +4,7 @@
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import type * as Inspectable from "../../Inspectable.ts"
+import type * as Option from "../../Option.ts"
 import { hasProperty } from "../../Predicate.ts"
 import { redact } from "../../Redactable.ts"
 import * as Schema from "../../Schema.ts"
@@ -32,8 +33,8 @@ export const isHttpIncomingMessage = (u: unknown): u is HttpIncomingMessage => h
 export interface HttpIncomingMessage<E = unknown> extends Inspectable.Inspectable {
   readonly [TypeId]: typeof TypeId
   readonly headers: Headers.Headers
-  readonly remoteAddress: string | undefined
-  readonly json: Effect.Effect<unknown, E>
+  readonly remoteAddress: Option.Option<string>
+  readonly json: Effect.Effect<Schema.Json, E>
   readonly text: Effect.Effect<string, E>
   readonly urlParamsBody: Effect.Effect<UrlParams.UrlParams, E>
   readonly arrayBuffer: Effect.Effect<ArrayBuffer, E>