effect 4.0.6 → 4.1.0

package/src/http/HttpClientError.ts

@@ -92,6 +92,15 @@ const formatMessage = (reason: string, description: string | undefined, info: st
 const formatMethodAndUrl = (request: HttpClientRequest.HttpClientRequest) =>
   `${request.method} ${UrlParams.redactUrl(request.url)}`
 
+// Serialized reasons carry the same request and response information as the
+// message, so headers, URL parameters and bodies stay out of logs. The full
+// objects remain available through the `request` and `response` properties.
+const reasonToJSON = (reason: HttpClientErrorReason, json: unknown) => ({
+  ...(json as object),
+  request: { _id: "HttpClientRequest", method: reason.request.method, url: UrlParams.redactUrl(reason.request.url) },
+  ...("response" in reason ? { response: { _id: "HttpClientResponse", status: reason.response.status } } : undefined)
+})
+
 /**
  * Error describing transport-level failures that occur while sending an HTTP request.
  *
@@ -123,6 +132,10 @@ export class TransportError extends Data.TaggedError("TransportError")<{
   override get message() {
     return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl)
   }
+
+  override toJSON(): unknown {
+    return reasonToJSON(this, super.toJSON())
+  }
 }
 
 /**
@@ -156,6 +169,10 @@ export class EncodeError extends Data.TaggedError("EncodeError")<{
   override get message() {
     return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl)
   }
+
+  override toJSON(): unknown {
+    return reasonToJSON(this, super.toJSON())
+  }
 }
 
 /**
@@ -189,6 +206,10 @@ export class InvalidUrlError extends Data.TaggedError("InvalidUrlError")<{
   override get message() {
     return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl)
   }
+
+  override toJSON(): unknown {
+    return reasonToJSON(this, super.toJSON())
+  }
 }
 
 /**
@@ -224,10 +245,15 @@ export class StatusCodeError extends Data.TaggedError("StatusCodeError")<{
     const info = `${this.response.status} ${this.methodAndUrl}`
     return formatMessage(formatReason(this._tag), this.description, info)
   }
+
+  override toJSON(): unknown {
+    return reasonToJSON(this, super.toJSON())
+  }
 }
 
 /**
- * Response error for failures while decoding an HTTP response body.
+ * Response error for failures while decoding an HTTP response, including a
+ * response with an undeclared status.
  *
  * @stability unstable
  * @category errors
@@ -259,6 +285,10 @@ export class DecodeError extends Data.TaggedError("DecodeError")<{
     const info = `${this.response.status} ${this.methodAndUrl}`
     return formatMessage(formatReason(this._tag), this.description, info)
   }
+
+  override toJSON(): unknown {
+    return reasonToJSON(this, super.toJSON())
+  }
 }
 
 /**
@@ -294,6 +324,10 @@ export class EmptyBodyError extends Data.TaggedError("EmptyBodyError")<{
     const info = `${this.response.status} ${this.methodAndUrl}`
     return formatMessage(formatReason(this._tag), this.description, info)
   }
+
+  override toJSON(): unknown {
+    return reasonToJSON(this, super.toJSON())
+  }
 }
 
 /**

package/src/http/HttpClientRequest.ts

@@ -56,7 +56,11 @@ export const isHttpClientRequest = (u: unknown): u is HttpClientRequest => hasPr
  */
 export interface HttpClientRequest extends Inspectable.Inspectable, Pipeable {
   readonly [TypeId]: typeof TypeId
-  readonly method: HttpMethod
+  /**
+   * The request method, which may be a method outside the known `HttpMethod`
+   * literals when the request was converted from a Web or server request.
+   */
+  readonly method: string
   readonly url: string
   readonly urlParams: UrlParams.UrlParams
   readonly hash: Option.Option<string>
@@ -126,7 +130,7 @@ const Proto = {
  * @since 4.0.0
  */
 export function makeWith(
-  method: HttpMethod,
+  method: string,
   url: string,
   urlParams: UrlParams.Input,
   hash: Option.Option<string>,
@@ -1171,7 +1175,7 @@ export interface CompressionOptions {
  * `Content-Length`. The compressed body does not retain the original lazy text.
  * Stream bodies are compressed lazily and have their content length removed.
  * They still require a client runtime that supports streaming request bodies
- * (Fetch requires `duplex: "half"`, which Safari and Firefox do not support).
+ * (stable Safari and Firefox do not; see `FetchHttpClient.StreamBodyFallback`).
  *
  * Returns the original request unchanged for empty, FormData, and raw bodies,
  * bodies with a known length below `options.minSize`, or requests with any
@@ -1203,7 +1207,7 @@ export const compressBody: {
    * `Content-Length`. The compressed body does not retain the original lazy text.
    * Stream bodies are compressed lazily and have their content length removed.
    * They still require a client runtime that supports streaming request bodies
-   * (Fetch requires `duplex: "half"`, which Safari and Firefox do not support).
+   * (stable Safari and Firefox do not; see `FetchHttpClient.StreamBodyFallback`).
    *
    * Returns the original request unchanged for empty, FormData, and raw bodies,
    * bodies with a known length below `options.minSize`, or requests with any
@@ -1235,7 +1239,7 @@ export const compressBody: {
    * `Content-Length`. The compressed body does not retain the original lazy text.
    * Stream bodies are compressed lazily and have their content length removed.
    * They still require a client runtime that supports streaming request bodies
-   * (Fetch requires `duplex: "half"`, which Safari and Firefox do not support).
+   * (stable Safari and Firefox do not; see `FetchHttpClient.StreamBodyFallback`).
    *
    * Returns the original request unchanged for empty, FormData, and raw bodies,
    * bodies with a known length below `options.minSize`, or requests with any
@@ -1273,7 +1277,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
+        )
     )
   }
 )
@@ -1686,16 +1698,15 @@ export function toUrl(self: HttpClientRequest): Option.Option<URL> {
  * @since 4.0.0
  */
 export const fromWeb = (request: globalThis.Request): HttpClientRequest => {
-  const method = request.method.toUpperCase() as HttpMethod
-  return modify(empty, {
-    method,
+  const method = request.method.toUpperCase()
+  return modify(makeWith(method, "", UrlParams.empty, Option.none(), Headers.empty, HttpBody.empty), {
     url: new URL(request.url),
     headers: request.headers,
     body: fromWebBody(request, method)
   })
 }
 
-const fromWebBody = (request: globalThis.Request, method: HttpMethod): HttpBody.HttpBody => {
+const fromWebBody = (request: globalThis.Request, method: string): HttpBody.HttpBody => {
   if (!hasBody(method) || request.body === null) {
     return HttpBody.empty
   }

package/src/http/HttpClientResponse.ts

@@ -25,6 +25,7 @@ import * as Headers from "./Headers.ts"
 import * as Error from "./HttpClientError.ts"
 import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
+import * as internalUrlParams from "./internal/urlParams.ts"
 import { getWebSource, WebSourceSymbol } from "./internal/webResponse.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -454,9 +455,9 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
   }
 
   get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, Error.HttpClientError> {
-    return Effect.flatMap(this.text, (_) =>
+    return Effect.flatMap(this.arrayBuffer, (bytes) =>
       Effect.try({
-        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        try: () => UrlParams.fromInput(internalUrlParams.fromBody(bytes)),
         catch: (cause) =>
           new Error.HttpClientError({
             reason: new Error.DecodeError({

package/src/http/HttpMethod.ts

@@ -57,12 +57,20 @@ export declare namespace HttpMethod {
 /**
  * Returns `true` when a method can carry a request body and narrows it to `HttpMethod.WithBody`.
  *
+ * **Details**
+ *
+ * Methods outside the known `HttpMethod` literals, such as a received
+ * `"PROPFIND"`, are treated as capable of carrying a body but are not narrowed.
+ *
  * @stability unstable
  * @category guards
  * @since 4.0.0
  */
-export const hasBody = (method: HttpMethod): method is HttpMethod.WithBody =>
-  method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE"
+export function hasBody(method: HttpMethod): method is HttpMethod.WithBody
+export function hasBody(method: string): boolean
+export function hasBody(method: string): boolean {
+  return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE"
+}
 
 /**
  * Provides a readonly set containing every supported `HttpMethod` literal.

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

@@ -32,10 +32,11 @@ import * as Headers from "./Headers.ts"
 import * as HttpBody from "./HttpBody.ts"
 import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
-import { hasBody, type HttpMethod } from "./HttpMethod.ts"
+import { hasBody } from "./HttpMethod.ts"
 import { HttpServerError, type RequestError, RequestParseError } from "./HttpServerError.ts"
 import * as bodyInternal from "./internal/httpBody.ts"
 import * as lazyStream from "./internal/lazyStream.ts"
+import * as internalUrlParams from "./internal/urlParams.ts"
 import * as Multipart from "./Multipart.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -77,7 +78,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
@@ -88,7 +91,11 @@ export interface HttpServerRequest extends HttpIncomingMessage.HttpIncomingMessa
   readonly source: object
   readonly url: string
   readonly originalUrl: string
-  readonly method: HttpMethod
+  /**
+   * The uppercase request method as received, which may be a method outside
+   * the known `HttpMethod` literals (for example `"PROPFIND"`).
+   */
+  readonly method: string
   readonly cookies: ReadonlyRecord<string, string>
 
   readonly multipart: Effect.Effect<
@@ -99,6 +106,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
@@ -558,8 +568,8 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
       options.protocol ?? this.protocol
     )
   }
-  get method(): HttpMethod {
-    return this.source.method.toUpperCase() as HttpMethod
+  get method(): string {
+    return this.source.method.toUpperCase()
   }
   get originalUrl() {
     return this.source.url
@@ -607,22 +617,7 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
 
   private textEffect: Effect.Effect<string, HttpServerError> | undefined
   get text(): Effect.Effect<string, HttpServerError> {
-    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
-            })
-          })
-      })
-    ))
-    return this.textEffect
+    return this.textEffect ??= Effect.map(this.arrayBuffer, (buffer) => textDecoder.decode(buffer))
   }
 
   get json(): Effect.Effect<Schema.Json, HttpServerError> {
@@ -640,9 +635,9 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
   }
 
   get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, HttpServerError> {
-    return Effect.flatMap(this.text, (_) =>
+    return Effect.flatMap(this.arrayBuffer, (bytes) =>
       Effect.try({
-        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        try: () => UrlParams.fromInput(internalUrlParams.fromBody(bytes)),
         catch: (cause) =>
           new HttpServerError({
             reason: new RequestParseError({
@@ -686,22 +681,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({
@@ -773,7 +782,7 @@ class ClientRequestImpl extends Inspectable.Class implements HttpServerRequest {
     )
   }
 
-  get method(): HttpMethod {
+  get method(): string {
     return this.source.method
   }
 
@@ -868,9 +877,9 @@ class ClientRequestImpl extends Inspectable.Class implements HttpServerRequest {
   }
 
   get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, HttpServerError> {
-    return Effect.flatMap(this.text, (_) =>
+    return Effect.flatMap(this.bytes, (bytes) =>
       Effect.try({
-        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        try: () => UrlParams.fromInput(internalUrlParams.fromBody(bytes)),
         catch: (cause) => requestParseError(this, undefined, cause)
       }))
   }
@@ -916,6 +925,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 +1095,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/HttpServerResponse.ts

@@ -38,6 +38,7 @@ 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 internalUrlParams from "./internal/urlParams.ts"
 import * as Template from "./Template.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -1653,9 +1654,9 @@ class ServerHttpClientResponse extends Inspectable.Class implements HttpClientRe
   }
 
   get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, HttpClientError.HttpClientError> {
-    return Effect.flatMap(this.text, (_) =>
+    return Effect.flatMap(this.bytes, (bytes) =>
       Effect.try({
-        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        try: () => UrlParams.fromInput(internalUrlParams.fromBody(bytes)),
         catch: (cause) =>
           new HttpClientError.HttpClientError({
             reason: new HttpClientError.DecodeError({