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

package/src/unstable/http/HttpMiddleware.ts

@@ -14,14 +14,14 @@ import { Clock } from "../../Clock.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import type * as Fiber from "../../Fiber.ts"
 import { constant, constFalse } from "../../Function.ts"
 import * as internalEffect from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type { Predicate } from "../../Predicate.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
-import { TracerEnabled } from "../../References.ts"
-import { ParentSpan } from "../../Tracer.ts"
+import { nativeTracer, ParentSpan, Tracer } from "../../Tracer.ts"
 import * as Headers from "./Headers.ts"
 import type { CompressionAlgorithm } from "./HttpPlatform.ts"
 import { HttpPlatform } from "./HttpPlatform.ts"
@@ -32,6 +32,7 @@ import * as Response from "./HttpServerResponse.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
 import * as compressionInternal from "./internal/compression.ts"
+import * as bodyInternal from "./internal/httpBody.ts"
 import { appendPreResponseHandlerUnsafe } from "./internal/preResponseHandler.ts"
 
 /**
@@ -170,6 +171,12 @@ export const logger: <E, R>(
   })
 )
 
+/** @internal */
+export const isTracerDisabledUnsafe = (
+  fiber: Fiber.Fiber<unknown, unknown>,
+  request: HttpServerRequest
+): boolean => !fiber.cache.tracerEnabled || fiber.getRef(TracerDisabledWhen)(request)
+
 /**
  * Middleware that creates a server trace span for each request and records request and response HTTP attributes.
  *
@@ -181,8 +188,7 @@ export const tracer: <E, R>(
 ) => Effect.Effect<HttpServerResponse, E, HttpServerRequest | R> = make((httpApp) =>
   Effect.withFiber((fiber) => {
     const request = Context.getUnsafe(fiber.context, HttpServerRequest)
-    const disabled = !fiber.getRef(TracerEnabled) || fiber.getRef(TracerDisabledWhen)(request)
-    if (disabled) {
+    if (isTracerDisabledUnsafe(fiber, request)) {
       return httpApp
     }
     const nameGenerator = fiber.getRef(SpanNameGenerator)
@@ -195,6 +201,11 @@ export const tracer: <E, R>(
     return Effect.onExitPrimitive(httpApp, (exit) => {
       fiber.setContext(prevServices)
       const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe()
+      if (Exit.isSuccess(exit) && (!span.sampled || fiber.getRef(Tracer) === nativeTracer)) {
+        span.end(endTime, exit)
+        return undefined
+      }
+      const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
       fiber.currentDispatcher.scheduleTask(() => {
         let response: HttpServerResponse
         let spanExit = exit
@@ -206,7 +217,6 @@ export const tracer: <E, R>(
           response = exit.value
         }
         if (span.sampled) {
-          const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
           span.attribute("http.request.method", request.method)
           if (request.url.startsWith("/")) {
             const host = request.headers.host ?? "localhost"
@@ -335,8 +345,8 @@ export const cors = (options?: {
     : (origin: string) => (opts.allowedOrigins as ReadonlyArray<string>).includes(origin)
 
   const allowOrigin = typeof opts.allowedOrigins === "function" || opts.allowedOrigins.length > 1
-    ? ((originHeader: string) => {
-      if (!isAllowedOrigin(originHeader)) return undefined
+    ? ((originHeader: string): ReadonlyRecord<string, string> => {
+      if (!isAllowedOrigin(originHeader)) return { vary: "Origin" }
       return {
         "access-control-allow-origin": originHeader,
         vary: "Origin"
@@ -398,18 +408,36 @@ export const cors = (options?: {
   const headersFromRequestOptions = (request: HttpServerRequest) => {
     const origin = request.headers["origin"]
     const accessControlRequestHeaders = request.headers["access-control-request-headers"]
-    return Headers.fromRecordUnsafe({
+    const headers = Headers.fromRecordUnsafe({
       ...allowOrigin(origin),
       ...allowCredentials,
       ...exposeHeaders,
       ...allowMethods,
-      ...allowHeaders(accessControlRequestHeaders),
       ...maxAge
     })
+    const accessControlHeaders = allowHeaders(accessControlRequestHeaders)
+    if (accessControlHeaders === undefined) return headers
+    const vary = accessControlHeaders["vary"]
+    return Headers.setAll(
+      headers,
+      vary === undefined
+        ? accessControlHeaders
+        : {
+          ...accessControlHeaders,
+          vary: compressionInternal.varyWith(headers, vary)
+        }
+    )
   }
 
-  const preResponseHandler = (request: HttpServerRequest, response: HttpServerResponse) =>
-    Effect.succeed(Response.setHeaders(response, headersFromRequest(request)))
+  const preResponseHandler = (request: HttpServerRequest, response: HttpServerResponse) => {
+    const headers = headersFromRequest(request)
+    return Effect.succeed(Response.setHeaders(
+      response,
+      headers["vary"] === undefined
+        ? headers
+        : Headers.set(headers, "vary", compressionInternal.varyWith(response.headers, "Origin"))
+    ))
+  }
 
   return <E, R>(
     httpApp: Effect.Effect<HttpServerResponse, E, R>
@@ -457,7 +485,7 @@ export const cors = (options?: {
  * explicitly flush each input chunk, so incremental delivery depends on the
  * runtime's implementation.
  *
- * **Security**
+ * **Gotchas**
  *
  * Compression can expose secrets through BREACH-style attacks when one
  * response contains both secret data and attacker-controlled input and an
@@ -542,7 +570,7 @@ export const compression = (
     if (algorithm === undefined) {
       return Effect.succeed(withVary(response))
     }
-    const contentLength = body.contentLength ?? contentLengthHeader(response.headers)
+    const contentLength = body.contentLength ?? bodyInternal.parseContentLength(response.headers["content-length"])
     if (contentLength !== undefined && contentLength < minSize) {
       return Effect.succeed(withVary(response))
     }
@@ -561,8 +589,8 @@ export const compression = (
 }
 
 const withVary = (response: HttpServerResponse): HttpServerResponse => {
-  const vary = compressionInternal.varyAcceptEncoding(response.headers)
-  return vary === undefined ? response : Response.setHeader(response, "vary", vary)
+  const vary = compressionInternal.varyWith(response.headers, "Accept-Encoding")
+  return Response.setHeader(response, "vary", vary)
 }
 
 const defaultAlgorithms: ReadonlyArray<CompressionAlgorithm> = ["br", "gzip", "deflate"]
@@ -575,12 +603,3 @@ const defaultLevels = {
 } as const
 
 const noTransformRegex = /(?:^|[\s,])no-transform(?:$|[\s,;])/i
-
-const contentLengthHeader = (headers: Headers.Headers): number | undefined => {
-  const value = headers["content-length"]
-  if (value === undefined) {
-    return undefined
-  }
-  const parsed = Number(value)
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined
-}

package/src/unstable/http/HttpPlatform.ts

@@ -9,13 +9,14 @@
  *
  * @since 4.0.0
  */
+import * as ByteSize from "../../ByteSize.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
-import type { PlatformError } from "../../PlatformError.ts"
+import { badArgument, type PlatformError } from "../../PlatformError.ts"
 import * as Stream from "../../Stream.ts"
 import * as Etag from "./Etag.ts"
 import * as Headers from "./Headers.ts"
@@ -35,17 +36,17 @@ export class HttpPlatform extends Context.Service<HttpPlatform, {
   readonly fileResponse: (
     path: string,
     options?: Response.Options.WithContent & {
-      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
     }
   ) => Effect.Effect<Response.HttpServerResponse, PlatformError>
   readonly fileWebResponse: (
     file: Body.HttpBody.FileLike,
     options?: Response.Options.WithContent & {
-      readonly bytesToRead?: FileSystem.SizeInput | undefined
-      readonly chunkSize?: FileSystem.SizeInput | undefined
-      readonly offset?: FileSystem.SizeInput | undefined
+      readonly bytesToRead?: number | undefined
+      readonly chunkSize?: number | undefined
+      readonly offset?: number | undefined
     }
   ) => Effect.Effect<Response.HttpServerResponse>
 }>()("effect/http/HttpPlatform") {}
@@ -66,7 +67,7 @@ export const make: (impl: {
     headers: Headers.Headers,
     start: number,
     end: number | undefined,
-    contentLength: number
+    contentLength: bigint
   ) => Response.HttpServerResponse
   readonly fileWebResponse: (
     file: Body.HttpBody.FileLike,
@@ -74,9 +75,9 @@ export const make: (impl: {
     statusText: string | undefined,
     headers: Headers.Headers,
     options?: {
-      readonly bytesToRead?: FileSystem.SizeInput | undefined
-      readonly chunkSize?: FileSystem.SizeInput | undefined
-      readonly offset?: FileSystem.SizeInput | undefined
+      readonly bytesToRead?: number | undefined
+      readonly chunkSize?: number | undefined
+      readonly offset?: number | undefined
     }
   ) => Response.HttpServerResponse
 }) => Effect.Effect<
@@ -93,8 +94,18 @@ export const make: (impl: {
     fileResponse: Effect.fnUntraced(function*(path, options) {
       const info = yield* fs.stat(path)
       const etag = yield* etagGen.fromFileInfo(info)
-      const start = Number(options?.offset ?? 0)
-      const end = options?.bytesToRead !== undefined ? start + Number(options.bytesToRead) : undefined
+      const requestedOffset = options?.offset === undefined
+        ? ByteSize.zero
+        : yield* fileResponseSize(options.offset, "offset")
+      const offset = requestedOffset > info.size ? info.size : requestedOffset
+      const available = info.size - offset
+      const bytesToRead = options?.bytesToRead !== undefined
+        ? yield* fileResponseSize(options.bytesToRead, "bytesToRead")
+        : undefined
+      const contentLength = bytesToRead === undefined || bytesToRead > available ? available : bytesToRead
+      const limit = bytesToRead === undefined ? undefined : offset + contentLength
+      const start = yield* fileResponseNumber(offset, "offset")
+      const end = limit === undefined ? undefined : yield* fileResponseNumber(limit, "end")
       const headers = Headers.set(
         options?.headers ? Headers.fromInput(options.headers) : Headers.empty,
         "etag",
@@ -103,7 +114,6 @@ export const make: (impl: {
       if (Option.isSome(info.mtime)) {
         ;(headers as any)["last-modified"] = info.mtime.value.toUTCString()
       }
-      const contentLength = end !== undefined ? end - start : Number(info.size) - start
       return impl.fileResponse(
         path,
         options?.status ?? 200,
@@ -135,6 +145,28 @@ export const make: (impl: {
   })
 })
 
+const fileResponseSize = (input: ByteSize.Input, field: string): Effect.Effect<ByteSize.ByteSize, PlatformError> => {
+  const size = ByteSize.fromInput(input)
+  return Option.isSome(size)
+    ? Effect.succeed(size.value)
+    : Effect.fail(badArgument({
+      module: "HttpPlatform",
+      method: "fileResponse",
+      description: `Invalid ${field}: ${input}`
+    }))
+}
+
+const fileResponseNumber = (value: bigint, field: string): Effect.Effect<number, PlatformError> => {
+  const number = Number(value)
+  return Number.isSafeInteger(number)
+    ? Effect.succeed(number)
+    : Effect.fail(badArgument({
+      module: "HttpPlatform",
+      method: "fileResponse",
+      description: `${field} exceeds the safe integer range: ${value}`
+    }))
+}
+
 /**
  * Provides the default `HttpPlatform` implementation for serving file paths and
  * `File`-like values as streamed HTTP responses.
@@ -153,19 +185,29 @@ export const layer = Layer.effect(HttpPlatform)(
       platform: "web",
       compression: internal.compressionWeb,
       fileResponse(path, status, statusText, headers, start, end, contentLength) {
+        const length = Number(contentLength)
         return Response.stream(
           fs.stream(path, {
             offset: start,
             bytesToRead: end !== undefined ? end - start : undefined
           }),
-          { contentLength, headers, status, statusText }
+          {
+            // Omit unsafe numeric metadata so it cannot overwrite the exact header.
+            contentLength: Number.isSafeInteger(length) ? length : undefined,
+            headers: Headers.set(headers, "content-length", contentLength.toString()),
+            status,
+            statusText
+          }
         )
       },
       fileWebResponse(file, status, statusText, headers, options) {
-        const offset = Number(options?.offset ?? 0)
-        const bytesToRead = options?.bytesToRead !== undefined ? Number(options.bytesToRead) : undefined
-        const chunkSize = options?.chunkSize !== undefined ? Math.max(1, Number(options.chunkSize)) : Infinity
-        const end = offset + (bytesToRead ?? Infinity)
+        const offset = Math.min(Math.max(options?.offset ?? 0, 0), file.size)
+        const available = file.size - offset
+        const contentLength = options?.bytesToRead === undefined
+          ? available
+          : Math.min(Math.max(options.bytesToRead, 0), available)
+        const chunkSize = options?.chunkSize !== undefined ? Math.max(1, options.chunkSize) : Infinity
+        const end = offset + contentLength
         const stream = end <= offset
           ? Stream.empty
           : Stream.fromReadableStream({
@@ -192,7 +234,7 @@ export const layer = Layer.effect(HttpPlatform)(
             Stream.map((chunk) => chunk.bytes)
           )
         return Response.stream(stream, {
-          contentLength: bytesToRead ?? file.size - offset,
+          contentLength,
           headers,
           status,
           statusText

package/src/unstable/http/HttpRouter.ts

@@ -13,6 +13,7 @@ import * as Arr from "../../Array.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { compose, dual, identity } from "../../Function.ts"
+import { fiberEnterInterruptibleUnsafe } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
@@ -163,9 +164,10 @@ export const make = Effect.gen(function*() {
   return HttpRouter.of({
     [TypeId]: TypeId,
     prefixed(this: HttpRouter, prefix: string) {
+      prefix = removeTrailingSlash(prefix as PathInput)
       return HttpRouter.of({
         ...this,
-        prefixed: (newPrefix: string) => this.prefixed(prefixPath(prefix, newPrefix)),
+        prefixed: (newPrefix: string) => this.prefixed(prefixPath(newPrefix, prefix)),
         addAll: (routes) => addAll(routes.map(prefixRoute(prefix))) as any,
         add: (method, path, handler, options) =>
           addAll([
@@ -218,19 +220,22 @@ export const make = Effect.gen(function*() {
           params: result.params
         })
 
-        const span = Context.getOrUndefined(context, Tracer.ParentSpan)
-        if (span && span._tag === "Span") {
-          span.attribute("http.route", route.path)
+        if (fiber.getRef(Tracer.Tracer) !== Tracer.nativeTracer) {
+          const span = Context.getOrUndefined(context, Tracer.ParentSpan)
+          if (span !== undefined && span._tag === "Span" && span.sampled) {
+            span.attribute("http.route", route.path)
+          }
+        }
+        // The enclosing request restores the fiber context on exit.
+        fiber.setContext(context)
+        if (!route.uninterruptible) {
+          const interrupted = fiberEnterInterruptibleUnsafe(fiber)
+          if (interrupted !== undefined) return interrupted
         }
-        return Effect.updateContext(
-          (route.uninterruptible ?
-            route.handler :
-            Effect.interruptible(route.handler)) as Effect.Effect<
-              HttpServerResponse.HttpServerResponse,
-              unknown
-            >,
-          () => context
-        )
+        return route.handler as Effect.Effect<
+          HttpServerResponse.HttpServerResponse,
+          unknown
+        >
       })
       if (middleware.size === 0) return handler
       for (const fn of Arr.reverse(middleware)) {
@@ -293,7 +298,9 @@ export const params: Effect.Effect<
   ReadonlyRecord<string, string | undefined>,
   never,
   RouteContext
-> = Effect.map(RouteContext, (_) => _.params)
+> = Effect.withFiberSucceed((fiber) =>
+  Context.getUnsafe(fiber.context as Context.Context<RouteContext>, RouteContext).params
+)
 
 /**
  * Decodes a schema from the current request and its JSON body.
@@ -791,7 +798,7 @@ export const prefixRoute: {
     ...self,
     path: prefixPath(self.path, prefix) as PathInput,
     prefix: Option.match(self.prefix, {
-      onNone: () => prefix as string,
+      onNone: () => removeTrailingSlash(prefix as PathInput),
       onSome: (existingPrefix) => prefixPath(existingPrefix, prefix) as string
     })
   }))
@@ -1327,7 +1334,11 @@ export const serve = <A, E, R, HE, HR = Request.Only<"Requires", R> | Request.On
  *
  * The result contains a `handler` function that converts Web `Request` values to
  * Web `Response` values and a `dispose` function for releasing the layer
- * resources.
+ * resources. 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/HttpServer.ts

@@ -16,6 +16,7 @@ import { dual } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Path from "../../Path.ts"
 import type * as Scope from "../../Scope.ts"
+import * as NetAddress from "../net/NetAddress.ts"
 import * as Etag from "./Etag.ts"
 import * as HttpClient from "./HttpClient.ts"
 import * as ClientRequest from "./HttpClientRequest.ts"
@@ -52,44 +53,9 @@ export class HttpServer extends Context.Service<HttpServer, {
     >
   }
 
-  readonly address: Address
+  readonly address: NetAddress.SocketAddress
 }>()("effect/http/HttpServer") {}
 
-/**
- * Address where an HTTP server is listening.
- *
- * **Details**
- *
- * The address is either a TCP host and port or a Unix domain socket path.
- *
- * @category models
- * @since 4.0.0
- */
-export type Address = UnixAddress | TcpAddress
-
-/**
- * TCP address for an HTTP server, identified by hostname and port.
- *
- * @category models
- * @since 4.0.0
- */
-export interface TcpAddress {
-  readonly _tag: "TcpAddress"
-  readonly hostname: string
-  readonly port: number
-}
-
-/**
- * Unix domain socket address for an HTTP server.
- *
- * @category models
- * @since 4.0.0
- */
-export interface UnixAddress {
-  readonly _tag: "UnixAddress"
-  readonly path: string
-}
-
 /**
  * Constructs an `HttpServer` service from a serving implementation and listening
  * address.
@@ -103,7 +69,7 @@ export const make = (
       httpEffect: Effect.Effect<HttpServerResponse, unknown, HttpServerRequest | Scope.Scope>,
       middleware?: Middleware.HttpMiddleware
     ) => Effect.Effect<void, never, Scope.Scope>
-    readonly address: Address
+    readonly address: NetAddress.SocketAddress
   }
 ): HttpServer["Service"] => options
 
@@ -299,24 +265,17 @@ export const serveEffect: {
 > => HttpServer.use((server) => server.serve(effect, middleware!)) as any)
 
 /**
- * Formats a server address as a display string.
+ * Formats a server address as a display string using {@link NetAddress.formatUrlUnsafe}.
  *
- * **Details**
+ * **Gotchas**
  *
- * TCP addresses are formatted as `http://host:port`; Unix socket addresses are
- * formatted as `unix://path`.
+ * Throws a `NetAddressError` when URL conversion fails, including for scoped
+ * IPv6 addresses. Unix socket paths are displayed with a `unix://` prefix.
  *
  * @category converting
  * @since 4.0.0
  */
-export const formatAddress = (address: Address): string => {
-  switch (address._tag) {
-    case "UnixAddress":
-      return `unix://${address.path}`
-    case "TcpAddress":
-      return `http://${address.hostname}:${address.port}`
-  }
-}
+export const formatAddress: (address: NetAddress.SocketAddress) => string = NetAddress.formatUrlUnsafe
 
 /**
  * Reads the current server address, formats it with `formatAddress`, and passes
@@ -361,12 +320,12 @@ export const withLogAddress = <A, E, R>(
  *
  * **Details**
  *
- * For TCP servers, requests are prefixed with the server URL and `0.0.0.0` is
- * rewritten to `127.0.0.1`.
+ * For internet servers, requests are prefixed with the server URL and unspecified
+ * addresses are replaced by IPv4 loopback, including dual-stack `::` listeners.
  *
  * **Gotchas**
  *
- * Unix socket addresses are not supported.
+ * Unix socket addresses and scoped IPv6 addresses are not supported.
  *
  * @category testing
  * @since 4.0.0
@@ -379,12 +338,14 @@ export const makeTestClient: Effect.Effect<
   const server = yield* HttpServer
   const client = yield* HttpClient.HttpClient
   const address = server.address
-  if (address._tag === "UnixAddress") {
-    return yield* Effect.die(new Error("HttpServer.layerTestClient: UnixAddress not supported"))
+  if (NetAddress.isUnixPathAddress(address)) {
+    return yield* Effect.die(new Error("HttpServer.layerTestClient: UnixPathAddress not supported"))
+  }
+  const url = yield* Effect.fromResult(NetAddress.toUrl(address)).pipe(Effect.orDie)
+  if (NetAddress.isUnspecified(address.address)) {
+    url.hostname = NetAddress.formatIp(NetAddress.ipv4Loopback)
   }
-  const host = address.hostname === "0.0.0.0" ? "127.0.0.1" : address.hostname
-  const url = `http://${host}:${address.port}`
-  return HttpClient.mapRequest(client, ClientRequest.prependUrl(url))
+  return HttpClient.mapRequest(client, ClientRequest.prependUrl(url.origin))
 })
 
 /**

package/src/unstable/http/HttpServerRequest.ts

@@ -33,6 +33,7 @@ import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import { hasBody, type HttpMethod } from "./HttpMethod.ts"
 import { HttpServerError, type RequestError, RequestParseError } from "./HttpServerError.ts"
+import * as bodyInternal from "./internal/httpBody.ts"
 import * as Multipart from "./Multipart.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -350,7 +351,7 @@ export const schemaBodyFormJson = <A, RD>(
 ) => {
   const parseMultipart = Multipart.schemaJson(schema, options)
   return (field: string) => {
-    const parseUrlParams = UrlParams.schemaJsonField(field, options).pipe(
+    const parseUrlParams = Schema.JsonFromUrlParamsField(field, options).pipe(
       Schema.decodeTo(schema),
       Schema.decodeEffect
     )
@@ -423,18 +424,23 @@ export const fromWeb = (request: globalThis.Request): HttpServerRequest =>
  * @category converting
  * @since 4.0.0
  */
-export const toClientRequest = (request: HttpServerRequest): HttpClientRequest.HttpClientRequest =>
-  HttpClientRequest.setUrl(
+export const toClientRequest = (request: HttpServerRequest): HttpClientRequest.HttpClientRequest => {
+  const body = toClientBody(request)
+  const headers = body._tag !== "Empty" && body.contentLength === undefined
+    ? Headers.remove(request.headers, "content-length")
+    : request.headers
+  return HttpClientRequest.setUrl(
     HttpClientRequest.makeWith(
       request.method,
       "",
       UrlParams.empty,
       Option.none(),
-      request.headers,
-      toClientBody(request)
+      headers,
+      body
     ),
     Option.getOrElse(toURL(request), () => request.url)
   )
+}
 
 const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody => {
   if (!hasBody(request.method)) {
@@ -445,19 +451,11 @@ const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody => {
     ? HttpBody.stream(
       request.stream,
       request.headers["content-type"],
-      parseContentLength(request.headers["content-length"])
+      bodyInternal.parseContentLength(request.headers["content-length"])
     )
     : HttpBody.formData(formData)
 }
 
-const parseContentLength = (contentLength: string | undefined): number | undefined => {
-  if (contentLength === undefined) {
-    return undefined
-  }
-  const parsed = Number.parseInt(contentLength, 10)
-  return Number.isNaN(parsed) ? undefined : parsed
-}
-
 const removeHost = (url: string) => {
   if (url[0] === "/") {
     return url
@@ -842,7 +840,11 @@ class ClientRequestImpl extends Inspectable.Class implements HttpServerRequest {
   }
 
   get arrayBuffer(): Effect.Effect<ArrayBuffer, HttpServerError> {
-    return Effect.map(this.bytes, (bytes) => bytes.slice().buffer)
+    return Effect.map(
+      this.bytes,
+      // Copy this view because Buffer views may share a larger ArrayBuffer.
+      (bytes) => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
+    )
   }
 
   get upgrade(): Effect.Effect<Socket.Socket, HttpServerError> {

package/src/unstable/http/HttpServerRespondable.ts

@@ -10,8 +10,8 @@
  */
 import * as Cause from "../../Cause.ts"
 import * as Effect from "../../Effect.ts"
+import * as Schema from "../../internal/schemaError.ts"
 import { hasProperty } from "../../Predicate.ts"
-import * as Schema from "../../Schema.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as Response from "./HttpServerResponse.ts"