effect 4.0.0-beta.103 → 4.0.0-beta.105

package/src/unstable/http/FindMyWay.ts

@@ -1,15 +1,74 @@
 /**
- * Re-exports the `find-my-way-ts` router package used by the unstable HTTP
- * routing modules.
+ * A radix-tree HTTP router used by the unstable HTTP routing modules.
  *
- * This module keeps the router types and helpers available from the Effect HTTP
- * namespace without wrapping or changing them.
+ * @since 4.0.0
+ */
+import * as internal from "./FindMyWay/internal/router.ts"
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2017-2019 Tomas Della Vedova
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
  *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface RouterConfig {
+  readonly ignoreTrailingSlash: boolean
+  readonly ignoreDuplicateSlashes: boolean
+  readonly caseSensitive: boolean
+  readonly maxParamLength: number
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type PathInput = `/${string}` | "*"
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface Router<A> {
+  readonly on: (method: string | Iterable<string>, path: PathInput, handler: A) => void
+  readonly all: (path: PathInput, handler: A) => void
+  readonly find: (method: string, url: string) => FindResult<A> | undefined
+  readonly has: (method: string, url: string) => boolean
+}
+
+/**
  * @since 4.0.0
+ * @category models
  */
+export interface FindResult<A> {
+  readonly handler: A
+  readonly params: Record<string, string | undefined>
+  readonly searchParams: Record<string, string | Array<string>>
+}
 
 /**
- * @category re-exports
  * @since 4.0.0
+ * @category constructors
  */
-export * from "find-my-way-ts"
+export const make: <A>(options?: Partial<RouterConfig>) => Router<A> = internal.make

package/src/unstable/http/HttpClient.ts

@@ -1267,7 +1267,8 @@ export declare namespace WithRateLimiter {
    *
    * **Details**
    *
-   * They define the backing limiter, initial limit window, keying strategy, algorithm, token cost, and whether response headers update future limits.
+   * They define the backing limiter, initial limit window, keying strategy,
+   * algorithm, token cost, retry count, and response header inspection.
    *
    * @category rate limiting
    * @since 4.0.0
@@ -1300,11 +1301,48 @@ export declare namespace WithRateLimiter {
      */
     readonly tokens?: number | ((request: HttpClientRequest.HttpClientRequest) => number) | undefined
     /**
-     * Disable automatic limits updates from response headers.
+     * The maximum number of automatic retries after an HTTP `429` response.
+     * Use a non-negative integer. Defaults to an unlimited number of retries.
+     * Set to `0` to disable automatic retries.
+     */
+    readonly times?: number | undefined
+    /**
+     * Overrides the response header names used for rate limit inspection.
+     * Header names are matched case-insensitively. An omitted field continues
+     * using the built-in names, while a configured field replaces them for
+     * that value. Header value formats are unchanged.
+     */
+    readonly responseHeaders?: {
+      /**
+       * Header containing the maximum number of requests in a window.
+       */
+      readonly limit?: string | undefined
+      /**
+       * Header containing the number of requests remaining in a window.
+       */
+      readonly remaining?: string | undefined
+      /**
+       * Header containing the rate limit reset time.
+       */
+      readonly reset?: string | undefined
+      /**
+       * Header containing the number of seconds until the rate limit resets.
+       */
+      readonly resetAfter?: string | undefined
+      /**
+       * Header containing the retry delay for an HTTP `429` response.
+       */
+      readonly retryAfter?: string | undefined
+    } | undefined
+    /**
+     * Disables automatic limit updates, `Retry-After` delays, and adaptive
+     * feedback from response headers. This does not disable automatic HTTP
+     * `429` retries. Set `times` to `0` to disable them.
      */
     readonly disableResponseInspection?: boolean | undefined
     /**
-     * Disable adaptive learning from `Retry-After` responses.
+     * Disables adaptive learning from `Retry-After` responses. Response
+     * inspection and direct `Retry-After` delays remain enabled.
      */
     readonly disableAdaptiveLearning?: boolean | undefined
   }
@@ -1319,6 +1357,12 @@ export declare namespace WithRateLimiter {
  * automatically retries HTTP `429` responses (or `HttpClientError` values
  * wrapping a `429` response) by forcing the retry back through the limiter.
  *
+ * **Gotchas**
+ *
+ * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+ * Disabling response inspection does not disable retries; set `times` to `0`
+ * to return or fail with the first `429`.
+ *
  * @category rate limiting
  * @since 4.0.0
  */
@@ -1332,6 +1376,12 @@ export const withRateLimiter: {
    * automatically retries HTTP `429` responses (or `HttpClientError` values
    * wrapping a `429` response) by forcing the retry back through the limiter.
    *
+   * **Gotchas**
+   *
+   * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+   * Disabling response inspection does not disable retries; set `times` to `0`
+   * to return or fail with the first `429`.
+   *
    * @category rate limiting
    * @since 4.0.0
    */
@@ -1347,6 +1397,12 @@ export const withRateLimiter: {
    * automatically retries HTTP `429` responses (or `HttpClientError` values
    * wrapping a `429` response) by forcing the retry back through the limiter.
    *
+   * **Gotchas**
+   *
+   * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+   * Disabling response inspection does not disable retries; set `times` to `0`
+   * to return or fail with the first `429`.
+   *
    * @category rate limiting
    * @since 4.0.0
    */
@@ -1371,6 +1427,7 @@ export const withRateLimiter: {
     ? tokensOption
     : constant(tokensOption ?? 1)
   const adaptiveLearningEnabled = !options.disableAdaptiveLearning
+  const headerNames = resolveRateLimiterHeaderNames(options.responseHeaders)
 
   const getState = (key: string): RateLimiterState => {
     const current = states.get(key)
@@ -1385,13 +1442,13 @@ export const withRateLimiter: {
     ? undefined
     : (clock: Clock, key: string, headers: Headers.Headers, tokens: number) => {
       const current = getState(key)
-      const next = parseRateLimiterState(current, clock, headers, tokens)
+      const next = parseRateLimiterState(current, clock, headers, tokens, headerNames)
       if (next.limit !== current.limit || !Duration.equals(next.window, current.window)) {
         states.set(key, next)
       }
     }
 
-  return transform(self, function loop(effect, request): Effect.Effect<
+  return transform(self, function loop(effect, request, retries = 0): Effect.Effect<
     HttpClientResponse.HttpClientResponse,
     E | RateLimiter.RateLimiterError,
     R
@@ -1401,11 +1458,11 @@ export const withRateLimiter: {
     const key = resolveKey(request)
     const tokens = Math.max(resolveTokens(request), 1)
     const current = getState(key)
+    const canRetry = options.times === undefined || retries < options.times
     function retry(retryAfter: Duration.Duration | undefined) {
-      if (options.disableResponseInspection) return loop(effect, request)
       return retryAfter
-        ? Effect.flatMap(Effect.sleep(retryAfter), () => loop(effect, request))
-        : loop(effect, request)
+        ? Effect.flatMap(Effect.sleep(retryAfter), () => loop(effect, request, retries + 1))
+        : loop(effect, request, retries + 1)
     }
     const inspectResponse = (
       response: HttpClientResponse.HttpClientResponse,
@@ -1422,12 +1479,18 @@ export const withRateLimiter: {
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
          *
+         * **Gotchas**
+         *
+         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+         * Disabling response inspection does not disable retries; set `times` to `0`
+         * to return or fail with the first `429`.
+         *
          * @category rate limiting
          * @since 4.0.0
          */
         Duration.Duration | undefined>(undefined);
       }
-      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, "retry-after"))
+      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, ...headerNames.retryAfter))
       if (retryAfter === undefined) {
         return Effect.succeed</**
          * Applies request rate limiting using the `RateLimiter` service.
@@ -1438,12 +1501,18 @@ export const withRateLimiter: {
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
          *
+         * **Gotchas**
+         *
+         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+         * Disabling response inspection does not disable retries; set `times` to `0`
+         * to return or fail with the first `429`.
+         *
          * @category rate limiting
          * @since 4.0.0
          */
         Duration.Duration | undefined>(undefined);
       }
-      const delay = parseRateLimitWindow(clock, response.headers) ?? retryAfter
+      const delay = parseRateLimitWindow(clock, response.headers, headerNames) ?? retryAfter
       if (adaptive === undefined) {
         return Effect.succeed</**
          * Applies request rate limiting using the `RateLimiter` service.
@@ -1454,6 +1523,12 @@ export const withRateLimiter: {
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
          *
+         * **Gotchas**
+         *
+         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
+         * Disabling response inspection does not disable retries; set `times` to `0`
+         * to return or fail with the first `429`.
+         *
          * @category rate limiting
          * @since 4.0.0
          */
@@ -1489,7 +1564,7 @@ export const withRateLimiter: {
             const request = Effect.matchEffect(effect, {
               onSuccess(response) {
                 return Effect.flatMap(inspectResponse(response, adaptive), (retryAfter) => {
-                  if (response.status !== 429) return Effect.succeed(response)
+                  if (response.status !== 429 || !canRetry) return Effect.succeed(response)
                   return retry(retryAfter)
                 })
               },
@@ -1497,7 +1572,7 @@ export const withRateLimiter: {
                 if (isTooManyRequestsHttpClientError(error)) {
                   return Effect.flatMap(
                     inspectResponse(error.reason.response, adaptive),
-                    (retryAfter) => retry(retryAfter)
+                    (retryAfter) => canRetry ? retry(retryAfter) : Effect.fail(error)
                   )
                 }
                 return Effect.fail(error)
@@ -1531,6 +1606,34 @@ export const withRateLimiter: {
   });
 })
 
+interface RateLimiterHeaderNames {
+  readonly limit: ReadonlyArray<string>
+  readonly remaining: ReadonlyArray<string>
+  readonly reset: ReadonlyArray<string>
+  readonly resetAfter: ReadonlyArray<string>
+  readonly retryAfter: ReadonlyArray<string>
+}
+
+const resolveRateLimiterHeaderNames = (
+  responseHeaders: WithRateLimiter.Options["responseHeaders"]
+): RateLimiterHeaderNames => ({
+  limit: responseHeaders?.limit === undefined
+    ? ["ratelimit-limit", "x-ratelimit-limit"]
+    : [responseHeaders.limit.toLowerCase()],
+  remaining: responseHeaders?.remaining === undefined
+    ? ["ratelimit-remaining", "x-ratelimit-remaining"]
+    : [responseHeaders.remaining.toLowerCase()],
+  reset: responseHeaders?.reset === undefined
+    ? ["ratelimit-reset", "x-ratelimit-reset"]
+    : [responseHeaders.reset.toLowerCase()],
+  resetAfter: responseHeaders?.resetAfter === undefined
+    ? ["ratelimit-reset-after", "x-ratelimit-reset-after"]
+    : [responseHeaders.resetAfter.toLowerCase()],
+  retryAfter: responseHeaders?.retryAfter === undefined
+    ? ["retry-after"]
+    : [responseHeaders.retryAfter.toLowerCase()]
+})
+
 interface RateLimiterState {
   readonly limit: number
   readonly window: Duration.Duration
@@ -1541,10 +1644,11 @@ const parseRateLimiterState = (
   state: RateLimiterState,
   clock: Clock,
   headers: Headers.Headers,
-  tokens: number
+  tokens: number,
+  headerNames: RateLimiterHeaderNames
 ): RateLimiterState => {
-  const limit = parseRateLimitLimit(state, headers, tokens) ?? state.limit
-  const window = parseRateLimitWindow(clock, headers) ?? state.window
+  const limit = parseRateLimitLimit(state, headers, tokens, headerNames) ?? state.limit
+  const window = parseRateLimitWindow(clock, headers, headerNames) ?? state.window
   if (limit === state.limit && Duration.equals(window, state.window)) {
     return state
   }
@@ -1554,35 +1658,40 @@ const parseRateLimiterState = (
 const parseRateLimitLimit = (
   state: RateLimiterState,
   headers: Headers.Headers,
-  tokens: number
+  tokens: number,
+  headerNames: RateLimiterHeaderNames
 ): number | undefined => {
-  const raw = getHeader(headers, "ratelimit-limit", "x-ratelimit-limit")
+  const raw = getHeader(headers, ...headerNames.limit)
   const value = parseNumberHeader(raw)
   if (value !== undefined && value > 0) {
     return value
   }
-  const remaining = parseRateLimitRemaining(headers)
+  const remaining = parseRateLimitRemaining(headers, headerNames)
   if (remaining === undefined) {
     return undefined
   }
   return state.initial ? remaining + tokens : Math.max(remaining + tokens, state.limit)
 }
 
-const parseRateLimitRemaining = (headers: Headers.Headers): number | undefined => {
-  const raw = getHeader(headers, "ratelimit-remaining", "x-ratelimit-remaining")
+const parseRateLimitRemaining = (
+  headers: Headers.Headers,
+  headerNames: RateLimiterHeaderNames
+): number | undefined => {
+  const raw = getHeader(headers, ...headerNames.remaining)
   const value = parseNumberHeader(raw)
   return value !== undefined && value >= 0 ? value : undefined
 }
 
 const parseRateLimitWindow = (
   clock: Clock,
-  headers: Headers.Headers
+  headers: Headers.Headers,
+  headerNames: RateLimiterHeaderNames
 ): Duration.Duration | undefined => {
-  const resetAfter = parseResetAfter(getHeader(headers, "ratelimit-reset-after", "x-ratelimit-reset-after"))
+  const resetAfter = parseResetAfter(getHeader(headers, ...headerNames.resetAfter))
   if (resetAfter !== undefined) {
     return resetAfter
   }
-  return parseResetHeader(clock, getHeader(headers, "ratelimit-reset", "x-ratelimit-reset"))
+  return parseResetHeader(clock, getHeader(headers, ...headerNames.reset))
 }
 
 const parseRetryAfter = (

package/src/unstable/http/HttpClientError.ts

@@ -299,7 +299,7 @@ export type HttpClientErrorReason = RequestError | ResponseError
  * @category schemas
  * @since 4.0.0
  */
-export class HttpClientErrorSchema extends Schema.ErrorClass<HttpClientErrorSchema>(TypeId)({
+export class HttpClientErrorSchema extends Schema.Error<HttpClientErrorSchema>(TypeId)({
   _tag: Schema.tag("HttpError"),
   kind: Schema.Literals(
     [

package/src/unstable/http/HttpClientRequest.ts

@@ -28,6 +28,7 @@ import * as Stream from "../../Stream.ts"
 import * as Headers from "./Headers.ts"
 import * as HttpBody from "./HttpBody.ts"
 import { hasBody, type HttpMethod } from "./HttpMethod.ts"
+import * as bodyInternal from "./internal/httpBody.ts"
 import * as Url from "./Url.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -874,25 +875,12 @@ export const setBody: {
    */
   (self: HttpClientRequest, body: HttpBody.HttpBody): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, body: HttpBody.HttpBody): HttpClientRequest => {
-  let headers = self.headers
-  if (body._tag === "Empty" || body._tag === "FormData") {
-    headers = Headers.remove(Headers.remove(headers, "Content-Type"), "Content-length")
-  } else {
-    if (body.contentType) {
-      headers = Headers.set(headers, "content-type", body.contentType)
-    }
-    if (body.contentLength !== undefined) {
-      headers = Headers.set(headers, "content-length", body.contentLength.toString())
-    } else {
-      headers = Headers.remove(headers, "content-length")
-    }
-  }
   return makeWith(
     self.method,
     self.url,
     self.urlParams,
     self.hash,
-    headers,
+    bodyInternal.updateHeaders(self.headers, body),
     body
   )
 })

package/src/unstable/http/HttpClientResponse.ts

@@ -355,22 +355,7 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
 
   private textBody?: Effect.Effect<string, Error.HttpClientError>
   get text(): Effect.Effect<string, Error.HttpClientError> {
-    if (this.textBody) {
-      return this.textBody
-    }
-    this.textBody = Effect.tryPromise({
-      try: () => this.source.text(),
-      catch: (cause) =>
-        new Error.HttpClientError({
-          reason: new Error.DecodeError({
-            request: this.request,
-            response: this,
-            cause
-          })
-        })
-    }).pipe(Effect.cached, Effect.runSync)
-    this.arrayBufferBody = Effect.map(this.textBody, (_) => new TextEncoder().encode(_).buffer)
-    return this.textBody
+    return this.textBody ??= Effect.map(this.arrayBuffer, (_) => new TextDecoder().decode(_))
   }
 
   get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, Error.HttpClientError> {
@@ -419,7 +404,6 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
           })
         })
     }).pipe(Effect.cached, Effect.runSync)
-    this.textBody = Effect.map(this.arrayBufferBody, (_) => new TextDecoder().decode(_))
     return this.arrayBufferBody
   }
 

package/src/unstable/http/HttpPlatform.ts

@@ -161,14 +161,42 @@ export const layer = Layer.effect(HttpPlatform)(
           { contentLength, headers, status, statusText }
         )
       },
-      fileWebResponse(file, status, statusText, headers, _options) {
-        return Response.stream(
-          Stream.fromReadableStream({
+      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 stream = end <= offset
+          ? Stream.empty
+          : Stream.fromReadableStream({
             evaluate: () => file.stream() as ReadableStream<Uint8Array>,
             onError: identity
-          }),
-          { headers, status, statusText }
-        )
+          }).pipe(
+            Stream.mapAccum(
+              () => 0,
+              (position, bytes) => {
+                const next = position + bytes.length
+                const start = Math.min(Math.max(offset - position, 0), bytes.length)
+                const stop = Math.min(Math.max(end - position, 0), bytes.length)
+                const chunks: Array<{ readonly bytes: Uint8Array; readonly done: boolean }> = []
+                for (let index = start; index < stop; index += chunkSize) {
+                  chunks.push({
+                    bytes: bytes.subarray(index, Math.min(index + chunkSize, stop)),
+                    done: next >= end && index + chunkSize >= stop
+                  })
+                }
+                return [next, chunks]
+              }
+            ),
+            Stream.takeUntil((chunk) => chunk.done),
+            Stream.map((chunk) => chunk.bytes)
+          )
+        return Response.stream(stream, {
+          contentLength: bytesToRead ?? file.size - offset,
+          headers,
+          status,
+          statusText
+        })
       }
     }))
 ).pipe(Layer.provide(Etag.layerWeak))

package/src/unstable/http/HttpServerRequest.ts

@@ -863,25 +863,25 @@ const rawBodyStream = (request: HttpServerRequest, body: unknown): Stream.Stream
   if (body instanceof Request) {
     return streamFromReadable(request, body.body)
   }
-  if (isFormData(body)) {
-    return streamFromReadable(request, new Response(body).body)
-  }
   if (isReadableStream(body)) {
     return streamFromReadable(request, body)
   }
+  if (isBodyInit(body)) {
+    return streamFromReadable(request, new Response(body).body)
+  }
   return Stream.fail(requestParseError(request, "Unsupported body type"))
 }
 
 const rawBodyBytes = (request: HttpServerRequest, body: unknown): Effect.Effect<Uint8Array, HttpServerError> => {
-  if (body instanceof Blob) {
-    return bytesFromBodyInit(request, body)
-  }
   if (body instanceof Request) {
     return Effect.tryPromise({
       try: () => body.arrayBuffer().then((buffer) => new Uint8Array(buffer)),
       catch: (cause) => requestParseError(request, undefined, cause)
     })
   }
+  if (isBodyInit(body)) {
+    return bytesFromBodyInit(request, body)
+  }
   return Effect.fail(requestParseError(request, "Unsupported body type"))
 }
 
@@ -995,6 +995,14 @@ const isReadableStream = (u: unknown): u is ReadableStream<Uint8Array> =>
 
 const isFormData = (u: unknown): u is FormData => typeof FormData !== "undefined" && u instanceof FormData
 
+const isBodyInit = (u: unknown): u is BodyInit =>
+  typeof u === "string" ||
+  (typeof ArrayBuffer !== "undefined" && (u instanceof ArrayBuffer || ArrayBuffer.isView(u))) ||
+  (typeof Blob !== "undefined" && u instanceof Blob) ||
+  isFormData(u) ||
+  (typeof URLSearchParams !== "undefined" && u instanceof URLSearchParams) ||
+  isReadableStream(u)
+
 const textDecoder = new TextDecoder()
 
 /**

package/src/unstable/http/HttpServerResponse.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 bodyInternal from "./internal/httpBody.ts"
 import * as Template from "./Template.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -563,7 +564,7 @@ export const setHeader: {
     makeResponse({
       ...self,
       headers: Headers.set(self.headers, key, value)
-    })
+    }, true)
 )
 
 /**
@@ -623,7 +624,7 @@ export const setHeaders: {
     makeResponse({
       ...self,
       headers: Headers.setAll(self.headers, input)
-    })
+    }, true)
 )
 
 /**
@@ -1204,7 +1205,8 @@ export const setBody: {
   (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse
 } = dual(
   2,
-  (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse => makeResponse({ ...self, body })
+  (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse =>
+    makeResponse({ ...self, headers: bodyInternal.updateHeaders(self.headers, body), body })
 )
 
 /**
@@ -1623,7 +1625,7 @@ const makeResponse = (options: {
   readonly headers?: Headers.Headers | undefined
   readonly cookies?: Cookies.Cookies | undefined
   readonly body?: Body.HttpBody | undefined
-}) => {
+}, preferHeaders = false) => {
   const self = Object.create(Proto) as Mutable<HttpServerResponse>
   self.status = options.status
   self.statusText = options.statusText
@@ -1631,13 +1633,13 @@ const makeResponse = (options: {
   self.body = options.body ?? Body.empty
   if (
     self.body._tag !== "Empty" &&
-    (self.body.contentType || self.body.contentLength)
+    (self.body.contentType || self.body.contentLength !== undefined)
   ) {
     const newHeaders = Headers.fromRecordUnsafe({ ...options.headers }) as any
-    if (self.body.contentType) {
+    if (self.body.contentType && (!preferHeaders || newHeaders["content-type"] === undefined)) {
       newHeaders["content-type"] = self.body.contentType
     }
-    if (self.body.contentLength) {
+    if (self.body.contentLength !== undefined && (!preferHeaders || newHeaders["content-length"] === undefined)) {
       newHeaders["content-length"] = self.body.contentLength.toString()
     }
     self.headers = newHeaders

package/src/unstable/http/Multipart.ts

@@ -34,7 +34,7 @@ import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as IncomingMessage from "./HttpIncomingMessage.ts"
 import * as HttpServerRespondable from "./HttpServerRespondable.ts"
 import * as HttpServerResponse from "./HttpServerResponse.ts"
-import * as MP from "./Multipasta.ts"
+import * as MP from "./MultipartParser.ts"
 
 /**
  * Type identifier used to brand multipart part values.
@@ -678,6 +678,8 @@ export const toPersisted = (
     const path_ = yield* Path.Path
     const dir = yield* fs.makeTempDirectoryScoped()
     const persisted: Record<string, Array<PersistedFile> | Array<string> | string> = Object.create(null)
+    const usedPaths = new Set<string>()
+    let fileIndex = 0
     yield* Stream.runForEach(stream, (part) => {
       if (part._tag === "Field") {
         if (!(part.key in persisted)) {
@@ -692,7 +694,12 @@ export const toPersisted = (
         return Effect.void
       }
       const file = part
-      const path = path_.join(dir, path_.basename(file.name).slice(-128))
+      const fileName = path_.basename(file.name).slice(-128)
+      let path = path_.join(dir, fileName)
+      while (usedPaths.has(path)) {
+        path = path_.join(dir, `${fileIndex++}-${fileName}`)
+      }
+      usedPaths.add(path)
       const filePart = new PersistedFileImpl(
         file.key,
         file.name,