effect 4.0.6 → 4.0.7

package/src/http/HttpClientRequest.ts

@@ -1273,7 +1273,15 @@ export const compressBody: {
     }
     return Effect.map(
       compression.compressBody(self.body, algorithm, options),
-      (body) => body === self.body ? self : setHeader(setBody(self, body), "content-encoding", algorithm)
+      (body) =>
+        body === self.body ? self : makeWith(
+          self.method,
+          self.url,
+          self.urlParams,
+          self.hash,
+          Headers.set(bodyInternal.updateContentLength(self.headers, body), "content-encoding", algorithm),
+          body
+        )
     )
   }
 )

package/src/http/HttpMiddleware.ts

@@ -44,6 +44,7 @@ import * as decompressionInternal from "./internal/decompression.ts"
 import * as bodyInternal from "./internal/httpBody.ts"
 import { appendPreResponseHandlerUnsafe, CurrentRequestState } from "./internal/requestState.ts"
 import * as tracing from "./internal/tracing.ts"
+import * as internalUrlParams from "./internal/urlParams.ts"
 import * as UrlParams from "./UrlParams.ts"
 
 /**
@@ -135,19 +136,6 @@ export declare namespace HttpMiddleware {
  */
 export const make = <M extends HttpMiddleware>(middleware: M): M => middleware
 
-const stripSearchAndHash = (url: string): string => {
-  const queryIndex = url.indexOf("?")
-  const hashIndex = url.indexOf("#")
-
-  if (queryIndex === -1) {
-    return hashIndex === -1 ? url : url.slice(0, hashIndex)
-  }
-  if (hashIndex === -1) {
-    return url.slice(0, queryIndex)
-  }
-  return url.slice(0, Math.min(queryIndex, hashIndex))
-}
-
 /**
  * Runs an effect with HTTP response logging disabled for the current server request.
  *
@@ -232,7 +220,7 @@ export const logger: <E, R>(
   Effect.withFiber((fiber) => {
     const request = Context.getUnsafe(fiber.context, HttpServerRequest)
     const state = Context.getOrUndefined(fiber.context, CurrentRequestState)
-    const path = stripSearchAndHash(request.url)
+    const path = internalUrlParams.stripSearchAndHash(request.url)
     return Effect.withLogSpan(
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
         if (state?.loggerDisabled) {
@@ -278,12 +266,19 @@ export const isTracerDisabledUnsafe = (
 
 // OpenTelemetry requires failed server spans for 5xx responses.
 const responseSpanExit = (
+  fiber: Fiber.Fiber<unknown, unknown>,
   request: HttpServerRequest,
   response: HttpServerResponse
 ): Exit.Exit<HttpServerResponse, HttpServerError> => {
   if (!(response.status >= 500 && response.status < 600)) {
     return Exit.succeed(response)
   }
+  // The message is path-only, but exporters can still read `error.request.url`
+  // after the request-scoped redacted names are gone.
+  const url = UrlParams.redactUrl(request.url, fiber.getRef(UrlParams.CurrentRedactedNames))
+  if (url !== request.url) {
+    request = request.modify({ url })
+  }
   const stackTraceLimit = getStackTraceLimit()
   setStackTraceLimit(0)
   try {
@@ -319,7 +314,7 @@ export const tracer: <E, R>(
       fiber.setContext(prevServices)
       const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe()
       if (Exit.isSuccess(exit) && (!span.sampled || fiber.getRef(Tracer) === nativeTracer)) {
-        span.end(endTime, responseSpanExit(request, exit.value))
+        span.end(endTime, responseSpanExit(fiber, request, exit.value))
         return undefined
       }
       const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
@@ -333,10 +328,10 @@ export const tracer: <E, R>(
         // OpenTelemetry only treats 5xx responses as server span errors; interrupts still fail the span.
         spanExit = Option.isSome(cause) && (response.status >= 500 || Cause.hasInterrupts(cause.value))
           ? Exit.failCause(cause.value)
-          : responseSpanExit(request, response)
+          : responseSpanExit(fiber, request, response)
       } else {
         response = exit.value
-        spanExit = responseSpanExit(request, response)
+        spanExit = responseSpanExit(fiber, request, response)
       }
       if (span.sampled) {
         span.attribute("http.request.method", request.method)
@@ -434,7 +429,9 @@ export interface TrustedProxyOptions {
  * @category proxying
  * @since 4.0.0
  */
-export const xForwardedHeaders = (options: TrustedProxyOptions): HttpMiddleware => {
+export const xForwardedHeaders = (options: TrustedProxyOptions): <E, R>(
+  httpApp: Effect.Effect<HttpServerResponse, E, HttpServerRequest | R>
+) => Effect.Effect<HttpServerResponse, E, HttpServerRequest | R> => {
   const { trustedProxies } = options
   const isTrusted: Predicate<NetAddress.IpAddress> = typeof trustedProxies === "function"
     ? trustedProxies

package/src/http/HttpRouter.ts

@@ -284,7 +284,8 @@ function sliceRequestUrl(
     }
     while (index < url.length && !"/?;#".includes(url[index])) index++
   }
-  return request.modify({ url: index < url.length ? url.slice(index) : "/" })
+  const rest = url.slice(index)
+  return request.modify({ url: rest.startsWith("/") ? rest : "/" + rest })
 }
 
 function countSegments(prefix: string, ignoreDuplicateSlashes: boolean) {

package/src/http/HttpServerError.ts

@@ -23,7 +23,7 @@ import { hasProperty } from "../Predicate.ts"
 import type * as Request from "./HttpServerRequest.ts"
 import * as Respondable from "./HttpServerRespondable.ts"
 import * as Response from "./HttpServerResponse.ts"
-import * as UrlParams from "./UrlParams.ts"
+import * as internalUrlParams from "./internal/urlParams.ts"
 
 const TypeId = "~effect/http/HttpServerError"
 
@@ -280,7 +280,7 @@ export class ClientAbort extends Context.Service<ClientAbort, true>()("effect/ht
 }
 
 const formatMethodAndUrl = (request: Request.HttpServerRequest) =>
-  `${request.method} ${UrlParams.redactUrl(request.url)}`
+  `${request.method} ${internalUrlParams.toPath(request.url)}`
 
 const formatRequestMessage = (reason: string, description: string | undefined, info: string) => {
   const prefix = `${reason} (${info})`

package/src/http/HttpServerRequest.ts

@@ -77,7 +77,9 @@ export const TypeId = "~effect/http/HttpServerRequest"
  * creating adjusted request views. `upgrade` completes a WebSocket handshake
  * for `Upgrade: websocket`. Platforms that can hand over the connection, such
  * as Node, answer other protocols with `101 Switching Protocols` and expose
- * the raw connection.
+ * the raw connection. `upgradeWith` does the same and adds custom headers to
+ * the `101` response; `upgrade` is `upgradeWith({})`. WebSocket upgrades fail
+ * when custom headers are given.
  *
  * @stability unstable
  * @category models
@@ -99,6 +101,9 @@ export interface HttpServerRequest extends HttpIncomingMessage.HttpIncomingMessa
   readonly multipartStream: Stream.Stream<Multipart.Part, Multipart.MultipartError>
 
   readonly upgrade: Effect.Effect<Socket.Socket, HttpServerError>
+  readonly upgradeWith: (options: {
+    readonly headers?: Headers.Input | undefined
+  }) => Effect.Effect<Socket.Socket, HttpServerError>
 
   /**
    * Address of the directly connected peer. Trusted proxy middleware replaces
@@ -610,18 +615,23 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
     if (this.textEffect) {
       return this.textEffect
     }
-    this.textEffect = Effect.runSync(Effect.cached(
-      Effect.tryPromise({
-        try: () => this.source.text(),
-        catch: (cause) =>
-          new HttpServerError({
-            reason: new RequestParseError({
-              request: this,
-              cause
+    this.textEffect = Effect.withFiber((fiber) =>
+      fiber.getRef(HttpIncomingMessage.MaxBodySize) === undefined
+        ? Effect.tryPromise({
+          try: () => this.source.text(),
+          catch: (cause) =>
+            new HttpServerError({
+              reason: new RequestParseError({
+                request: this,
+                cause
+              })
             })
-          })
-      })
-    ))
+        })
+        : Effect.map(this.arrayBuffer, (buffer) => textDecoder.decode(buffer))
+    ).pipe(
+      Effect.cached,
+      Effect.runSync
+    )
     return this.textEffect
   }
 
@@ -686,22 +696,36 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
     if (this.arrayBufferEffect) {
       return this.arrayBufferEffect
     }
-    this.arrayBufferEffect = Effect.runSync(Effect.cached(
-      Effect.tryPromise({
-        try: () => this.source.arrayBuffer(),
+    this.arrayBufferEffect = Effect.withFiber((fiber) => {
+      const maxBodySize = fiber.getRef(HttpIncomingMessage.MaxBodySize)
+      return Effect.tryPromise({
+        try: (signal) =>
+          maxBodySize === undefined
+            ? this.source.arrayBuffer()
+            : readArrayBufferLimited(this.source, Number(maxBodySize), signal),
         catch: (cause) =>
           new HttpServerError({
             reason: new RequestParseError({
               request: this,
+              reason: cause instanceof BodyTooLargeError ? "BodyTooLarge" : "Parse",
               cause
             })
           })
       })
-    ))
+    }).pipe(
+      Effect.cached,
+      Effect.runSync
+    )
     return this.arrayBufferEffect
   }
 
   get upgrade(): Effect.Effect<Socket.Socket, HttpServerError> {
+    return this.upgradeWith({})
+  }
+
+  upgradeWith(
+    _options: { readonly headers?: Headers.Input | undefined }
+  ): Effect.Effect<Socket.Socket, HttpServerError> {
     return Effect.fail(
       new HttpServerError({
         reason: new RequestParseError({
@@ -916,6 +940,12 @@ class ClientRequestImpl extends Inspectable.Class implements HttpServerRequest {
   }
 
   get upgrade(): Effect.Effect<Socket.Socket, HttpServerError> {
+    return this.upgradeWith({})
+  }
+
+  upgradeWith(
+    _options: { readonly headers?: Headers.Input | undefined }
+  ): Effect.Effect<Socket.Socket, HttpServerError> {
     return Effect.fail(requestParseError(this, "Not an upgradeable ServerRequest"))
   }
 }
@@ -1080,6 +1110,62 @@ const isBodyInit = (u: unknown): u is BodyInit =>
 
 const textDecoder = new TextDecoder()
 
+class BodyTooLargeError extends Error {
+  constructor(maxBytes: number) {
+    super(`Request body exceeds ${maxBytes} bytes`)
+  }
+}
+
+const readArrayBufferLimited = async (
+  source: Request,
+  maxBytes: number,
+  signal: AbortSignal
+): Promise<ArrayBuffer> => {
+  const header = source.headers.get("content-length")
+  const contentLength = header !== null && /^\d+$/.test(header) ? Number(header) : undefined
+  if (contentLength !== undefined && contentLength > maxBytes) {
+    throw new BodyTooLargeError(maxBytes)
+  }
+  if (source.body === null) {
+    return new ArrayBuffer(0)
+  }
+  // A constructed request can understate its content-length, so bytes are
+  // counted on every runtime. Cancellation is not awaited, as the source's
+  // cleanup may never settle.
+  const limit = contentLength ?? maxBytes
+  const reader = source.body.getReader()
+  const cancel = () => {
+    reader.cancel().catch(() => {})
+  }
+  signal.addEventListener("abort", cancel, { once: true })
+  const chunks: Array<Uint8Array> = []
+  let bytes = 0
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      bytes += value.byteLength
+      if (bytes > limit) {
+        cancel()
+        throw bytes > maxBytes
+          ? new BodyTooLargeError(maxBytes)
+          : new Error(`Request body is longer than its content-length of ${contentLength}`)
+      }
+      chunks.push(value)
+    }
+  } finally {
+    signal.removeEventListener("abort", cancel)
+    reader.releaseLock()
+  }
+  const buffer = new Uint8Array(bytes)
+  let offset = 0
+  for (const chunk of chunks) {
+    buffer.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  return buffer.buffer
+}
+
 /**
  * Attempts to construct an absolute `URL` for a server request safely.
  *

package/src/http/HttpStaticServer.ts

@@ -121,7 +121,9 @@ export const make: (options: {
   ) => Effect.Effect<HttpServerResponse.HttpServerResponse, HttpServerError.HttpServerError> = Effect.fnUntraced(
     function*(request, filePath, fileSize) {
       const rangeHeader = request.method === "GET" ? request.headers["range"] : undefined
-      const shouldEvaluateConditionals = request.headers["if-none-match"] !== undefined ||
+      const shouldEvaluateConditionals = request.headers["if-match"] !== undefined ||
+        request.headers["if-unmodified-since"] !== undefined ||
+        request.headers["if-none-match"] !== undefined ||
         request.headers["if-modified-since"] !== undefined
 
       let fullResponse: HttpServerResponse.HttpServerResponse | undefined
@@ -446,6 +448,22 @@ const stripWeakEtagPrefix = (value: string): string => {
   return /^w\//i.test(trimmed) ? trimmed.slice(2) : trimmed;
 }
 
+// If-Match uses strong comparison (RFC 9110 §13.1.1), so weak tags never
+// match. Tags may contain commas, so the list is validated whole rather than
+// split, and a malformed list matches nothing.
+const entityTagList = /^[\s,]*(?:(?:W\/)?"[^"]*"\s*(?:,[\s,]*|$))*$/
+const entityTag = /(?:W\/)?"[^"]*"/g
+
+const matchesIfMatch = (ifMatch: string, etag: string | undefined): boolean => {
+  if (ifMatch.trim() === "*") {
+    return true
+  }
+  if (etag === undefined || !etag.startsWith("\"") || !entityTagList.test(ifMatch)) {
+    return false
+  }
+  return ifMatch.match(entityTag)?.includes(etag) ?? false
+}
+
 const matchesIfNoneMatch = (ifNoneMatch: string, etag: string | undefined): boolean => {
   const normalizedEtag = etag === undefined ? undefined : stripWeakEtagPrefix(etag)
   for (const candidate of ifNoneMatch.split(",")) {
@@ -463,18 +481,19 @@ const matchesIfNoneMatch = (ifNoneMatch: string, etag: string | undefined): bool
   return false
 }
 
-// An invalid date on either side disables the precondition (RFC 9110 §13.1.3).
-const isNotModifiedSince = (ifModifiedSince: string, lastModified: string | undefined): boolean => {
+// An invalid date on either side disables the precondition (RFC 9110 §13.1.3–4).
+const isModifiedSince = (since: string, lastModified: string | undefined): boolean | undefined => {
   if (lastModified === undefined) {
-    return false
+    return undefined
   }
-  const ifModifiedSinceDate = Headers.parseHttpDate(ifModifiedSince)
-  if (Result.isFailure(ifModifiedSinceDate)) {
-    return false
+  const sinceDate = Headers.parseHttpDate(since)
+  if (Result.isFailure(sinceDate)) {
+    return undefined
   }
   const lastModifiedDate = Headers.parseHttpDate(lastModified)
-  return Result.isSuccess(lastModifiedDate) &&
-    DateTime.toEpochMillis(lastModifiedDate.success) <= DateTime.toEpochMillis(ifModifiedSinceDate.success)
+  return Result.isSuccess(lastModifiedDate)
+    ? DateTime.toEpochMillis(lastModifiedDate.success) > DateTime.toEpochMillis(sinceDate.success)
+    : undefined
 }
 
 // Only a strong entity-tag can match (RFC 9110 §13.1.5). Weak tags start
@@ -485,21 +504,18 @@ const matchesIfRange = (ifRange: string, etag: string | undefined): boolean => {
   return value.startsWith("\"") && value === etag
 }
 
+// Headers a 304 must repeat from the 200 response (RFC 9110 §15.4.5), plus Last-Modified for revalidation.
+const notModifiedHeaders = ["cache-control", "content-location", "date", "etag", "expires", "last-modified", "vary"]
+
 const notModifiedResponse = (
   response: HttpServerResponse.HttpServerResponse
 ): HttpServerResponse.HttpServerResponse => {
   const headers: Record<string, string> = {}
-  const etag = response.headers["etag"]
-  if (etag !== undefined) {
-    headers["ETag"] = etag
-  }
-  const cacheControl = response.headers["cache-control"]
-  if (cacheControl !== undefined) {
-    headers["Cache-Control"] = cacheControl
-  }
-  const lastModified = response.headers["last-modified"]
-  if (lastModified !== undefined) {
-    headers["Last-Modified"] = lastModified
+  for (const name of notModifiedHeaders) {
+    const value = response.headers[name]
+    if (value !== undefined) {
+      headers[name] = value
+    }
   }
   return HttpServerResponse.empty({
     status: 304,
@@ -511,12 +527,25 @@ const evaluateConditionalRequest = (
   request: HttpServerRequest.HttpServerRequest,
   response: HttpServerResponse.HttpServerResponse
 ): HttpServerResponse.HttpServerResponse | undefined => {
+  const etag = response.headers["etag"]
+  const lastModified = response.headers["last-modified"]
+  const ifMatch = request.headers["if-match"]
+  if (ifMatch !== undefined) {
+    if (!matchesIfMatch(ifMatch, etag)) {
+      return HttpServerResponse.empty({ status: 412 })
+    }
+  } else {
+    const ifUnmodifiedSince = request.headers["if-unmodified-since"]
+    if (ifUnmodifiedSince !== undefined && isModifiedSince(ifUnmodifiedSince, lastModified) === true) {
+      return HttpServerResponse.empty({ status: 412 })
+    }
+  }
   const ifNoneMatch = request.headers["if-none-match"]
   if (ifNoneMatch !== undefined) {
-    return matchesIfNoneMatch(ifNoneMatch, response.headers["etag"]) ? notModifiedResponse(response) : undefined
+    return matchesIfNoneMatch(ifNoneMatch, etag) ? notModifiedResponse(response) : undefined
   }
   const ifModifiedSince = request.headers["if-modified-since"]
-  if (ifModifiedSince !== undefined && isNotModifiedSince(ifModifiedSince, response.headers["last-modified"])) {
+  if (ifModifiedSince !== undefined && isModifiedSince(ifModifiedSince, lastModified) === false) {
     return notModifiedResponse(response)
   }
   return undefined

package/src/http/MultipartParser/internal/contentType.ts

@@ -16,14 +16,14 @@
  * quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
  */
 const paramRE =
-  /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u{10ffff}]|\\[\v\u0020-\u{10ffff}])*"|[!#$%&'*+.^\w`|~-]+) */gu
+  /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\t\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u{10ffff}]|\\[\t\u0020-\u{10ffff}])*"|[!#$%&'*+.^\w`|~-]+) */gu
 
 /**
  * RegExp to match *( ";" disposition-parm ) in RFC 6266 sec 4.1, which allows
  * optional whitespace around separators
  */
 const dispositionParamRE =
-  /;[ \t]*([!#$%&'*+.^\w`|~-]+)[ \t]*=[ \t]*("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u{10ffff}]|\\[\v\u0020-\u{10ffff}])*"|[!#$%&'*+.^\w`|~-]+)[ \t]*/gu
+  /;[ \t]*([!#$%&'*+.^\w`|~-]+)[ \t]*=[ \t]*("(?:[\t\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u{10ffff}]|\\[\t\u0020-\u{10ffff}])*"|[!#$%&'*+.^\w`|~-]+)[ \t]*/gu
 
 /**
  * RegExp to match quoted-pair in RFC 7230 sec 3.2.6
@@ -31,7 +31,7 @@ const dispositionParamRE =
  * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
  * obs-text    = %x80-FF
  */
-const quotedPairRE = /\\([\v\u0020-\u{10ffff}])/gu
+const quotedPairRE = /\\([\t\u0020-\u{10ffff}])/gu
 
 /**
  * RegExp to match type in RFC 7231 sec 3.1.1.1

package/src/http/UrlParams.ts

@@ -870,7 +870,9 @@ const currentRedactedNames = (): ReadonlyArray<string | RegExp> =>
  *
  * **Details**
  *
- * Defaults include `AWSAccessKeyId`, `Signature`, `sig` and `X-Goog-Signature`.
+ * Defaults match the OpenTelemetry `url.full` list: `X-Amz-Signature`,
+ * `X-Amz-Credential`, `X-Amz-Security-Token`, `AWSAccessKeyId`, `Signature`,
+ * `sig` and `X-Goog-Signature`.
  * A custom list replaces the defaults. Matching uses `isRedactedName`.
  * Redaction leaves request URLs and parameter values unchanged. `Redacted`
  * values are redacted regardless of this list.
@@ -883,6 +885,9 @@ export const CurrentRedactedNames = Context.Reference<
   ReadonlyArray<string | RegExp>
 >("effect/http/UrlParams/CurrentRedactedNames", {
   defaultValue: () => [
+    "X-Amz-Signature",
+    "X-Amz-Credential",
+    "X-Amz-Security-Token",
     "AWSAccessKeyId",
     "Signature",
     "sig",

package/src/http/internal/compression.ts

@@ -155,13 +155,12 @@ const acceptMember = /^([a-z0-9!#$%&'*+.^_`|~-]+)(?:;q=(0(?:\.[0-9]{0,3})?|1(?:\
  * @internal
  */
 export const parseAcceptEncoding = (header: string): ReadonlyMap<string, number> | undefined => {
-  const trimmed = header.trim()
-  if (trimmed === "") {
-    return undefined
-  }
   const accepted = new Map<string, number>()
-  for (const part of trimmed.split(",")) {
+  for (const part of header.split(",")) {
     const member = part.trim().toLowerCase().replace(/[ \t]*;[ \t]*/g, ";")
+    if (member === "") {
+      continue
+    }
     const match = acceptMember.exec(member)
     if (match === null) {
       return undefined

package/src/http/internal/decompression.ts

@@ -124,6 +124,12 @@ export class DecompressedRequest extends Inspectable.Class implements HttpServer
     return this.inner.upgrade
   }
 
+  upgradeWith(
+    options: { readonly headers?: Headers.Input | undefined }
+  ): Effect.Effect<Socket.Socket, HttpServerError> {
+    return this.inner.upgradeWith(options)
+  }
+
   // Platform accessors such as `NodeHttpServerRequest.toServerResponse` read
   // the response handle from the request.
   get response(): unknown {

package/src/http/internal/httpBody.ts

@@ -11,9 +11,17 @@ export const updateHeaders = (headers: Headers.Headers, body: HttpBody.HttpBody)
   headers = body.contentType === undefined
     ? Headers.remove(headers, "content-type")
     : Headers.set(headers, "content-type", body.contentType)
-  return body.contentLength === undefined
+  return updateContentLength(headers, body)
+}
+
+/**
+ * @internal
+ */
+export const updateContentLength = (headers: Headers.Headers, body: HttpBody.HttpBody): Headers.Headers => {
+  const contentLength = body._tag === "Empty" || body._tag === "FormData" ? undefined : body.contentLength
+  return contentLength === undefined
     ? Headers.remove(headers, "content-length")
-    : Headers.set(headers, "content-length", body.contentLength.toString())
+    : Headers.set(headers, "content-length", contentLength.toString())
 }
 
 /**

package/src/http/internal/urlParams.ts

@@ -3,3 +3,32 @@ import * as Redacted from "../../Redacted.ts"
 /** @internal */
 export const unwrap = (value: string | Redacted.Redacted): string =>
   typeof value === "string" ? value : Redacted.value(value)
+
+/** @internal */
+export const stripSearchAndHash = (url: string): string => {
+  const queryIndex = url.indexOf("?")
+  const hashIndex = url.indexOf("#")
+
+  if (queryIndex === -1) {
+    return hashIndex === -1 ? url : url.slice(0, hashIndex)
+  }
+  if (hashIndex === -1) {
+    return url.slice(0, queryIndex)
+  }
+  return url.slice(0, Math.min(queryIndex, hashIndex))
+}
+
+const originForm = /^\/(?![/\\])/
+
+/** @internal */
+export const toPath = (url: string): string => {
+  // Origin-form targets and "*" are already paths; absolute URLs can carry credentials.
+  if (url === "*" || originForm.test(url)) {
+    return stripSearchAndHash(url)
+  }
+  try {
+    return new URL(url, "http://localhost").pathname
+  } catch {
+    return "<invalid URL>"
+  }
+}

package/src/http-api/HttpApi.ts

@@ -371,12 +371,9 @@ export class AdditionalSchemas extends Context.Service<
  *
  * Header codecs receive all HTTP headers, including undeclared transport
  * headers such as `content-type`, `content-length`, `host`, `user-agent` and
- * proxy headers. Without `HeadersParseOptions`, headers use `ParseOptions`:
- *
- * - `onExcessProperty: "error"` rejects real requests and `WithHeaders`
- *   responses with transport headers.
- * - `onExcessProperty: "preserve"` includes transport headers in the decoded
- *   value.
+ * proxy headers. Without `HeadersParseOptions`, headers use `ParseOptions`, so
+ * `onExcessProperty: "error"` rejects real requests and `WithHeaders` responses
+ * with transport headers.
  *
  * Set `HeadersParseOptions` to `{}` at the API level to use Schema defaults for
  * headers, even if an endpoint sets `ParseOptions`.