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

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"
 

package/src/unstable/http/HttpServerResponse.ts

@@ -10,10 +10,10 @@
  *
  * @since 4.0.0
  */
+import type * as ByteSize from "../../ByteSize.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as ErrorReporter from "../../ErrorReporter.ts"
-import type * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
 import * as Inspectable from "../../Inspectable.ts"
 import { PipeInspectableProto } from "../../internal/core.ts"
@@ -34,6 +34,7 @@ import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpClientResponse from "./HttpClientResponse.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import type { HttpPlatform } from "./HttpPlatform.ts"
+import * as headersInternal from "./internal/headers.ts"
 import * as bodyInternal from "./internal/httpBody.ts"
 import * as Template from "./Template.ts"
 import * as UrlParams from "./UrlParams.ts"
@@ -506,9 +507,9 @@ export const file = (
   path: string,
   options?:
     | (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
     })
     | undefined
 ): Effect.Effect<HttpServerResponse, PlatformError, HttpPlatform> =>
@@ -529,9 +530,9 @@ export const fileWeb = (
   file: Body.HttpBody.FileLike,
   options?:
     | (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
     })
     | undefined
 ): Effect.Effect<HttpServerResponse, never, HttpPlatform> =>
@@ -561,10 +562,7 @@ export const setHeader: {
 } = dual(
   3,
   (self: HttpServerResponse, key: string, value: string): HttpServerResponse =>
-    makeResponse({
-      ...self,
-      headers: Headers.set(self.headers, key, value)
-    }, true)
+    makeResponse(self, Headers.set(self.headers, key, value))
 )
 
 /**
@@ -621,10 +619,7 @@ export const setHeaders: {
 } = dual(
   2,
   (self: HttpServerResponse, input: Headers.Input): HttpServerResponse =>
-    makeResponse({
-      ...self,
-      headers: Headers.setAll(self.headers, input)
-    }, true)
+    makeResponse(self, Headers.setAll(self.headers, input))
 )
 
 /**
@@ -1206,7 +1201,7 @@ export const setBody: {
 } = dual(
   2,
   (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse =>
-    makeResponse({ ...self, headers: bodyInternal.updateHeaders(self.headers, body), body })
+    makeResponse({ ...self, body }, bodyInternal.updateHeaders(self.headers, body))
 )
 
 /**
@@ -1298,7 +1293,13 @@ export const toWeb = (
         headers
       })
     }
-    case "Uint8Array":
+    case "Uint8Array": {
+      return new Response(body.text ?? body.body as any, {
+        status: response.status,
+        statusText: response.statusText!,
+        headers
+      })
+    }
     case "Raw": {
       if (body.body instanceof Response) {
         for (const [key, value] of headers as any) {
@@ -1336,12 +1337,8 @@ export const toWeb = (
 }
 
 /**
- * Wraps an `HttpServerResponse` as an `HttpClientResponse`.
- *
- * **Details**
- *
- * An optional request can be supplied for client-response metadata and decode
- * errors.
+ * Wraps an `HttpServerResponse` as an `HttpClientResponse`, using the optional
+ * request for metadata and decode errors. Without a request, `url` is empty.
  *
  * @category converting
  * @since 4.0.0
@@ -1387,6 +1384,14 @@ class ServerHttpClientResponse extends Inspectable.Class implements HttpClientRe
     return this.response.status
   }
 
+  get url(): string {
+    if (this.request === HttpClientRequest.empty) return ""
+    const url = HttpClientRequest.toUrl(this.request)
+    if (Option.isNone(url)) return ""
+    url.value.hash = ""
+    return url.value.href
+  }
+
   private cachedHeaders?: Headers.Headers
   get headers(): Headers.Headers {
     return this.cachedHeaders ??= this.response.body._tag === "FormData"
@@ -1531,7 +1536,11 @@ class ServerHttpClientResponse extends Inspectable.Class implements HttpClientRe
   }
 
   get arrayBuffer(): Effect.Effect<ArrayBuffer, HttpClientError.HttpClientError> {
-    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
+    )
   }
 
   private decodeError(cause: unknown): HttpClientError.HttpClientError {
@@ -1578,7 +1587,7 @@ export const fromClientResponse = (
     body: Body.stream(
       Stream.catchIf(response.stream, isEmptyBodyError, () => Stream.empty),
       Option.getOrUndefined(Headers.get(headers, "content-type")),
-      getContentLength(headers)
+      bodyInternal.parseContentLength(headers["content-length"])
     )
   })
 }
@@ -1591,15 +1600,6 @@ const isEmptyBodyError = (
 ): error is HttpClientError.HttpClientError =>
   HttpClientError.isHttpClientError(error) && error.reason._tag === "EmptyBodyError"
 
-const getContentLength = (headers: Headers.Headers): number | undefined => {
-  const contentLength = Option.getOrUndefined(Headers.get(headers, "content-length"))
-  if (contentLength === undefined) {
-    return undefined
-  }
-  const parsed = Number(contentLength)
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined
-}
-
 const Proto: Omit<
   HttpServerResponse,
   "status" | "statusText" | "headers" | "cookies" | "body"
@@ -1625,7 +1625,10 @@ const makeResponse = (options: {
   readonly headers?: Headers.Headers | undefined
   readonly cookies?: Cookies.Cookies | undefined
   readonly body?: Body.HttpBody | undefined
-}, preferHeaders = false) => {
+}, ownedHeaders?: Headers.Headers) => {
+  // ownedHeaders is a freshly created map that nothing else references, so it
+  // can be completed in place instead of copied. It supersedes options.headers,
+  // and explicit content headers in it take precedence over body-derived ones.
   const self = Object.create(Proto) as Mutable<HttpServerResponse>
   self.status = options.status
   self.statusText = options.statusText
@@ -1635,16 +1638,21 @@ const makeResponse = (options: {
     self.body._tag !== "Empty" &&
     (self.body.contentType || self.body.contentLength !== undefined)
   ) {
-    const newHeaders = Headers.fromRecordUnsafe({ ...options.headers }) as any
-    if (self.body.contentType && (!preferHeaders || newHeaders["content-type"] === undefined)) {
+    const owned = ownedHeaders !== undefined
+    const newHeaders = owned
+      ? ownedHeaders as any
+      : options.headers === undefined || options.headers === Headers.empty
+      ? headersInternal.emptyMutableUnsafe() as any
+      : Headers.fromRecordUnsafe({ ...options.headers }) as any
+    if (self.body.contentType && (!owned || newHeaders["content-type"] === undefined)) {
       newHeaders["content-type"] = self.body.contentType
     }
-    if (self.body.contentLength !== undefined && (!preferHeaders || newHeaders["content-length"] === undefined)) {
+    if (self.body.contentLength !== undefined && (!owned || newHeaders["content-length"] === undefined)) {
       newHeaders["content-length"] = self.body.contentLength.toString()
     }
     self.headers = newHeaders
   } else {
-    self.headers = options.headers ?? Headers.empty
+    self.headers = ownedHeaders ?? options.headers ?? Headers.empty
   }
   return self
 }
@@ -1679,7 +1687,8 @@ export const fromWeb = (response: Response): HttpServerResponse => {
           evaluate: () => response.body!,
           onError: (e) => e
         }),
-        contentType ?? undefined
+        contentType ?? undefined,
+        bodyInternal.parseContentLength(response.headers.get("content-length"))
       )
     )
   }

package/src/unstable/http/HttpStaticServer.ts

@@ -27,7 +27,7 @@ import * as HttpServerResponse from "./HttpServerResponse.ts"
  * **Example** (Serving files from a directory)
  *
  * ```ts import.meta.vitest
- * import { Effect, FileSystem, Layer, Path } from "effect"
+ * import { ByteSize, Effect, FileSystem, Layer, Path } from "effect"
  * import {
  *   HttpEffect,
  *   HttpPlatform,
@@ -39,7 +39,7 @@ import * as HttpServerResponse from "./HttpServerResponse.ts"
  *   stat: () =>
  *     Effect.succeed({
  *       type: "File",
- *       size: FileSystem.Size(20)
+ *       size: ByteSize.bytes(20)
  *     } as FileSystem.File.Info)
  * })
  * const TestHttpPlatform = Layer.succeed(
@@ -111,35 +111,38 @@ export const make: (options: {
   const serveFile: (
     request: HttpServerRequest.HttpServerRequest,
     filePath: string,
-    fileSize?: number
+    fileSize?: bigint
   ) => Effect.Effect<HttpServerResponse.HttpServerResponse, HttpServerError.HttpServerError> = Effect.fnUntraced(
     function*(request, filePath, fileSize) {
-      const rangeHeader = request.headers["range"]
+      const rangeHeader = request.method === "GET" ? request.headers["range"] : undefined
       const shouldEvaluateConditionals = request.headers["if-none-match"] !== undefined ||
         request.headers["if-modified-since"] !== undefined
 
       let fullResponse: HttpServerResponse.HttpServerResponse | undefined
+      const getFullResponse = () =>
+        fullResponse === undefined
+          ? Effect.map(
+            handlePlatformError(request, platform.fileResponse(filePath)),
+            (response) => setFileHeaders(response, filePath)
+          )
+          : Effect.succeed(fullResponse)
       if (shouldEvaluateConditionals) {
-        fullResponse = setFileHeaders(yield* handlePlatformError(request, platform.fileResponse(filePath)), filePath)
+        fullResponse = yield* getFullResponse()
         const conditionalResponse = evaluateConditionalRequest(request, fullResponse)
         if (conditionalResponse !== undefined) {
           return conditionalResponse
         }
-        if (rangeHeader === undefined) {
-          return fullResponse
-        }
       }
 
-      const resolvedFileSize = rangeHeader === undefined
-        ? undefined
-        : fileSize ?? Number((yield* handlePlatformError(request, fileSystem.stat(filePath))).size)
-      const parsedRange = rangeHeader === undefined || resolvedFileSize === undefined
-        ? undefined
-        : parseRange(rangeHeader, resolvedFileSize)
+      if (rangeHeader === undefined) {
+        return yield* getFullResponse()
+      }
+
+      const resolvedFileSize = fileSize ?? (yield* handlePlatformError(request, fileSystem.stat(filePath))).size
+      const parsedRange = parseRange(rangeHeader, resolvedFileSize)
 
       if (parsedRange === undefined) {
-        return fullResponse ??
-          setFileHeaders(yield* handlePlatformError(request, platform.fileResponse(filePath)), filePath)
+        return yield* getFullResponse()
       }
 
       if (parsedRange === "unsatisfiable") {
@@ -157,7 +160,7 @@ export const make: (options: {
           platform.fileResponse(filePath, {
             status: 206,
             offset: parsedRange.start,
-            bytesToRead: parsedRange.end - parsedRange.start + 1
+            bytesToRead: parsedRange.end - parsedRange.start + BigInt(1)
           })
         ),
         filePath
@@ -190,7 +193,7 @@ export const make: (options: {
           : Effect.fail(toInternalServerError(request, error)),
       onSuccess(info) {
         if (info.type === "File") {
-          return serveFile(request, resolvedPath, Number(info.size))
+          return serveFile(request, resolvedPath, info.size)
         }
         if (info.type === "Directory" && index !== undefined) {
           return serveFile(request, path.join(resolvedPath, index))
@@ -302,19 +305,18 @@ const resolveMimeType = (path: Path.Path, filePath: string, mimeTypes: Record<st
   return mimeTypes[extension.slice(1)] ?? "application/octet-stream"
 }
 
-const parseInteger = (value: string): number | undefined => {
+const parseInteger = (value: string): bigint | undefined => {
   if (!/^\d+$/.test(value)) {
     return undefined
   }
-  const parsed = Number(value)
-  return Number.isSafeInteger(parsed) ? parsed : undefined
+  return BigInt(value)
 }
 
 const parseRange = (
   header: string,
-  fileSize: number
+  fileSize: bigint
 ):
-  | { readonly start: number; readonly end: number }
+  | { readonly start: bigint; readonly end: bigint }
   | "unsatisfiable"
   | undefined =>
 {
@@ -340,12 +342,12 @@ const parseRange = (
     if (suffixLength === undefined) {
       return undefined
     }
-    if (suffixLength === 0 || fileSize === 0) {
+    if (suffixLength === BigInt(0) || fileSize === BigInt(0)) {
       return "unsatisfiable"
     }
     return {
-      start: Math.max(fileSize - suffixLength, 0),
-      end: fileSize - 1
+      start: fileSize > suffixLength ? fileSize - suffixLength : BigInt(0),
+      end: fileSize - BigInt(1)
     }
   }
   const start = parseInteger(startPart)
@@ -358,7 +360,7 @@ const parseRange = (
     }
     return {
       start,
-      end: fileSize - 1
+      end: fileSize - BigInt(1)
     }
   }
   const end = parseInteger(endPart)
@@ -370,7 +372,7 @@ const parseRange = (
   }
   return {
     start,
-    end: Math.min(end, fileSize - 1)
+    end: end < fileSize ? end : fileSize - BigInt(1)
   }
 }