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

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

package/src/unstable/http/Mime.ts

@@ -0,0 +1,76 @@
+/**
+ * Standard MIME type lookup.
+ *
+ * @since 4.0.0
+ */
+import * as Option from "../../Option.ts"
+import standardTypes from "./internal/mimeTypes.ts"
+
+const extensionToType = new Map<string, string>()
+const typeToExtension = new Map<string, string>()
+const typeToExtensions = new Map<string, Set<string>>()
+
+for (const [type, extensions] of Object.entries(standardTypes)) {
+  const allExtensions = new Set<string>()
+  typeToExtensions.set(type, allExtensions)
+  for (let index = 0; index < extensions.length; index++) {
+    let extension: string = extensions[index]
+    const starred = extension.startsWith("*")
+    if (starred) {
+      extension = extension.slice(1)
+    }
+    allExtensions.add(extension)
+    if (index === 0) {
+      typeToExtension.set(type, extension)
+    }
+    if (!starred) {
+      extensionToType.set(extension, type)
+    }
+  }
+}
+
+/**
+ * Returns the standard MIME type associated with a file name or extension.
+ *
+ * @category utilities
+ * @since 4.0.0
+ */
+export const getType = (path: string): Option.Option<string> => {
+  if (typeof path !== "string") {
+    return Option.none()
+  }
+  const last = path.replace(/^.*[/\\]/s, "").toLowerCase()
+  const extension = last.replace(/^.*\./s, "").toLowerCase()
+  const hasPath = last.length < path.length
+  const hasDot = extension.length < last.length - 1
+  if (!hasDot && hasPath) {
+    return Option.none()
+  }
+  return Option.fromUndefinedOr(extensionToType.get(extension))
+}
+
+/**
+ * Returns the default file extension associated with a standard MIME type.
+ *
+ * @category utilities
+ * @since 4.0.0
+ */
+export const getExtension = (type: string): Option.Option<string> => {
+  if (typeof type !== "string") {
+    return Option.none()
+  }
+  return Option.fromUndefinedOr(typeToExtension.get(type.split(";")[0].trim().toLowerCase()))
+}
+
+/**
+ * Returns every file extension associated with a standard MIME type.
+ *
+ * @category utilities
+ * @since 4.0.0
+ */
+export const getAllExtensions = (type: string): Option.Option<ReadonlySet<string>> => {
+  if (typeof type !== "string") {
+    return Option.none()
+  }
+  return Option.fromUndefinedOr(typeToExtensions.get(type.split(";")[0].trim().toLowerCase()))
+}

package/src/unstable/http/Multipart.ts

@@ -11,6 +11,7 @@
  * @since 4.0.0
  */
 import * as Arr from "../../Array.ts"
+import * as ByteSize from "../../ByteSize.ts"
 import * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
 import * as Context from "../../Context.ts"
@@ -30,7 +31,6 @@ import type { ParseOptions } from "../../SchemaAST.ts"
 import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import type * as Scope from "../../Scope.ts"
 import * as Stream from "../../Stream.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as IncomingMessage from "./HttpIncomingMessage.ts"
 import * as HttpServerRespondable from "./HttpServerRespondable.ts"
 import * as HttpServerResponse from "./HttpServerResponse.ts"
@@ -98,13 +98,26 @@ export interface Field extends Part.Proto {
 }
 
 /**
- * Returns `true` when a value is a multipart `Part`.
+ * Returns `true` when a value has the multipart part type identifier.
+ *
+ * **Details**
+ *
+ * This includes `Field`, `File`, and `PersistedFile` values. Use
+ * `isStreamPart` to identify only parsed, streamed parts.
  *
  * @category guards
  * @since 4.0.0
  */
 export const isPart = (u: unknown): u is Part => Predicate.hasProperty(u, TypeId)
 
+/**
+ * Returns `true` when a value is a multipart text `Field` or streamed `File`.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isStreamPart = (u: unknown): u is Part => isPart(u) && (u._tag === "Field" || u._tag === "File")
+
 /**
  * Returns `true` when a value is a multipart text `Field`.
  *
@@ -422,9 +435,9 @@ export const makeConfig = (
     return Effect.succeed<MP.BaseConfig>({
       headers,
       maxParts: fiber.getRef(MaxParts),
-      maxFieldSize: Number(fiber.getRef(MaxFieldSize)),
-      maxPartSize: UndefinedOr.map(fiber.getRef(MaxFileSize), Number),
-      maxTotalSize: UndefinedOr.map(fiber.getRef(IncomingMessage.MaxBodySize), Number),
+      maxFieldSize: fiber.getRef(MaxFieldSize),
+      maxPartSize: fiber.getRef(MaxFileSize),
+      maxTotalSize: fiber.getRef(IncomingMessage.MaxBodySize),
       isFile: mimeTypes.length === 0 ? undefined : (info: MP.PartInfo): boolean =>
         !mimeTypes.some(
           (_) => info.contentType.includes(_)
@@ -456,6 +469,7 @@ export const makeChannel = <IE>(headers: Record<string, string>): Channel.Channe
     Effect.map(makeConfig(headers), (config) => {
       let partsBuffer: Array<Part> = []
       let exit = Option.none<Exit.Exit<never, IE | MultipartError | Cause.Done>>()
+      let ended = false
 
       const parser = MP.make({
         ...config,
@@ -503,7 +517,10 @@ export const makeChannel = <IE>(headers: Record<string, string>): Channel.Channe
         }),
         Effect.catchCause((cause) => {
           if (Pull.isDoneCause(cause)) {
-            parser.end()
+            if (!ended) {
+              ended = true
+              parser.end()
+            }
           } else {
             exit = Option.some(Exit.failCause(cause)) as any
           }
@@ -757,9 +774,9 @@ class PersistedFileImpl extends PartBase implements PersistedFile {
  */
 export const limitsServices = (options: {
   readonly maxParts?: number | undefined
-  readonly maxFieldSize?: FileSystem.SizeInput | undefined
-  readonly maxFileSize?: FileSystem.SizeInput | undefined
-  readonly maxTotalSize?: FileSystem.SizeInput | undefined
+  readonly maxFieldSize?: ByteSize.Input | undefined
+  readonly maxFileSize?: ByteSize.Input | undefined
+  readonly maxTotalSize?: ByteSize.Input | undefined
   readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
 }): Context.Context<never> => {
   const map = new Map<string, unknown>()
@@ -767,13 +784,13 @@ export const limitsServices = (options: {
     map.set(MaxParts.key, options.maxParts)
   }
   if (options.maxFieldSize !== undefined) {
-    map.set(MaxFieldSize.key, FileSystem.Size(options.maxFieldSize))
+    map.set(MaxFieldSize.key, ByteSize.fromInputUnsafe(options.maxFieldSize))
   }
   if (options.maxFileSize !== undefined) {
-    map.set(MaxFileSize.key, UndefinedOr.map(options.maxFileSize, FileSystem.Size))
+    map.set(MaxFileSize.key, ByteSize.fromInputUnsafe(options.maxFileSize))
   }
   if (options.maxTotalSize !== undefined) {
-    map.set(IncomingMessage.MaxBodySize.key, UndefinedOr.map(options.maxTotalSize, FileSystem.Size))
+    map.set(IncomingMessage.MaxBodySize.key, ByteSize.fromInputUnsafe(options.maxTotalSize))
   }
   if (options.fieldMimeTypes !== undefined) {
     map.set(FieldMimeTypes.key, options.fieldMimeTypes)
@@ -800,9 +817,9 @@ export declare namespace withLimits {
    */
   export type Options = {
     readonly maxParts?: number | undefined
-    readonly maxFieldSize?: FileSystem.SizeInput | undefined
-    readonly maxFileSize?: FileSystem.SizeInput | undefined
-    readonly maxTotalSize?: FileSystem.SizeInput | undefined
+    readonly maxFieldSize?: ByteSize.Input | undefined
+    readonly maxFileSize?: ByteSize.Input | undefined
+    readonly maxTotalSize?: ByteSize.Input | undefined
     readonly fieldMimeTypes?: ReadonlyArray<string> | undefined
   }
 }
@@ -831,8 +848,8 @@ export const MaxParts = Context.Reference<number | undefined>("effect/http/Multi
  * @category services
  * @since 4.0.0
  */
-export const MaxFieldSize = Context.Reference<FileSystem.SizeInput>("effect/http/Multipart/MaxFieldSize", {
-  defaultValue: constant(FileSystem.Size(10 * 1024 * 1024))
+export const MaxFieldSize = Context.Reference<ByteSize.ByteSize>("effect/http/Multipart/MaxFieldSize", {
+  defaultValue: constant(ByteSize.mebibytes(10))
 })
 
 /**
@@ -845,7 +862,7 @@ export const MaxFieldSize = Context.Reference<FileSystem.SizeInput>("effect/http
  * @category services
  * @since 4.0.0
  */
-export const MaxFileSize = Context.Reference<FileSystem.SizeInput | undefined>(
+export const MaxFileSize = Context.Reference<ByteSize.ByteSize | undefined>(
   "effect/http/Multipart/MaxFileSize",
   { defaultValue: () => undefined }
 )

package/src/unstable/http/MultipartParser/internal/multipart.ts

@@ -1,3 +1,4 @@
+import * as ByteSize from "../../../../ByteSize.ts"
 import type { Config, MultipartError, PartInfo } from "../../MultipartParser.ts"
 import * as CT from "./contentType.ts"
 import * as HP from "./headers.ts"
@@ -41,6 +42,9 @@ function parseBoundary(headers: Record<string, string>) {
 
 function noopOnChunk(_chunk: Uint8Array | null) {}
 
+const toLimit = (input: ByteSize.Input): number =>
+  input === Infinity ? Infinity : Number(ByteSize.fromInputUnsafe(input))
+
 export function make({
   headers,
   onFile: onPart,
@@ -49,10 +53,13 @@ export function make({
   onDone,
   isFile = defaultIsFile,
   maxParts = Infinity,
-  maxTotalSize = Infinity,
-  maxPartSize = Infinity,
-  maxFieldSize = 1024 * 1024
+  maxTotalSize: maxTotalSizeInput = Infinity,
+  maxPartSize: maxPartSizeInput = Infinity,
+  maxFieldSize: maxFieldSizeInput = 1024 * 1024
 }: Config) {
+  const maxTotalSize = toLimit(maxTotalSizeInput)
+  const maxPartSize = toLimit(maxPartSizeInput)
+  const maxFieldSize = toLimit(maxFieldSizeInput)
   const boundary = parseBoundary(headers)
   if (boundary === undefined) {
     onError({ _tag: "InvalidBoundary" })

package/src/unstable/http/MultipartParser.ts

@@ -3,6 +3,7 @@
  *
  * @since 4.0.0
  */
+import type * as ByteSize from "../../ByteSize.ts"
 import type * as HeadersParser from "./MultipartParser/HeadersParser.ts"
 import * as internal from "./MultipartParser/internal/multipart.ts"
 
@@ -61,9 +62,9 @@ export type BaseConfig = {
   readonly headers: Record<string, string>
   readonly isFile?: ((info: PartInfo) => boolean) | undefined
   readonly maxParts?: number | undefined
-  readonly maxTotalSize?: number | undefined
-  readonly maxPartSize?: number | undefined
-  readonly maxFieldSize?: number | undefined
+  readonly maxTotalSize?: ByteSize.Input | undefined
+  readonly maxPartSize?: ByteSize.Input | undefined
+  readonly maxFieldSize?: ByteSize.Input | undefined
 }
 
 /**