effect 4.0.0-rc.111 → 4.0.0-rc.113

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 }
 )

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