effect 4.0.0-beta.99 → 4.0.0-rc.109

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"
 
@@ -375,6 +376,63 @@ export const setHeaders: {
     self.body
   ))
 
+/**
+ * Transforms the request headers with the provided function, returning a new request.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const updateHeaders: {
+  /**
+   * Transforms the request headers with the provided function, returning a new request.
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  (f: (headers: Headers.Headers) => Headers.Headers): (self: HttpClientRequest) => HttpClientRequest
+  /**
+   * Transforms the request headers with the provided function, returning a new request.
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  (self: HttpClientRequest, f: (headers: Headers.Headers) => Headers.Headers): HttpClientRequest
+} = dual(2, (self: HttpClientRequest, f: (headers: Headers.Headers) => Headers.Headers): HttpClientRequest =>
+  makeWith(
+    self.method,
+    self.url,
+    self.urlParams,
+    self.hash,
+    f(self.headers),
+    self.body
+  ))
+
+/**
+ * Removes a single request header by name, returning a new request.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const removeHeader: {
+  /**
+   * Removes a single request header by name, returning a new request.
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  (key: string): (self: HttpClientRequest) => HttpClientRequest
+  /**
+   * Removes a single request header by name, returning a new request.
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  (self: HttpClientRequest, key: string): HttpClientRequest
+} = dual(
+  2,
+  (self: HttpClientRequest, key: string): HttpClientRequest => updateHeaders(self, Headers.remove(key))
+)
+
 /**
  * Sets the `Authorization` header using HTTP Basic authentication credentials.
  *
@@ -817,23 +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())
-    }
-  }
   return makeWith(
     self.method,
     self.url,
     self.urlParams,
     self.hash,
-    headers,
+    bodyInternal.updateHeaders(self.headers, body),
     body
   )
 })

package/src/unstable/http/HttpClientResponse.ts

@@ -213,21 +213,21 @@ export const matchStatus: {
 /**
  * Succeeds with the response when its status satisfies the predicate, otherwise fails with `HttpClientError`.
  *
- * @category filters
+ * @category filtering
  * @since 4.0.0
  */
 export const filterStatus: {
   /**
    * Succeeds with the response when its status satisfies the predicate, otherwise fails with `HttpClientError`.
    *
-   * @category filters
+   * @category filtering
    * @since 4.0.0
    */
   (f: (status: number) => boolean): (self: HttpClientResponse) => Effect.Effect<HttpClientResponse, Error.HttpClientError>
   /**
    * Succeeds with the response when its status satisfies the predicate, otherwise fails with `HttpClientError`.
    *
-   * @category filters
+   * @category filtering
    * @since 4.0.0
    */
   (self: HttpClientResponse, f: (status: number) => boolean): Effect.Effect<HttpClientResponse, Error.HttpClientError>
@@ -250,7 +250,7 @@ export const filterStatus: {
 /**
  * Succeeds with the response only when its status is in the 2xx range, otherwise fails with `HttpClientError`.
  *
- * @category filters
+ * @category filtering
  * @since 4.0.0
  */
 export const filterStatusOk = (self: HttpClientResponse): Effect.Effect<HttpClientResponse, Error.HttpClientError> =>
@@ -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/HttpEffect.ts

@@ -25,7 +25,7 @@ import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as Response from "./HttpServerResponse.ts"
-import { appendPreResponseHandlerUnsafe, requestPreResponseHandlers } from "./internal/preResponseHandler.ts"
+import * as preResponseHandler from "./internal/preResponseHandler.ts"
 
 /**
  * Runs an HTTP server effect, sends the produced response with the supplied handler, and converts failures into HTTP responses.
@@ -46,7 +46,7 @@ export const toHandled = <E, R, EH, RH>(
       const fiber = Fiber.getCurrent()!
       reportCauseUnsafe(fiber, cause)
       const request = Context.getUnsafe(fiber.context, HttpServerRequest)
-      const handler = requestPreResponseHandlers.get(request.source)
+      const handler = preResponseHandler.requestPreResponseHandlers.get(request.source)
       const cont = cause.reasons.length === 0 ? Effect.succeed(response) : Effect.failCause(cause)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
@@ -69,7 +69,7 @@ export const toHandled = <E, R, EH, RH>(
     onSuccess: (response) => {
       const fiber = Fiber.getCurrent()!
       const request = Context.getUnsafe(fiber.context, HttpServerRequest)
-      const handler = requestPreResponseHandlers.get(request.source)
+      const handler = preResponseHandler.requestPreResponseHandlers.get(request.source)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
         return Effect.mapEager(handleResponse(request, response), () => response)
@@ -172,7 +172,7 @@ const scoped = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
 /**
  * Function run with the current request and response just before the response is sent, allowing the response to be replaced or failing with `HttpServerError`.
  *
- * @category Pre-response handlers
+ * @category handlers
  * @since 4.0.0
  */
 export type PreResponseHandler = (
@@ -183,7 +183,7 @@ export type PreResponseHandler = (
 /**
  * Registers an additional pre-response handler for the current HTTP server request.
  *
- * @category fiber refs
+ * @category handlers
  * @since 4.0.0
  */
 export const appendPreResponseHandler = (handler: PreResponseHandler): Effect.Effect<void, never, HttpServerRequest> =>
@@ -192,34 +192,35 @@ export const appendPreResponseHandler = (handler: PreResponseHandler): Effect.Ef
     return Effect.void
   })
 
-export {
-  /**
-   * Registers a pre-response handler for the supplied HTTP server request.
-   *
-   * @category fiber refs
-   * @since 4.0.0
-   */
-  appendPreResponseHandlerUnsafe
-}
+/**
+ * Registers a pre-response handler for the supplied HTTP server request.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const appendPreResponseHandlerUnsafe: (
+  request: HttpServerRequest,
+  handler: PreResponseHandler
+) => void = preResponseHandler.appendPreResponseHandlerUnsafe
 
 /**
  * Runs an effect after registering a pre-response handler for the current HTTP server request.
  *
- * @category fiber refs
+ * @category handlers
  * @since 4.0.0
  */
 export const withPreResponseHandler: {
   /**
    * Runs an effect after registering a pre-response handler for the current HTTP server request.
    *
-   * @category fiber refs
+   * @category handlers
    * @since 4.0.0
    */
   (handler: PreResponseHandler): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>
   /**
    * Runs an effect after registering a pre-response handler for the current HTTP server request.
    *
-   * @category fiber refs
+   * @category handlers
    * @since 4.0.0
    */
   <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler): Effect.Effect<A, E, R | HttpServerRequest>
@@ -227,14 +228,14 @@ export const withPreResponseHandler: {
   /**
    * Runs an effect after registering a pre-response handler for the current HTTP server request.
    *
-   * @category fiber refs
+   * @category handlers
    * @since 4.0.0
    */
   (handler: PreResponseHandler) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>,
   /**
    * Runs an effect after registering a pre-response handler for the current HTTP server request.
    *
-   * @category fiber refs
+   * @category handlers
    * @since 4.0.0
    */
   <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler) => Effect.Effect<A, E, R | HttpServerRequest>
@@ -268,18 +269,18 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
     )
     return Effect.void
   }, middleware)
-  return (request: Request, reqContext?: Context.Context<never> | undefined): Promise<globalThis.Response> =>
+  return (request: Request, _context?: Context.Context<never> | undefined): Promise<globalThis.Response> =>
     new Promise((resolve) => {
-      const contextMap = new Map<string, any>(context.mapUnsafe)
-      if (Context.isContext(reqContext)) {
-        for (const [key, value] of reqContext.mapUnsafe) {
-          contextMap.set(key, value)
+      let reqContext = context
+      if (Context.isContext(_context)) {
+        for (const [key, value] of _context.mapUnsafe) {
+          reqContext = Context.addUnsafe(reqContext, key, value)
         }
       }
       const httpServerRequest = Request.fromWeb(request)
-      contextMap.set(HttpServerRequest.key, httpServerRequest)
+      reqContext = Context.add(reqContext, HttpServerRequest, httpServerRequest)
       ;(httpServerRequest as any)[resolveSymbol] = resolve
-      const fiber = Effect.runForkWith(Context.makeUnsafe(contextMap))(httpApp as any)
+      const fiber = Effect.runForkWith(reqContext)(httpApp as any)
       request.signal?.addEventListener("abort", () => {
         fiber.interruptUnsafe(undefined, ClientAbort.annotation)
       }, { once: true })

package/src/unstable/http/HttpMethod.ts

@@ -51,7 +51,7 @@ export declare namespace HttpMethod {
 /**
  * Returns `true` when a method can carry a request body and narrows it to `HttpMethod.WithBody`.
  *
- * @category predicates
+ * @category guards
  * @since 4.0.0
  */
 export const hasBody = (method: HttpMethod): method is HttpMethod.WithBody =>
@@ -107,18 +107,15 @@ export const allShort = [
  *
  * **Example** (Checking HTTP method values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { HttpMethod } from "effect/unstable/http"
  *
- * console.log(HttpMethod.isHttpMethod("GET"))
- * // true
- * console.log(HttpMethod.isHttpMethod("get"))
- * // false
- * console.log(HttpMethod.isHttpMethod(1))
- * // false
+ * HttpMethod.isHttpMethod("GET") // => true
+ * HttpMethod.isHttpMethod("get") // => false
+ * HttpMethod.isHttpMethod(1) // => false
  * ```
  *
- * @category refinements
+ * @category guards
  * @since 4.0.0
  */
 export const isHttpMethod = (u: unknown): u is HttpMethod => all.has(u as HttpMethod)

package/src/unstable/http/HttpMiddleware.ts

@@ -23,12 +23,15 @@ import type { ReadonlyRecord } from "../../Record.ts"
 import { TracerEnabled } from "../../References.ts"
 import { ParentSpan } from "../../Tracer.ts"
 import * as Headers from "./Headers.ts"
+import type { CompressionAlgorithm } from "./HttpPlatform.ts"
+import { HttpPlatform } from "./HttpPlatform.ts"
 import { causeResponseStripped } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import * as Response from "./HttpServerResponse.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
+import * as compressionInternal from "./internal/compression.ts"
 import { appendPreResponseHandlerUnsafe } from "./internal/preResponseHandler.ts"
 
 /**
@@ -84,7 +87,7 @@ const stripSearchAndHash = (url: string): string => {
 /**
  * Runs an effect with HTTP response logging disabled for the current server request.
  *
- * @category Logger
+ * @category logging
  * @since 4.0.0
  */
 export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | HttpServerRequest> =>
@@ -97,7 +100,7 @@ export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effec
 /**
  * Context reference for a predicate that disables server-side tracing for matching requests.
  *
- * @category Tracer
+ * @category services
  * @since 4.0.0
  */
 export const TracerDisabledWhen = Context.Reference<Predicate<HttpServerRequest>>(
@@ -108,7 +111,7 @@ export const TracerDisabledWhen = Context.Reference<Predicate<HttpServerRequest>
 /**
  * Creates a layer that disables server-side tracing for requests whose URL exactly matches one of the supplied URLs.
  *
- * @category Tracer
+ * @category layers
  * @since 4.0.0
  */
 export const layerTracerDisabledForUrls = (
@@ -118,7 +121,7 @@ export const layerTracerDisabledForUrls = (
 /**
  * Context reference for generating server span names from HTTP server requests.
  *
- * @category Tracer
+ * @category services
  * @since 4.0.0
  */
 export const SpanNameGenerator = Context.Reference<(request: HttpServerRequest) => string>(
@@ -129,7 +132,7 @@ export const SpanNameGenerator = Context.Reference<(request: HttpServerRequest)
 /**
  * Middleware that logs sent HTTP responses with request method, request URL, and response status annotations.
  *
- * @category Logger
+ * @category logging
  * @since 4.0.0
  */
 export const logger: <E, R>(
@@ -170,7 +173,7 @@ export const logger: <E, R>(
 /**
  * Middleware that creates a server trace span for each request and records request and response HTTP attributes.
  *
- * @category Tracer
+ * @category tracing
  * @since 4.0.0
  */
 export const tracer: <E, R>(
@@ -193,32 +196,6 @@ export const tracer: <E, R>(
       fiber.setContext(prevServices)
       const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe()
       fiber.currentDispatcher.scheduleTask(() => {
-        const url = Request.toURL(request)
-        if (Option.isSome(url) && (url.value.username !== "" || url.value.password !== "")) {
-          url.value.username = "REDACTED"
-          url.value.password = "REDACTED"
-        }
-        const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
-        const requestHeaders = Headers.redact(request.headers, redactedHeaderNames)
-        span.attribute("http.request.method", request.method)
-        if (Option.isSome(url)) {
-          span.attribute("url.full", url.value.toString())
-          span.attribute("url.path", url.value.pathname)
-          const query = url.value.search.slice(1)
-          if (query !== "") {
-            span.attribute("url.query", url.value.search.slice(1))
-          }
-          span.attribute("url.scheme", url.value.protocol.slice(0, -1))
-        }
-        if (request.headers["user-agent"] !== undefined) {
-          span.attribute("user_agent.original", request.headers["user-agent"])
-        }
-        for (const name in requestHeaders) {
-          span.attribute(`http.request.header.${name}`, String(requestHeaders[name]))
-        }
-        if (Option.isSome(request.remoteAddress)) {
-          span.attribute("client.address", request.remoteAddress.value)
-        }
         let response: HttpServerResponse
         let spanExit = exit
         if (Exit.isFailure(exit)) {
@@ -228,10 +205,38 @@ export const tracer: <E, R>(
         } else {
           response = exit.value
         }
-        span.attribute("http.response.status_code", response.status)
-        const responseHeaders = Headers.redact(response.headers, redactedHeaderNames)
-        for (const name in responseHeaders) {
-          span.attribute(`http.response.header.${name}`, String(responseHeaders[name]))
+        if (span.sampled) {
+          const url = Request.toURL(request)
+          if (Option.isSome(url) && (url.value.username !== "" || url.value.password !== "")) {
+            url.value.username = "REDACTED"
+            url.value.password = "REDACTED"
+          }
+          const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
+          const requestHeaders = Headers.redact(request.headers, redactedHeaderNames)
+          span.attribute("http.request.method", request.method)
+          if (Option.isSome(url)) {
+            span.attribute("url.full", url.value.toString())
+            span.attribute("url.path", url.value.pathname)
+            const query = url.value.search.slice(1)
+            if (query !== "") {
+              span.attribute("url.query", url.value.search.slice(1))
+            }
+            span.attribute("url.scheme", url.value.protocol.slice(0, -1))
+          }
+          if (request.headers["user-agent"] !== undefined) {
+            span.attribute("user_agent.original", request.headers["user-agent"])
+          }
+          for (const name in requestHeaders) {
+            span.attribute(`http.request.header.${name}`, String(requestHeaders[name]))
+          }
+          if (Option.isSome(request.remoteAddress)) {
+            span.attribute("client.address", request.remoteAddress.value)
+          }
+          span.attribute("http.response.status_code", response.status)
+          const responseHeaders = Headers.redact(response.headers, redactedHeaderNames)
+          for (const name in responseHeaders) {
+            span.attribute(`http.response.header.${name}`, String(responseHeaders[name]))
+          }
         }
         span.end(endTime, spanExit)
       }, 0)
@@ -243,7 +248,7 @@ export const tracer: <E, R>(
 /**
  * Middleware that trusts `X-Forwarded-Host` and `X-Forwarded-For`, updating the request host header and remote address.
  *
- * @category Proxying
+ * @category proxying
  * @since 4.0.0
  */
 export const xForwardedHeaders = make((httpApp) =>
@@ -263,7 +268,7 @@ export const xForwardedHeaders = make((httpApp) =>
 /**
  * Middleware that parses the current request URL's search parameters and provides them as `ParsedSearchParams`.
  *
- * @category search params
+ * @category parsing
  * @since 4.0.0
  */
 export const searchParamsParser = <E, R>(
@@ -283,7 +288,7 @@ export const searchParamsParser = <E, R>(
 /**
  * Middleware that handles CORS preflight requests and adds configured CORS headers to HTTP responses.
  *
- * @category CORS
+ * @category middleware
  * @since 4.0.0
  */
 export const cors = (options?: {
@@ -401,3 +406,161 @@ export const cors = (options?: {
       return httpApp
     })
 }
+
+/**
+ * Middleware that compresses HTTP response bodies based on the request's
+ * `Accept-Encoding` header.
+ *
+ * **Details**
+ *
+ * Content negotiation follows RFC 9110: the first algorithm in server
+ * preference order that the client accepts with a positive q-value and the
+ * platform supports is used. When no algorithm is acceptable the response is
+ * sent uncompressed.
+ *
+ * The body transform is performed by the `HttpPlatform` service.
+ *
+ * Responses are skipped when the status is 1xx, 204, 206, or 304, when a
+ * `Content-Encoding` is already present, when `Cache-Control: no-transform`
+ * is set, when the content type is absent or not compressible, when a known
+ * body length is below `minSize`, or when the body is empty or `FormData`. A
+ * response carrying `Content-Encoding: identity` opts out of compression and
+ * has the header stripped before sending.
+ *
+ * `Vary: Accept-Encoding` is set on every response that was eligible by
+ * status and content type, including ones skipped by negotiation or
+ * `minSize`.
+ *
+ * Do not combine this middleware with Deno's automatic response compression.
+ * On edge runtimes that already apply automatic compression, the middleware
+ * is unnecessary. Platforms backed by Web `CompressionStream` also cannot
+ * explicitly flush each input chunk, so incremental delivery depends on the
+ * runtime's implementation.
+ *
+ * **Security**
+ *
+ * Compression can expose secrets through BREACH-style attacks when one
+ * response contains both secret data and attacker-controlled input and an
+ * attacker can observe the compressed response length. For affected routes,
+ * disable compression with `Content-Encoding: identity` or
+ * `Cache-Control: no-transform`, or use `compressible` to restrict which
+ * response content types can be compressed.
+ *
+ * @category compression
+ * @since 4.0.0
+ */
+export const compression = (
+  options?: {
+    /**
+     * Server preference order. Negotiation picks the first accepted algorithm
+     * supported by the platform. Defaults to `["br", "gzip", "deflate"]`;
+     * `zstd` must be explicitly opted into.
+     */
+    readonly algorithms?: ReadonlyArray<CompressionAlgorithm> | undefined
+    /**
+     * Minimum body size in bytes when the length is known. Unknown-length bodies
+     * are always compressed. Defaults to `1024`.
+     */
+    readonly minSize?: number | undefined
+    /** Replaces the default content-type predicate. */
+    readonly compressible?: ((contentType: string) => boolean) | undefined
+    /** Per-algorithm levels. Platforms without a level knob ignore them. */
+    readonly levels?: {
+      readonly gzip?: number | undefined
+      readonly deflate?: number | undefined
+      readonly br?: number | undefined
+      readonly zstd?: number | undefined
+    } | undefined
+  } | undefined
+): <E, R>(
+  httpApp: Effect.Effect<HttpServerResponse, E, R>
+) => Effect.Effect<HttpServerResponse, E, R | HttpServerRequest | HttpPlatform> => {
+  const preferred = options?.algorithms ?? defaultAlgorithms
+  const minSize = options?.minSize ?? 1024
+  const compressible = options?.compressible ?? compressionInternal.defaultCompressible
+  const levels = { ...defaultLevels, ...options?.levels }
+  const levelOptions: Record<CompressionAlgorithm, { readonly level: number | undefined }> = {
+    gzip: { level: levels.gzip },
+    deflate: { level: levels.deflate },
+    br: { level: levels.br },
+    zstd: { level: levels.zstd }
+  }
+  const transform = (
+    compression: HttpPlatform["Service"]["compression"],
+    acceptEncoding: string | undefined,
+    response: HttpServerResponse
+  ): Effect.Effect<HttpServerResponse> => {
+    if (
+      response.status < 200 ||
+      response.status === 204 ||
+      response.status === 206 ||
+      response.status === 304
+    ) {
+      return Effect.succeed(response)
+    }
+    const currentEncoding = response.headers["content-encoding"]
+    if (currentEncoding !== undefined) {
+      return Effect.succeed(
+        currentEncoding.trim().toLowerCase() === "identity"
+          ? Response.removeHeader(response, "content-encoding")
+          : response
+      )
+    }
+    const body = response.body
+    if (body._tag === "Empty" || body._tag === "FormData") {
+      return Effect.succeed(response)
+    }
+    const cacheControl = response.headers["cache-control"]
+    if (cacheControl !== undefined && noTransformRegex.test(cacheControl)) {
+      return Effect.succeed(response)
+    }
+    const contentType = response.headers["content-type"] ?? body.contentType
+    if (contentType === undefined || !compressible(contentType)) {
+      return Effect.succeed(response)
+    }
+    const algorithm = compressionInternal.negotiate(acceptEncoding, preferred, compression.algorithms)
+    if (algorithm === undefined) {
+      return Effect.succeed(withVary(response))
+    }
+    const contentLength = body.contentLength ?? contentLengthHeader(response.headers)
+    if (contentLength !== undefined && contentLength < minSize) {
+      return Effect.succeed(withVary(response))
+    }
+    return compression.compressResponse(response, algorithm, levelOptions[algorithm])
+  }
+  return <E, R>(
+    httpApp: Effect.Effect<HttpServerResponse, E, R>
+  ): Effect.Effect<HttpServerResponse, E, R | HttpServerRequest | HttpPlatform> =>
+    Effect.withFiber((fiber) => {
+      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
+      const compression = Context.getUnsafe(fiber.context, HttpPlatform).compression
+      appendPreResponseHandlerUnsafe(request, (request, response) =>
+        transform(compression, request.headers["accept-encoding"], response))
+      return httpApp
+    })
+}
+
+const withVary = (response: HttpServerResponse): HttpServerResponse => {
+  const vary = compressionInternal.varyAcceptEncoding(response.headers)
+  return vary === undefined ? response : Response.setHeader(response, "vary", vary)
+}
+
+const defaultAlgorithms: ReadonlyArray<CompressionAlgorithm> = ["br", "gzip", "deflate"]
+
+const defaultLevels = {
+  gzip: 6,
+  deflate: 6,
+  br: 4,
+  zstd: 3
+} as const
+
+const noTransformRegex = /(?:^|[\s,])no-transform(?:$|[\s,;])/i
+
+const contentLengthHeader = (headers: Headers.Headers): number | undefined => {
+  const value = headers["content-length"]
+  if (value === undefined) {
+    return undefined
+  }
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined
+}