effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/unstable/http/HttpClient.ts

@@ -348,9 +348,9 @@ const catch_: {
   <E, E2, R2>(
     f: (e: E) => Effect.Effect<HttpClientResponse.HttpClientResponse, E2, R2>
   ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E2, R2 | R>
-  <E, R, A2, E2, R2>(
+  <E, R, E2, R2>(
     self: HttpClient.With<E, R>,
-    f: (e: E) => Effect.Effect<A2, E2, R2>
+    f: (e: E) => Effect.Effect<HttpClientResponse.HttpClientResponse, E2, R2>
   ): HttpClient.With<E2, R | R2>
 } = dual(
   2,
@@ -1976,36 +1976,43 @@ export const followRedirects: {
   makeWith(
     (request) => {
       const loop = (
-        request: HttpClientRequest.HttpClientRequest,
+        request: Effect.Effect<HttpClientRequest.HttpClientRequest, E, R>,
         redirects: number
       ): Effect.Effect<HttpClientResponse.HttpClientResponse, E, R> =>
-        Effect.flatMap(
-          self.postprocess(Effect.succeed(request)),
-          (response) => {
-            if (
-              response.status < 300 || response.status >= 400 || !response.headers.location ||
-              redirects >= (maxRedirects ?? 10)
-            ) {
-              return Effect.succeed(response)
-            }
-            const url = new URL(response.headers.location, response.request.url)
-            let nextRequest = request
-            if (
-              ((response.status === 301 || response.status === 302) && request.method === "POST") ||
-              (response.status === 303 && request.method !== "GET" && request.method !== "HEAD")
-            ) {
-              nextRequest = HttpClientRequest.setMethod(nextRequest, "GET")
-              nextRequest = HttpClientRequest.setBody(nextRequest, HttpBody.empty)
-            }
-            if (url.origin !== new URL(response.request.url).origin) {
-              nextRequest = HttpClientRequest.removeHeader(nextRequest, "authorization")
-              nextRequest = HttpClientRequest.removeHeader(nextRequest, "proxy-authorization")
-              nextRequest = HttpClientRequest.removeHeader(nextRequest, "cookie")
+        Effect.suspend(() => {
+          let currentRequest: HttpClientRequest.HttpClientRequest | undefined
+          return Effect.flatMap(
+            self.postprocess(Effect.map(request, (request) => {
+              currentRequest = request
+              return request
+            })),
+            (response) => {
+              if (
+                response.status < 300 || response.status >= 400 || !response.headers.location ||
+                redirects >= (maxRedirects ?? 10)
+              ) {
+                return Effect.succeed(response)
+              }
+              const url = new URL(response.headers.location, response.request.url)
+              const request = currentRequest ?? response.request
+              let nextRequest = request
+              if (
+                ((response.status === 301 || response.status === 302) && request.method === "POST") ||
+                (response.status === 303 && request.method !== "GET" && request.method !== "HEAD")
+              ) {
+                nextRequest = HttpClientRequest.setMethod(nextRequest, "GET")
+                nextRequest = HttpClientRequest.setBody(nextRequest, HttpBody.empty)
+              }
+              if (url.origin !== new URL(response.request.url).origin) {
+                nextRequest = HttpClientRequest.removeHeader(nextRequest, "authorization")
+                nextRequest = HttpClientRequest.removeHeader(nextRequest, "proxy-authorization")
+                nextRequest = HttpClientRequest.removeHeader(nextRequest, "cookie")
+              }
+              return loop(Effect.succeed(HttpClientRequest.setUrl(nextRequest, url)), redirects + 1)
             }
-            return loop(HttpClientRequest.setUrl(nextRequest, url), redirects + 1)
-          }
-        )
-      return Effect.flatMap(request, (request) => loop(request, 0))
+          )
+        })
+      return loop(request, 0)
     },
     self.preprocess
   ))
@@ -2040,7 +2047,7 @@ export const TracerHeaderFilter = Context.Reference<
  * @category services
  * @since 4.0.0
  */
-export const TracerPropagationEnabled = Context.Reference<boolean>("effect/HttpClient/TracerPropagationEnabled", {
+export const TracerPropagationEnabled = Context.Reference<boolean>("effect/http/HttpClient/TracerPropagationEnabled", {
   defaultValue: constTrue
 })
 
@@ -2142,6 +2149,10 @@ class InterruptibleResponse implements HttpClientResponse.HttpClientResponse, Pi
     return this.original.request
   }
 
+  get url() {
+    return this.original.url
+  }
+
   get status() {
     return this.original.status
   }

package/src/unstable/http/HttpClientRequest.ts

@@ -9,6 +9,7 @@
  *
  * @since 4.0.0
  */
+import type * as ByteSize from "../../ByteSize.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
@@ -1168,6 +1169,13 @@ export const bodyStream: {
 /**
  * Creates a file-backed request body from a filesystem path and sets it on the request.
  *
+ * **Details**
+ *
+ * Uses {@link HttpBody.file} to validate ranges lazily and calculate the EOF-clamped content length with exact
+ * bigint arithmetic. Invalid range inputs or a final length above `Number.MAX_SAFE_INTEGER` fail with
+ * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts are valid when the final length is
+ * representable as a safe integer. The request's Content-Length header contains that exact length.
+ *
  * @category combinators
  * @since 4.0.0
  */
@@ -1175,21 +1183,35 @@ export const bodyFile: {
   /**
    * Creates a file-backed request body from a filesystem path and sets it on the request.
    *
+   * **Details**
+   *
+   * Uses {@link HttpBody.file} to validate ranges lazily and calculate the EOF-clamped content length with exact
+   * bigint arithmetic. Invalid range inputs or a final length above `Number.MAX_SAFE_INTEGER` fail with
+   * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts are valid when the final length is
+   * representable as a safe integer. The request's Content-Length header contains that exact length.
+   *
    * @category combinators
    * @since 4.0.0
    */
   (
     path: string,
     options?: {
-      readonly bytesToRead?: FileSystem.SizeInput | undefined
-      readonly chunkSize?: FileSystem.SizeInput | undefined
-      readonly offset?: FileSystem.SizeInput | undefined
+      readonly bytesToRead?: ByteSize.Input | undefined
+      readonly chunkSize?: number | undefined
+      readonly offset?: ByteSize.Input | undefined
       readonly contentType?: string
     }
   ): (self: HttpClientRequest) => Effect.Effect<HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
   /**
    * Creates a file-backed request body from a filesystem path and sets it on the request.
    *
+   * **Details**
+   *
+   * Uses {@link HttpBody.file} to validate ranges lazily and calculate the EOF-clamped content length with exact
+   * bigint arithmetic. Invalid range inputs or a final length above `Number.MAX_SAFE_INTEGER` fail with
+   * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts are valid when the final length is
+   * representable as a safe integer. The request's Content-Length header contains that exact length.
+   *
    * @category combinators
    * @since 4.0.0
    */
@@ -1197,9 +1219,9 @@ export const bodyFile: {
     self: HttpClientRequest,
     path: string,
     options?: {
-      readonly bytesToRead?: FileSystem.SizeInput | undefined
-      readonly chunkSize?: FileSystem.SizeInput | undefined
-      readonly offset?: FileSystem.SizeInput | undefined
+      readonly bytesToRead?: ByteSize.Input | undefined
+      readonly chunkSize?: number | undefined
+      readonly offset?: ByteSize.Input | undefined
       readonly contentType?: string
     }
   ): Effect.Effect<HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
@@ -1209,9 +1231,9 @@ export const bodyFile: {
     self: HttpClientRequest,
     path: string,
     options?: {
-      readonly bytesToRead?: FileSystem.SizeInput | undefined
-      readonly chunkSize?: FileSystem.SizeInput | undefined
-      readonly offset?: FileSystem.SizeInput | undefined
+      readonly bytesToRead?: ByteSize.Input | undefined
+      readonly chunkSize?: number | undefined
+      readonly offset?: ByteSize.Input | undefined
       readonly contentType?: string
     }
   ): Effect.Effect<HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem> =>
@@ -1257,18 +1279,10 @@ const fromWebBody = (request: globalThis.Request, method: HttpMethod): HttpBody.
   }
   return HttpBody.raw(request.body, {
     contentType: request.headers.get("content-type") ?? undefined,
-    contentLength: parseContentLength(request.headers.get("content-length"))
+    contentLength: bodyInternal.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
-}
-
 /**
  * Converts an `HttpClientRequest` safely to a Web `Request` as a `Result`, failing when the request URL is invalid.
  *

package/src/unstable/http/HttpClientResponse.ts

@@ -21,7 +21,7 @@ import type { Unify } from "../../Unify.ts"
 import * as Cookies from "./Cookies.ts"
 import * as Headers from "./Headers.ts"
 import * as Error from "./HttpClientError.ts"
-import type * as HttpClientRequest from "./HttpClientRequest.ts"
+import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -66,6 +66,11 @@ export const TypeId = "~effect/http/HttpClientResponse"
 export interface HttpClientResponse extends HttpIncomingMessage.HttpIncomingMessage<Error.HttpClientError>, Pipeable {
   readonly [TypeId]: typeof TypeId
   readonly request: HttpClientRequest.HttpClientRequest
+  /**
+   * The resolved URL, including query parameters and excluding the hash.
+   * Uses the final URL when redirects are followed. Empty if unknown.
+   */
+  readonly url: string
   readonly status: number
   readonly cookies: Cookies.Cookies
   readonly formData: Effect.Effect<FormData, Error.HttpClientError>
@@ -98,7 +103,7 @@ export const schemaJson = <
   schema: Schema.ConstraintCodec<A, I, RD, unknown>,
   options?: (ParseOptions & HttpIncomingMessage.JsonOptions) | undefined
 ) => {
-  const decode = Schema.decodeEffect(Schema.toCodecJson(schema).annotate({ options }))
+  const decode = Schema.decodeEffect(Schema.toCodecJson(schema), options)
   const decodeBody = HttpIncomingMessage.schemaBodyJson(Schema.Unknown, options)
   return (
     self: HttpClientResponse
@@ -129,7 +134,7 @@ export const schemaNoBody = <
   schema: Schema.Codec<A, I, RD, RE>,
   options?: ParseOptions | undefined
 ) => {
-  const decode = Schema.decodeEffect(schema.annotate({ options }))
+  const decode = Schema.decodeEffect(schema, options)
   return (self: HttpClientResponse): Effect.Effect<A, Schema.SchemaError, RD> =>
     decode({
       status: self.status,
@@ -299,6 +304,14 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
     return this.source.status
   }
 
+  get url(): string {
+    if (this.source.url) return this.source.url.split("#")[0]
+    const url = HttpClientRequest.toUrl(this.request)
+    if (Option.isNone(url)) return ""
+    url.value.hash = ""
+    return url.value.href
+  }
+
   get headers(): Headers.Headers {
     return Headers.fromInput(this.source.headers)
   }

package/src/unstable/http/HttpEffect.ts

@@ -13,13 +13,15 @@ import * as Context from "../../Context.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 { reportCauseUnsafe } from "../../internal/effect.ts"
+import { constVoid, dual } from "../../Function.ts"
+import { contA, contE } from "../../internal/core.ts"
+import { effectIsExit, fiberEnterUninterruptibleUnsafe, reportCauseUnsafe } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
 import * as Stream from "../../Stream.ts"
+import { nativeTracer } from "../../Tracer.ts"
 import * as HttpBody from "./HttpBody.ts"
-import { type HttpMiddleware, tracer } from "./HttpMiddleware.ts"
+import { type HttpMiddleware, isTracerDisabledUnsafe, tracer } from "./HttpMiddleware.ts"
 import { causeResponse, ClientAbort, HttpServerError, InternalError } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
@@ -41,11 +43,10 @@ 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 handleCause = (cause: Cause.Cause<E | EH | HttpServerError>) =>
+  const handleCause = (request: HttpServerRequest, cause: Cause.Cause<E | EH | HttpServerError>) =>
     Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
       reportCauseUnsafe(fiber, cause)
-      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
       const handler = preResponseHandler.requestPreResponseHandlers.get(request.source)
       const cont = cause.reasons.length === 0 ? Effect.succeed(response) : Effect.failCause(cause)
       if (handler === undefined) {
@@ -65,52 +66,117 @@ export const toHandled = <E, R, EH, RH>(
       )
     })
 
-  const responded = Effect.matchCauseEffect(self, {
-    onSuccess: (response) => {
-      const fiber = Fiber.getCurrent()!
-      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
-      const handler = preResponseHandler.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
-  })
+  // Writes the response, applying any registered pre-response handler first.
+  // Returns an `Exit` when the write completes synchronously.
+  const sendResponse = (
+    request: HttpServerRequest,
+    response: HttpServerResponse
+  ): Effect.Effect<HttpServerResponse, EH | HttpServerError, RH> => {
+    const handler = preResponseHandler.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)
+    })
+  }
 
-  const withMiddleware: Effect.Effect<
+  const withMiddleware = (request: HttpServerRequest): Effect.Effect<
     unknown,
     E | EH | HttpServerError,
     HttpServerRequest | R | RH
-  > = middleware === undefined ?
-    tracer(responded) :
-    Effect.matchCauseEffect(tracer(middleware(responded)), {
-      onFailure(cause): Effect.Effect<void, EH, RH> {
-        const fiber = Fiber.getCurrent()!
-        reportCauseUnsafe(fiber, cause)
-        const request = Context.getUnsafe(fiber.context, HttpServerRequest)
-        if (handledSymbol in request) return Effect.void
-        return Effect.matchCauseEffectEager(causeResponse(cause), {
-          onFailure(_) {
-            return handleResponse(request, Response.empty({ status: 500 }))
-          },
-          onSuccess([response]) {
-            return handleResponse(request, response)
-          }
-        })
-      },
-      onSuccess(response): Effect.Effect<void, EH, RH> {
-        const fiber = Fiber.getCurrent()!
-        const request = Context.getUnsafe(fiber.context, Request.HttpServerRequest)
-        return handledSymbol in request ? Effect.void : handleResponse(request, response)
-      }
+  > => {
+    const responded = Effect.matchCauseEffect(self, {
+      onSuccess: (response) => sendResponse(request, response),
+      onFailure: (cause) => handleCause(request, cause)
     })
+    return middleware === undefined ?
+      responded :
+      Effect.matchCauseEffect(tracer(middleware(responded)), {
+        onFailure(cause): Effect.Effect<void, EH, RH> {
+          reportCauseUnsafe(Fiber.getCurrent()!, cause)
+          if (handledSymbol in request) return Effect.void
+          return Effect.matchCauseEffectEager(causeResponse(cause), {
+            onFailure(_) {
+              return handleResponse(request, Response.empty({ status: 500 }))
+            },
+            onSuccess([response]) {
+              return handleResponse(request, response)
+            }
+          })
+        },
+        onSuccess(response): Effect.Effect<void, EH, RH> {
+          return handledSymbol in request ? Effect.void : handleResponse(request, response)
+        }
+      })
+  }
 
-  return Effect.uninterruptible(scoped(withMiddleware)) as any
+  // Apply tracing lazily so disabled requests can use the single-frame path.
+  const traced = (request: HttpServerRequest) =>
+    tracer(
+      withMiddleware(request) as Effect.Effect<
+        HttpServerResponse,
+        E | EH | HttpServerError,
+        HttpServerRequest | R | RH
+      >
+    )
+
+  // Handle untraced requests without middleware in one continuation frame.
+  // Effectful writes use `finishAfter` to restore state and close the scope.
+  const finishAfter = (
+    frame: RequestFrame,
+    fiber: Fiber.Fiber<unknown, unknown>,
+    effect: Effect.Effect<unknown, unknown, unknown>
+  ) =>
+    Effect.onExitPrimitive(effect, (exit) => {
+      fiber.setContext(frame.prev)
+      if (scopeEjected in frame.scope) return undefined
+      return Scope.closeUnsafe(frame.scope, exit)
+    }, true)
+
+  class RequestFrame {
+    readonly scope: Scope.Closeable
+    readonly prev: Context.Context<never>
+    readonly request: HttpServerRequest
+    constructor(scope: Scope.Closeable, prev: Context.Context<never>, request: HttpServerRequest) {
+      this.scope = scope
+      this.prev = prev
+      this.request = request
+    }
+    [contA](response: HttpServerResponse, fiber: Fiber.Fiber<unknown, unknown>) {
+      const sent = sendResponse(this.request, response)
+      // Most response writes complete synchronously.
+      if (effectIsExit(sent) && sent._tag === "Success") {
+        fiber.setContext(this.prev)
+        if (scopeEjected in this.scope) return sent
+        const closed = Scope.closeUnsafe(this.scope, sent)
+        return closed === undefined ? sent : Effect.flatMap(closed, () => sent)
+      }
+      return finishAfter(this, fiber, sent)
+    }
+    [contE](cause: Cause.Cause<E | EH | HttpServerError>, fiber: Fiber.Fiber<unknown, unknown>) {
+      return finishAfter(this, fiber, handleCause(this.request, cause))
+    }
+  }
+
+  return Effect.withFiber((fiber) => {
+    fiberEnterUninterruptibleUnsafe(fiber)
+    const scope = Scope.makeUnsafe()
+    const frame = new RequestFrame(scope, fiber.context, Context.getUnsafe(fiber.context, HttpServerRequest))
+    fiber.setContext(Context.add(frame.prev, Scope.Scope, scope))
+    // The native tracer has no backend, so its spans are unobservable.
+    const currentTracer = fiber.cache.tracer
+    if (
+      middleware === undefined &&
+      (currentTracer === undefined || currentTracer === nativeTracer || isTracerDisabledUnsafe(fiber, frame.request))
+    ) {
+      ;(fiber as any)._stack.push(frame)
+      return self
+    }
+    return finishAfter(frame, fiber, middleware === undefined ? traced(frame.request) : withMiddleware(frame.request))
+  }) as any
 }
 
 const handledSymbol = Symbol.for("effect/http/HttpEffect/handled")
@@ -157,18 +223,6 @@ export const scopeTransferToStream = (
 
 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 prevServices = fiber.context
-    fiber.setContext(Context.add(fiber.context, Scope.Scope, scope))
-    return Effect.onExitPrimitive(effect, (exit) => {
-      fiber.setContext(prevServices)
-      if (scopeEjected in scope) return undefined
-      return Scope.closeUnsafe(scope, exit)
-    }, true)
-  })
-
 /**
  * Function run with the current request and response just before the response is sent, allowing the response to be replaced or failing with `HttpServerError`.
  *
@@ -263,7 +317,7 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
 {
   const resolveSymbol = Symbol.for("@effect/platform/HttpApp/resolve")
   const httpApp = toHandled(self, (request, response) => {
-    response = scopeTransferToStream(response)
+    if (request.method !== "HEAD") response = scopeTransferToStream(response)
     ;(request as any)[resolveSymbol](
       Response.toWeb(response, { withoutBody: request.method === "HEAD", context })
     )
@@ -281,9 +335,11 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
       reqContext = Context.add(reqContext, HttpServerRequest, httpServerRequest)
       ;(httpServerRequest as any)[resolveSymbol] = resolve
       const fiber = Effect.runForkWith(reqContext)(httpApp as any)
-      request.signal?.addEventListener("abort", () => {
-        fiber.interruptUnsafe(undefined, ClientAbort.annotation)
-      }, { once: true })
+      if (fiber.pollUnsafe() === undefined) {
+        request.signal?.addEventListener("abort", () => {
+          fiber.interruptUnsafe(undefined, ClientAbort.annotation)
+        }, { once: true })
+      }
     })
 }
 
@@ -302,6 +358,14 @@ export const toWebHandler: <E>(
 /**
  * Builds a Web `Request` handler from a layer and handler factory, returning the handler with a `dispose` function for the layer scope.
  *
+ * **Details**
+ *
+ * The layer is built immediately, so the cost is paid when the handler is
+ * created rather than on the first request. A layer that performs asynchronous
+ * work while building may still be in progress when the first request arrives,
+ * in which case that request waits for the build to finish. If the build fails,
+ * every request rejects with the build error.
+ *
  * @category converting
  * @since 4.0.0
  */
@@ -337,9 +401,18 @@ export const toWebHandlerLayerWith = <
   let handlerCache:
     | ((request: Request, context?: Context.Context<ReqR> | undefined) => Promise<globalThis.Response>)
     | undefined
-  let handlerPromise:
-    | Promise<(request: Request, context?: Context.Context<ReqR> | undefined) => Promise<globalThis.Response>>
-    | undefined
+  const handlerPromise = Effect.runPromise(Effect.gen(function*() {
+    const context = yield* (options.memoMap
+      ? Layer.buildWithMemoMap(layer, options.memoMap, scope)
+      : Layer.buildWithScope(layer, scope))
+    return handlerCache = toWebHandlerWith<Provided, R>(context)(
+      yield* options.toHandler(context),
+      options.middleware
+    ) as any
+  }))
+  // A failed build must not become an unhandled rejection at startup. Every
+  // request still rejects with the build error below.
+  handlerPromise.catch(constVoid)
   function handler(
     request: Request,
     context?: Context.Context<ReqR> | undefined
@@ -347,15 +420,6 @@ export const toWebHandlerLayerWith = <
     if (handlerCache) {
       return handlerCache(request, context)
     }
-    handlerPromise ??= Effect.runPromise(Effect.gen(function*() {
-      const context = yield* (options.memoMap
-        ? Layer.buildWithMemoMap(layer, options.memoMap, scope)
-        : Layer.buildWithScope(layer, scope))
-      return handlerCache = toWebHandlerWith<Provided, R>(context)(
-        yield* options.toHandler(context),
-        options.middleware
-      ) as any
-    }))
     return handlerPromise.then((f) => f(request, context))
   }
   return { dispose, handler: handler as any } as const
@@ -364,6 +428,14 @@ export const toWebHandlerLayerWith = <
 /**
  * Builds a Web `Request` handler for an HTTP server effect using a layer to provide its services, returning the handler with a `dispose` function.
  *
+ * **Details**
+ *
+ * The layer is built immediately, so the cost is paid when the handler is
+ * created rather than on the first request. A layer that performs asynchronous
+ * work while building may still be in progress when the first request arrives,
+ * in which case that request waits for the build to finish. If the build fails,
+ * every request rejects with the build error.
+ *
  * @category converting
  * @since 4.0.0
  */

package/src/unstable/http/HttpIncomingMessage.ts

@@ -9,9 +9,9 @@
  *
  * @since 4.0.0
  */
+import type * as ByteSize from "../../ByteSize.ts"
 import * as Context from "../../Context.ts"
 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"
@@ -20,7 +20,7 @@ import * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
 import type * as Stream from "../../Stream.ts"
 import type * as Headers from "./Headers.ts"
-import * as UrlParams from "./UrlParams.ts"
+import type * as UrlParams from "./UrlParams.ts"
 
 /**
  * Type identifier for `HttpIncomingMessage` values.
@@ -102,7 +102,7 @@ export const schemaBodyUrlParams = <
   schema: Schema.ConstraintCodec<A, I, RD, unknown>,
   options?: ParseOptions | undefined
 ) => {
-  const decode = UrlParams.schemaRecord.pipe(
+  const decode = Schema.RecordFromUrlParams.pipe(
     Schema.decodeTo(schema),
     Schema.decodeEffect
   )
@@ -130,7 +130,7 @@ export const schemaHeaders = <A, I extends Readonly<Record<string, string | unde
  * @category references
  * @since 4.0.0
  */
-export const MaxBodySize = Context.Reference<FileSystem.Size | undefined>(
+export const MaxBodySize = Context.Reference<ByteSize.ByteSize | undefined>(
   "effect/http/HttpIncomingMessage/MaxBodySize",
   { defaultValue: () => undefined }
 )