effect 4.0.3 → 4.0.5

package/src/graphql/index.ts

@@ -0,0 +1,48 @@
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+
+// @barrel: Auto-generated exports. Do not edit manually.
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQL from "./GraphQL.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLClient from "./GraphQLClient.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLClientError from "./GraphQLClientError.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLGroup from "./GraphQLGroup.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLMiddleware from "./GraphQLMiddleware.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLProtocol from "./GraphQLProtocol.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLResolver from "./GraphQLResolver.ts"

package/src/http/FetchHttpClient.ts

@@ -115,12 +115,15 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
  * **Gotchas**
  *
  * Fetch behavior comes from the runtime's implementation, so CORS, cookies,
- * redirects, abort handling, and streaming support can vary by platform. Stream
- * request bodies are sent as Web streams with `duplex: "half"`, and any
- * `content-length` header is removed before calling `fetch`.
+ * redirects, abort handling, and streaming support can vary by platform. Trace
+ * propagation is on by default, and a browser preflight fails unless the
+ * target allows `b3` and `traceparent`. Stream request bodies are sent as Web
+ * streams with `duplex: "half"`, and any `content-length` header is removed
+ * before calling `fetch`.
  *
  * @see {@link Fetch} for supplying the fetch implementation used by this layer
  * @see {@link RequestInit} for default `RequestInit` options applied before request-specific fields
+ * @see {@link HttpClient.TracerPropagationEnabled} for leaving `b3` and `traceparent` off a browser request
  *
  * @stability unstable
  * @category layers

package/src/http/FindMyWay/internal/router.ts

@@ -857,7 +857,8 @@ function makeCreateParams(
   }
 }
 
-function getClosingParenthensePosition(path: string, idx: number) {
+/** @internal */
+export function getClosingParenthensePosition(path: string, idx: number) {
   // `path.indexOf()` will always return the first position of the closing parenthese,
   // but it's inefficient for grouped or wrong regexp expressions.
   // see issues #62 and #63 for more info

package/src/http/Headers.ts

@@ -731,10 +731,11 @@ export const isRedactedName = (
   name: string,
   patterns: ReadonlyArray<string | RegExp>
 ): boolean => {
+  const lowerName = name.toLowerCase()
   for (let i = 0; i < patterns.length; i++) {
     const pattern = patterns[i]
     if (typeof pattern === "string") {
-      if (pattern.toLowerCase() === name.toLowerCase()) {
+      if (pattern.toLowerCase() === lowerName) {
         return true
       }
     } else if (name.search(pattern) !== -1) {
@@ -749,9 +750,9 @@ export const isRedactedName = (
  *
  * **Details**
  *
- * Defaults include `authorization`, `cookie`, `set-cookie`, `x-api-key` and
- * `AWSAccessKeyId`, `Signature`, `sig` and `X-Goog-Signature`. Names match
- * case-insensitively, and providing a new list replaces the defaults.
+ * Defaults include `authorization`, `cookie`, `set-cookie` and `x-api-key`.
+ * A custom list replaces the defaults. Matching uses `isRedactedName`.
+ * Use `UrlParams.CurrentRedactedNames` for query parameters.
  *
  * @stability unstable
  * @category services
@@ -764,10 +765,6 @@ export const CurrentRedactedNames = Context.Reference<
     "authorization",
     "cookie",
     "set-cookie",
-    "x-api-key",
-    "AWSAccessKeyId",
-    "Signature",
-    "sig",
-    "X-Goog-Signature"
+    "x-api-key"
   ]
 })

package/src/http/HttpClient.ts

@@ -47,6 +47,7 @@ import * as HttpMethod from "./HttpMethod.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
 import * as tracing from "./internal/tracing.ts"
 import * as Url from "./Url.ts"
+import * as UrlParams from "./UrlParams.ts"
 
 const TypeId = "~effect/http/HttpClient"
 
@@ -905,7 +906,11 @@ export const make = (
           (span) => {
             span.attribute("http.request.method", request.method)
             const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
-            tracing.addUrlAttributes(span, url)
+            tracing.addUrlAttributes(
+              span,
+              url,
+              tracing.redactedNames(request.urlParams, fiber.getRef(UrlParams.CurrentRedactedNames))
+            )
             const headerFilter = fiber.getRef(TracerHeaderFilter)
             tracing.addHeaderAttributes(span, "request", request.headers, headerFilter, redactedHeaderNames)
             request = fiber.getRef(TracerPropagationEnabled)
@@ -1204,6 +1209,9 @@ export const retry: {
  * Specifying a `while` predicate allows you to consider other errors as
  * transient, and is ignored in "response-only" mode.
  *
+ * A `Retry-After` header on a transient response, or on the response of a
+ * status code error, sets the minimum delay before the next attempt.
+ *
  * @stability unstable
  * @category error handling
  * @since 4.0.0
@@ -1221,6 +1229,9 @@ export const retryTransient: {
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
    *
+   * A `Retry-After` header on a transient response, or on the response of a
+   * status code error, sets the minimum delay before the next attempt.
+   *
    * @stability unstable
    * @category error handling
    * @since 4.0.0
@@ -1257,6 +1268,9 @@ export const retryTransient: {
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
    *
+   * A `Retry-After` header on a transient response, or on the response of a
+   * status code error, sets the minimum delay before the next attempt.
+   *
    * @stability unstable
    * @category error handling
    * @since 4.0.0
@@ -1295,6 +1309,9 @@ export const retryTransient: {
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
    *
+   * A `Retry-After` header on a transient response, or on the response of a
+   * status code error, sets the minimum delay before the next attempt.
+   *
    * @stability unstable
    * @category error handling
    * @since 4.0.0
@@ -1314,6 +1331,9 @@ export const retryTransient: {
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
    *
+   * A `Retry-After` header on a transient response, or on the response of a
+   * status code error, sets the minimum delay before the next attempt.
+   *
    * @stability unstable
    * @category error handling
    * @since 4.0.0
@@ -1341,14 +1361,15 @@ export const retryTransient: {
   ): HttpClient.With<E | ES, R1 | R> => {
     const isOnlySchedule = Schedule.isSchedule(options)
     const retryOn = isOnlySchedule ? "errors-and-responses" : options.retryOn ?? "errors-and-responses"
-    const schedule = isOnlySchedule ? options : options.schedule
-    const passthroughSchedule = schedule && Schedule.passthrough(schedule)
+    const schedule = withRetryAfter(
+      isOnlySchedule ? options : options.schedule ?? Schedule.forever
+    )
     const times = isOnlySchedule ? undefined : options.times
     return transformResponse(
       self,
       flow(
         retryOn === "errors-only" ? identity : Effect.repeat({
-          schedule: passthroughSchedule!,
+          schedule,
           times,
           while: isTransientResponse
         }),
@@ -1643,7 +1664,10 @@ export const withRateLimiter: {
          */
         Duration.Duration | undefined>(undefined);
       }
-      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, ...headerNames.retryAfter))
+      const retryAfter = parseRetryAfter(
+        clock.currentTimeMillisUnsafe(),
+        getHeader(response.headers, ...headerNames.retryAfter)
+      )
       if (retryAfter === undefined) {
         return Effect.succeed</**
          * Applies request rate limiting using the `RateLimiter` service.
@@ -1865,21 +1889,24 @@ const parseRateLimitWindow = (
 }
 
 const parseRetryAfter = (
-  clock: Clock,
+  nowMillis: number,
   value: string | undefined
 ): Duration.Duration | undefined => {
   if (value === undefined) {
     return undefined
   }
-  const numeric = parseNumberHeader(value)
-  if (numeric !== undefined) {
-    return Duration.max(Duration.seconds(numeric), Duration.millis(1))
+  const trimmed = value.trim()
+  if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+    const numeric = Number(trimmed)
+    return Number.isFinite(numeric)
+      ? Duration.max(Duration.seconds(numeric), Duration.millis(1))
+      : undefined
   }
-  const parsedDate = Date.parse(value)
+  const parsedDate = Date.parse(trimmed)
   if (Number.isNaN(parsedDate)) {
     return undefined
   }
-  const millis = parsedDate - clock.currentTimeMillisUnsafe()
+  const millis = parsedDate - nowMillis
   if (millis <= 0) {
     return Duration.millis(1)
   }
@@ -2233,6 +2260,18 @@ export const TracerHeaderFilter = Context.Reference<
 /**
  * Context reference that controls whether outgoing client spans are propagated to request headers.
  *
+ * **Details**
+ *
+ * When this is `true`, the client writes the compact B3 `b3` header and the
+ * W3C `traceparent` header. The default is on. The client span is still
+ * created when this is `false`.
+ *
+ * **Gotchas**
+ *
+ * A browser preflight fails when the target does not list `b3` and
+ * `traceparent` in `Access-Control-Allow-Headers`. Set this to `false` for
+ * those requests.
+ *
  * @stability unstable
  * @category services
  * @since 4.0.0
@@ -2417,6 +2456,28 @@ const isTransientHttpError = (error: unknown) =>
   (error.reason._tag === "TransportError" ||
     (error.reason._tag === "StatusCodeError" && isTransientResponse(error.reason.response)))
 
+const retryAfterOf = (input: unknown, nowMillis: number): Duration.Duration | undefined => {
+  const response = Error.isHttpClientError(input)
+    ? input.response
+    : Predicate.hasProperty(input, HttpClientResponse.TypeId)
+    ? input as HttpClientResponse.HttpClientResponse
+    : undefined
+  return parseRetryAfter(nowMillis, response?.headers["retry-after"])
+}
+
+const withRetryAfter = <ES, R1>(
+  schedule: Schedule.Schedule<unknown, any, ES, R1>
+): Schedule.Schedule<unknown, any, ES, R1> =>
+  Schedule.fromStep(
+    Effect.map(Schedule.toStep(schedule), (step) => (now: number, input: unknown) => {
+      const retryAfter = retryAfterOf(input, now)
+      if (retryAfter === undefined) {
+        return step(now, input)
+      }
+      return Effect.map(step(now, input), ([output, delay]) => [output, Duration.max(delay, retryAfter)])
+    })
+  )
+
 const isTooManyRequestsHttpClientError = (
   error: unknown
 ): error is Error.HttpClientError & { readonly reason: Error.StatusCodeError } =>

package/src/http/HttpClientError.ts

@@ -15,6 +15,7 @@ import { hasProperty } from "../Predicate.ts"
 import * as Schema from "../Schema.ts"
 import type * as HttpClientRequest from "./HttpClientRequest.ts"
 import type * as ClientResponse from "./HttpClientResponse.ts"
+import * as UrlParams from "./UrlParams.ts"
 
 const TypeId = "~effect/http/HttpClientError"
 
@@ -88,6 +89,9 @@ const formatReason = (tag: string) => tag.endsWith("Error") ? tag.slice(0, -5) :
 const formatMessage = (reason: string, description: string | undefined, info: string) =>
   description ? `${reason}: ${description} (${info})` : `${reason} error (${info})`
 
+const formatMethodAndUrl = (request: HttpClientRequest.HttpClientRequest) =>
+  `${request.method} ${UrlParams.redactUrl(request.url)}`
+
 /**
  * Error describing transport-level failures that occur while sending an HTTP request.
  *
@@ -107,7 +111,7 @@ export class TransportError extends Data.TaggedError("TransportError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -140,7 +144,7 @@ export class EncodeError extends Data.TaggedError("EncodeError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -173,7 +177,7 @@ export class InvalidUrlError extends Data.TaggedError("InvalidUrlError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -207,7 +211,7 @@ export class StatusCodeError extends Data.TaggedError("StatusCodeError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -242,7 +246,7 @@ export class DecodeError extends Data.TaggedError("DecodeError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**
@@ -277,7 +281,7 @@ export class EmptyBodyError extends Data.TaggedError("EmptyBodyError")<{
    * @since 4.0.0
    */
   get methodAndUrl() {
-    return `${this.request.method} ${this.request.url}`
+    return formatMethodAndUrl(this.request)
   }
 
   /**

package/src/http/HttpClientRequest.ts

@@ -30,6 +30,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 compression from "./internal/compressionBody.ts"
 import * as bodyInternal from "./internal/httpBody.ts"
 import * as Url from "./Url.ts"
 import * as UrlParams from "./UrlParams.ts"
@@ -104,7 +105,7 @@ const Proto = {
     return {
       _id: "HttpClientRequest",
       method: this.method,
-      url: this.url,
+      url: UrlParams.redactUrl(this.url),
       urlParams: this.urlParams,
       hash: this.hash,
       headers: redact(this.headers),
@@ -755,6 +756,10 @@ export const updateUrl: {
 /**
  * Sets one query parameter, replacing existing values for that parameter name.
  *
+ * **Details**
+ *
+ * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+ *
  * @stability unstable
  * @category combinators
  * @since 4.0.0
@@ -763,20 +768,28 @@ export const setUrlParam: {
   /**
    * Sets one query parameter, replacing existing values for that parameter name.
    *
+   * **Details**
+   *
+   * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
    */
-  (key: string, value: string): (self: HttpClientRequest) => HttpClientRequest
+  (key: string, value: string | Redacted.Redacted): (self: HttpClientRequest) => HttpClientRequest
   /**
    * Sets one query parameter, replacing existing values for that parameter name.
    *
+   * **Details**
+   *
+   * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
    */
-  (self: HttpClientRequest, key: string, value: string): HttpClientRequest
-} = dual(3, (self: HttpClientRequest, key: string, value: string): HttpClientRequest =>
+  (self: HttpClientRequest, key: string, value: string | Redacted.Redacted): HttpClientRequest
+} = dual(3, (self: HttpClientRequest, key: string, value: string | Redacted.Redacted): HttpClientRequest =>
   makeWith(
     self.method,
     self.url,
@@ -823,6 +836,10 @@ export const setUrlParams: {
 /**
  * Appends one query parameter value without removing existing values for the same name.
  *
+ * **Details**
+ *
+ * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+ *
  * @stability unstable
  * @category combinators
  * @since 4.0.0
@@ -831,20 +848,28 @@ export const appendUrlParam: {
   /**
    * Appends one query parameter value without removing existing values for the same name.
    *
+   * **Details**
+   *
+   * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
    */
-  (key: string, value: string): (self: HttpClientRequest) => HttpClientRequest
+  (key: string, value: string | Redacted.Redacted): (self: HttpClientRequest) => HttpClientRequest
   /**
    * Appends one query parameter value without removing existing values for the same name.
    *
+   * **Details**
+   *
+   * A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
    */
-  (self: HttpClientRequest, key: string, value: string): HttpClientRequest
-} = dual(3, (self: HttpClientRequest, key: string, value: string): HttpClientRequest =>
+  (self: HttpClientRequest, key: string, value: string | Redacted.Redacted): HttpClientRequest
+} = dual(3, (self: HttpClientRequest, key: string, value: string | Redacted.Redacted): HttpClientRequest =>
   makeWith(
     self.method,
     self.url,
@@ -974,6 +999,147 @@ export const setBody: {
   )
 })
 
+/**
+ * Algorithms supported by Web `CompressionStream` for request body compression.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export type CompressionAlgorithm = "gzip" | "deflate"
+
+/**
+ * Options for request body compression.
+ *
+ * @stability unstable
+ * @category options
+ * @since 4.0.0
+ */
+export interface CompressionOptions {
+  /**
+   * Minimum known body length in bytes to compress. Defaults to `1024`.
+   * Bodies with unknown length are always compressed.
+   */
+  readonly minSize?: number | undefined
+}
+
+/**
+ * Compresses a request body using Web `CompressionStream` and sets `Content-Encoding`.
+ *
+ * **Details**
+ *
+ * Byte-array bodies (including text, JSON, and URL-encoded bodies) are compressed
+ * into a new `Uint8Array` body, preserving the content type and updating
+ * `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).
+ *
+ * Returns the original request unchanged for empty, FormData, and raw bodies,
+ * bodies with a known length below `options.minSize`, or requests with any
+ * existing `Content-Encoding` header, including `identity`. Unknown-length
+ * streams are always compressed. The default minimum is 1024 bytes because
+ * gzip can make very small bodies larger.
+ *
+ * Requires `CompressionStream` (available in browsers, Node 18+, Bun, and Deno).
+ * There is no typed error channel: byte compression failures are defects;
+ * stream failures surface when the body is sent.
+ *
+ * To compress every request, use
+ * `HttpClient.mapRequestEffect(HttpClientRequest.compressBody("gzip"))`.
+ * `HttpClient.retryTransient` re-runs preprocessing, so this recompresses on
+ * every retry. For large bodies, compress once before calling `client.execute`.
+ *
+ * @stability unstable
+ * @category combinators
+ * @since 4.0.0
+ */
+export const compressBody: {
+  /**
+   * Compresses a request body using Web `CompressionStream` and sets `Content-Encoding`.
+   *
+   * **Details**
+   *
+   * Byte-array bodies (including text, JSON, and URL-encoded bodies) are compressed
+   * into a new `Uint8Array` body, preserving the content type and updating
+   * `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).
+   *
+   * Returns the original request unchanged for empty, FormData, and raw bodies,
+   * bodies with a known length below `options.minSize`, or requests with any
+   * existing `Content-Encoding` header, including `identity`. Unknown-length
+   * streams are always compressed. The default minimum is 1024 bytes because
+   * gzip can make very small bodies larger.
+   *
+   * Requires `CompressionStream` (available in browsers, Node 18+, Bun, and Deno).
+   * There is no typed error channel: byte compression failures are defects;
+   * stream failures surface when the body is sent.
+   *
+   * To compress every request, use
+   * `HttpClient.mapRequestEffect(HttpClientRequest.compressBody("gzip"))`.
+   * `HttpClient.retryTransient` re-runs preprocessing, so this recompresses on
+   * every retry. For large bodies, compress once before calling `client.execute`.
+   *
+   * @stability unstable
+   * @category combinators
+   * @since 4.0.0
+   */
+  (algorithm: CompressionAlgorithm, options?: CompressionOptions | undefined): (self: HttpClientRequest) => Effect.Effect<HttpClientRequest>
+  /**
+   * Compresses a request body using Web `CompressionStream` and sets `Content-Encoding`.
+   *
+   * **Details**
+   *
+   * Byte-array bodies (including text, JSON, and URL-encoded bodies) are compressed
+   * into a new `Uint8Array` body, preserving the content type and updating
+   * `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).
+   *
+   * Returns the original request unchanged for empty, FormData, and raw bodies,
+   * bodies with a known length below `options.minSize`, or requests with any
+   * existing `Content-Encoding` header, including `identity`. Unknown-length
+   * streams are always compressed. The default minimum is 1024 bytes because
+   * gzip can make very small bodies larger.
+   *
+   * Requires `CompressionStream` (available in browsers, Node 18+, Bun, and Deno).
+   * There is no typed error channel: byte compression failures are defects;
+   * stream failures surface when the body is sent.
+   *
+   * To compress every request, use
+   * `HttpClient.mapRequestEffect(HttpClientRequest.compressBody("gzip"))`.
+   * `HttpClient.retryTransient` re-runs preprocessing, so this recompresses on
+   * every retry. For large bodies, compress once before calling `client.execute`.
+   *
+   * @stability unstable
+   * @category combinators
+   * @since 4.0.0
+   */
+  (
+    self: HttpClientRequest,
+    algorithm: CompressionAlgorithm,
+    options?: CompressionOptions | undefined
+  ): Effect.Effect<HttpClientRequest>
+} = dual(
+  (args) => isHttpClientRequest(args[0]),
+  (
+    self: HttpClientRequest,
+    algorithm: CompressionAlgorithm,
+    options?: CompressionOptions | undefined
+  ): Effect.Effect<HttpClientRequest> => {
+    if (self.headers["content-encoding"] !== undefined) {
+      return Effect.succeed(self)
+    }
+    return Effect.map(
+      compression.compressBody(self.body, algorithm, options),
+      (body) => body === self.body ? self : setHeader(setBody(self, body), "content-encoding", algorithm)
+    )
+  }
+)
+
 /**
  * Sets a `Uint8Array` request body with an optional content type.
  *

package/src/http/HttpEffect.ts

@@ -347,10 +347,11 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
   const httpApp = toHandled(self, (request, response) => {
     const withoutBody = request.method === "HEAD"
     if (!Response.omitsBody(response, withoutBody)) {
+      // The transferred request scope closes when an abort interrupts the body, even if it is no longer read.
       response = scopeTransferToStream(response)
     }
     ;(request as any)[resolveSymbol](
-      Response.toWeb(response, { withoutBody, context })
+      Response.toWeb(response, { withoutBody, context, signal: (request.source as globalThis.Request).signal })
     )
     return Effect.void
   }, middleware)
@@ -366,10 +367,15 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
       reqContext = Context.add(reqContext, HttpServerRequest, httpServerRequest)
       ;(httpServerRequest as any)[resolveSymbol] = resolve
       const fiber = Effect.runForkWith(reqContext)(httpApp as any)
-      if (fiber.pollUnsafe() === undefined) {
-        request.signal?.addEventListener("abort", () => {
-          fiber.interruptUnsafe(undefined, ClientAbort.annotation)
-        }, { once: true })
+      const signal = request.signal
+      if (fiber.pollUnsafe() === undefined && signal) {
+        const onAbort = () => fiber.interruptUnsafe(undefined, ClientAbort.annotation)
+        if (signal.aborted) {
+          onAbort()
+        } else {
+          signal.addEventListener("abort", onAbort, { once: true })
+          fiber.addObserver(() => signal.removeEventListener("abort", onAbort))
+        }
       }
     })
 }