effect 4.0.7 → 4.1.0

package/src/http/Cookies.ts

@@ -7,6 +7,10 @@
  * `Set-Cookie` headers, and provides helpers for adding, removing, merging, and
  * expiring cookies.
  *
+ * For client-side storage, `mergeIntoArray` and `toRequestCookieHeader`
+ * work on a plain array of cookies scoped by domain, path and scheme, following
+ * RFC 6265.
+ *
  * @stability unstable
  * @since 4.0.0
  */
@@ -51,6 +55,12 @@ const CookieTypeId = "~effect/http/Cookies/Cookie"
  * HTTP cookie value with its decoded value, encoded value, and optional cookie
  * attributes such as domain, path, expiration, security, and same-site settings.
  *
+ * **Details**
+ *
+ * `hostOnly` marks a stored client cookie that is sent only to the exact
+ * `domain`, not its subdomains. It is not serialized, and `serializeCookie`
+ * omits `Domain` when it is set.
+ *
  * @stability unstable
  * @category cookies
  * @since 4.0.0
@@ -70,6 +80,7 @@ export interface Cookie extends Inspectable.Inspectable {
     readonly secure?: boolean | undefined
     readonly partitioned?: boolean | undefined
     readonly sameSite?: "lax" | "strict" | "none" | undefined
+    readonly hostOnly?: boolean | undefined
   } | undefined
 }
 
@@ -948,7 +959,7 @@ export function serializeCookie(self: Cookie): string {
     str += "; Max-Age=" + Math.trunc(maxAge)
   }
 
-  if (options.domain !== undefined) {
+  if (options.domain !== undefined && !options.hostOnly) {
     str += "; Domain=" + options.domain
   }
 
@@ -1041,6 +1052,275 @@ export const toRecord = (self: Cookies): Record<string, string> => {
  */
 export const toSetCookieHeaders = (self: Cookies): Array<string> => Object.values(self.cookies).map(serializeCookie)
 
+/**
+ * Merges cookies set by `url` into an array of client cookies, returning a new
+ * array.
+ *
+ * **When to use**
+ *
+ * Use to record the cookies of a response, or to seed an array of client
+ * cookies from `Set-Cookie` values for a base URL.
+ *
+ * **Details**
+ *
+ * A cookie without a `Domain` attribute is scoped as `hostOnly` to the exact
+ * host of `url`. A `Domain` attribute is accepted only when the host of `url`
+ * domain-matches it. Without a `Path` attribute the cookie uses the default
+ * path of `url`. `Max-Age` takes precedence over `Expires`, and both are
+ * converted to an absolute `expires` computed from `now` (epoch milliseconds).
+ *
+ * A cookie replaces the existing cookie with the same name, domain and path,
+ * keeping its position. A cookie that is already expired removes that existing
+ * cookie instead. The array is returned unchanged when `url` is not a valid
+ * absolute URL.
+ *
+ * **Gotchas**
+ *
+ * - There is no public suffix list. A `Domain` attribute is accepted whenever
+ *   the request host domain-matches it, unless the host is an IP address or the
+ *   domain is a single label such as `com`, so `foo.co.uk` can set
+ *   `Domain=co.uk`.
+ *
+ * @stability unstable
+ * @category client storage
+ * @since 4.0.0
+ */
+export const mergeIntoArray: {
+  /**
+   * Merges cookies set by `url` into an array of client cookies, returning a new
+   * array.
+   *
+   * **When to use**
+   *
+   * Use to record the cookies of a response, or to seed an array of client
+   * cookies from `Set-Cookie` values for a base URL.
+   *
+   * **Details**
+   *
+   * A cookie without a `Domain` attribute is scoped as `hostOnly` to the exact
+   * host of `url`. A `Domain` attribute is accepted only when the host of `url`
+   * domain-matches it. Without a `Path` attribute the cookie uses the default
+   * path of `url`. `Max-Age` takes precedence over `Expires`, and both are
+   * converted to an absolute `expires` computed from `now` (epoch milliseconds).
+   *
+   * A cookie replaces the existing cookie with the same name, domain and path,
+   * keeping its position. A cookie that is already expired removes that existing
+   * cookie instead. The array is returned unchanged when `url` is not a valid
+   * absolute URL.
+   *
+   * **Gotchas**
+   *
+   * - There is no public suffix list. A `Domain` attribute is accepted whenever
+   *   the request host domain-matches it, unless the host is an IP address or the
+   *   domain is a single label such as `com`, so `foo.co.uk` can set
+   *   `Domain=co.uk`.
+   *
+   * @stability unstable
+   * @category client storage
+   * @since 4.0.0
+   */
+  (url: string, cookies: Cookies, now: number): (self: ReadonlyArray<Cookie>) => ReadonlyArray<Cookie>
+  /**
+   * Merges cookies set by `url` into an array of client cookies, returning a new
+   * array.
+   *
+   * **When to use**
+   *
+   * Use to record the cookies of a response, or to seed an array of client
+   * cookies from `Set-Cookie` values for a base URL.
+   *
+   * **Details**
+   *
+   * A cookie without a `Domain` attribute is scoped as `hostOnly` to the exact
+   * host of `url`. A `Domain` attribute is accepted only when the host of `url`
+   * domain-matches it. Without a `Path` attribute the cookie uses the default
+   * path of `url`. `Max-Age` takes precedence over `Expires`, and both are
+   * converted to an absolute `expires` computed from `now` (epoch milliseconds).
+   *
+   * A cookie replaces the existing cookie with the same name, domain and path,
+   * keeping its position. A cookie that is already expired removes that existing
+   * cookie instead. The array is returned unchanged when `url` is not a valid
+   * absolute URL.
+   *
+   * **Gotchas**
+   *
+   * - There is no public suffix list. A `Domain` attribute is accepted whenever
+   *   the request host domain-matches it, unless the host is an IP address or the
+   *   domain is a single label such as `com`, so `foo.co.uk` can set
+   *   `Domain=co.uk`.
+   *
+   * @stability unstable
+   * @category client storage
+   * @since 4.0.0
+   */
+  (self: ReadonlyArray<Cookie>, url: string, cookies: Cookies, now: number): ReadonlyArray<Cookie>
+} = dual(4, (self: ReadonlyArray<Cookie>, url: string, cookies: Cookies, now: number): ReadonlyArray<Cookie> => {
+  const parsed = parseUrl(url)
+  if (parsed === undefined) {
+    return self
+  }
+  const stored = self.slice()
+  for (const cookie of Object.values(cookies.cookies)) {
+    const scoped = scopeCookie(parsed, cookie, now)
+    if (scoped === undefined) {
+      continue
+    }
+    const domain = cookieDomain(scoped)
+    const path = cookiePath(scoped)
+    const index = stored.findIndex((existing) =>
+      existing.name === scoped.name && cookieDomain(existing) === domain && cookiePath(existing) === path
+    )
+    if (scoped.options!.expires !== undefined && scoped.options!.expires.getTime() <= now) {
+      if (index !== -1) stored.splice(index, 1)
+    } else if (index === -1) {
+      stored.push(scoped)
+    } else {
+      stored[index] = scoped
+    }
+  }
+  return stored
+})
+
+/**
+ * Serializes the client cookies to send with a request to `url` into a
+ * `Cookie` header value.
+ *
+ * **Details**
+ *
+ * Selects cookies that have not expired at `now` (epoch milliseconds) and whose
+ * domain and path match `url`, skipping `Secure` cookies unless `url` uses
+ * `https`. Every matching cookie is kept, including cookies with the same name,
+ * ordered by longest path first. Returns `undefined` when no cookie matches.
+ *
+ * A leading dot and letter case in `domain` are ignored. A cookie without a
+ * `domain` is never sent, and a cookie without a `path` matches every path.
+ *
+ * @stability unstable
+ * @category client storage
+ * @since 4.0.0
+ */
+export const toRequestCookieHeader: {
+  /**
+   * Serializes the client cookies to send with a request to `url` into a
+   * `Cookie` header value.
+   *
+   * **Details**
+   *
+   * Selects cookies that have not expired at `now` (epoch milliseconds) and whose
+   * domain and path match `url`, skipping `Secure` cookies unless `url` uses
+   * `https`. Every matching cookie is kept, including cookies with the same name,
+   * ordered by longest path first. Returns `undefined` when no cookie matches.
+   *
+   * A leading dot and letter case in `domain` are ignored. A cookie without a
+   * `domain` is never sent, and a cookie without a `path` matches every path.
+   *
+   * @stability unstable
+   * @category client storage
+   * @since 4.0.0
+   */
+  (url: string, now: number): (self: ReadonlyArray<Cookie>) => string | undefined
+  /**
+   * Serializes the client cookies to send with a request to `url` into a
+   * `Cookie` header value.
+   *
+   * **Details**
+   *
+   * Selects cookies that have not expired at `now` (epoch milliseconds) and whose
+   * domain and path match `url`, skipping `Secure` cookies unless `url` uses
+   * `https`. Every matching cookie is kept, including cookies with the same name,
+   * ordered by longest path first. Returns `undefined` when no cookie matches.
+   *
+   * A leading dot and letter case in `domain` are ignored. A cookie without a
+   * `domain` is never sent, and a cookie without a `path` matches every path.
+   *
+   * @stability unstable
+   * @category client storage
+   * @since 4.0.0
+   */
+  (self: ReadonlyArray<Cookie>, url: string, now: number): string | undefined
+} = dual(3, (self: ReadonlyArray<Cookie>, url: string, now: number): string | undefined => {
+  const parsed = parseUrl(url)
+  if (parsed === undefined) {
+    return undefined
+  }
+  const host = parsed.hostname
+  const secure = parsed.protocol === "https:"
+  const matching = self.filter((cookie) => {
+    const domain = cookieDomain(cookie)
+    return domain !== undefined &&
+      (cookie.options?.hostOnly ? host === domain : domainMatches(host, domain)) &&
+      pathMatches(parsed.pathname, cookiePath(cookie)) &&
+      (cookie.options?.expires === undefined || cookie.options.expires.getTime() > now) &&
+      (secure || !cookie.options?.secure)
+  })
+  return matching.length === 0
+    ? undefined
+    : matching
+      .sort((a, b) => cookiePath(b).length - cookiePath(a).length)
+      .map((cookie) => `${cookie.name}=${cookie.valueEncoded}`)
+      .join("; ")
+})
+
+const parseUrl = (url: string): URL | undefined => {
+  try {
+    return new URL(url)
+  } catch {
+    return undefined
+  }
+}
+
+const cookieDomain = (cookie: Cookie): string | undefined =>
+  cookie.options?.domain?.replace(/^\./, "").toLowerCase() || undefined
+
+const cookiePath = (cookie: Cookie): string => cookie.options?.path?.startsWith("/") ? cookie.options.path : "/"
+
+const isIpAddress = (host: string): boolean => host.startsWith("[") || /^\d+\.\d+\.\d+\.\d+$/.test(host)
+
+const domainMatches = (host: string, domain: string): boolean =>
+  host === domain || (host.endsWith("." + domain) && !isIpAddress(host))
+
+const pathMatches = (requestPath: string, cookiePath: string): boolean =>
+  requestPath === cookiePath ||
+  (requestPath.startsWith(cookiePath) &&
+    (cookiePath.endsWith("/") || requestPath[cookiePath.length] === "/"))
+
+const defaultPath = (pathname: string): string => {
+  const index = pathname.lastIndexOf("/")
+  return index <= 0 ? "/" : pathname.slice(0, index)
+}
+
+const scopeCookie = (url: URL, cookie: Cookie, now: number): Cookie | undefined => {
+  const host = url.hostname
+  let domain = host
+  let hostOnly = true
+  const attribute = cookieDomain(cookie)
+  if (attribute !== undefined) {
+    if (isIpAddress(host) || !domainMatches(host, attribute)) {
+      return undefined
+    }
+    if (attribute.includes(".")) {
+      domain = attribute
+      hostOnly = false
+    } else if (attribute !== host) {
+      // a single-label domain such as "com" is treated like a public suffix
+      return undefined
+    }
+  }
+  const { maxAge, ...options } = cookie.options ?? {}
+  return Object.assign(Object.create(CookieProto), {
+    name: cookie.name,
+    value: cookie.value,
+    valueEncoded: cookie.valueEncoded,
+    options: {
+      ...options,
+      domain,
+      hostOnly: hostOnly || undefined,
+      path: options.path?.startsWith("/") ? options.path : defaultPath(url.pathname),
+      expires: maxAge !== undefined ? new Date(now + Duration.toMillis(maxAge)) : options.expires
+    }
+  })
+}
+
 /**
  * Parses a cookie header into a record of key-value pairs
  *

package/src/http/FetchHttpClient.ts

@@ -36,6 +36,32 @@ export const Fetch = Context.Reference<typeof globalThis.fetch>("effect/http/Fet
   defaultValue: () => globalThis.fetch
 })
 
+/**
+ * Context reference controlling stream bodies when the runtime does not support streaming requests.
+ *
+ * **Details**
+ *
+ * Defaults to `"error"`, which fails with an `EncodeError` without sending the
+ * request. Set to `"buffer"` to collect the entire stream in memory and send it
+ * as a single body instead. Runtimes with streaming support always send the stream.
+ *
+ * **Gotchas**
+ *
+ * Buffering keeps the entire upload in memory and can exhaust memory for large
+ * or unbounded uploads. Support is detected once, on the first stream body sent,
+ * using the global `Request` implementation even when a custom `Fetch` is provided.
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export const StreamBodyFallback = Context.Reference<"error" | "buffer">(
+  "effect/http/FetchHttpClient/StreamBodyFallback",
+  {
+    defaultValue: () => "error"
+  }
+)
+
 /**
  * Service that contains default fetch options for the fetch-based HTTP client.
  *
@@ -58,6 +84,27 @@ export class RequestInit extends Context.Service<RequestInit, globalThis.Request
   "effect/http/FetchHttpClient/RequestInit"
 ) {}
 
+// https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests
+let supportsStreamBody: boolean | undefined
+const detectStreamBodySupport = () => {
+  try {
+    let duplexAccessed = false
+    const body = new ReadableStream()
+    const request = new Request("https://example.com", {
+      method: "POST",
+      body,
+      get duplex() {
+        duplexAccessed = true
+        return "half"
+      }
+    } as globalThis.RequestInit)
+    // Bun and Deno preserve the stream without reading the duplex option.
+    return (duplexAccessed || request.body === body) && !request.headers.has("Content-Type")
+  } catch {
+    return false
+  }
+}
+
 const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fiber) => {
   if (request.headers.upgrade !== undefined) {
     return Effect.fail(
@@ -124,20 +171,41 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
     case "FormData":
       return send(request.body.formData)
     case "Stream": {
-      uploadController = new AbortController()
-      const uploadSignal = AbortSignal.any([signal, uploadController.signal])
-      const stopped = Effect.callback<void>((resume) => {
-        const onAbort = () => resume(Effect.interrupt)
-        if (uploadSignal.aborted) {
-          onAbort()
-          return
-        }
-        uploadSignal.addEventListener("abort", onAbort, { once: true })
-        return Effect.sync(() => uploadSignal.removeEventListener("abort", onAbort))
-      })
-      return Effect.flatMap(
-        Stream.toReadableStreamEffect(Stream.interruptWhen(request.body.stream, stopped)),
-        send
+      supportsStreamBody ??= detectStreamBodySupport()
+      if (supportsStreamBody) {
+        uploadController = new AbortController()
+        const uploadSignal = AbortSignal.any([signal, uploadController.signal])
+        const stopped = Effect.callback<void>((resume) => {
+          const onAbort = () => resume(Effect.interrupt)
+          if (uploadSignal.aborted) {
+            onAbort()
+            return
+          }
+          uploadSignal.addEventListener("abort", onAbort, { once: true })
+          return Effect.sync(() => uploadSignal.removeEventListener("abort", onAbort))
+        })
+        return Effect.flatMap(
+          Stream.toReadableStreamEffect(Stream.interruptWhen(request.body.stream, stopped)),
+          send
+        )
+      }
+      if (fiber.getRef(StreamBodyFallback) === "error") {
+        return Effect.fail(
+          new HttpClientError.HttpClientError({
+            reason: new HttpClientError.EncodeError({
+              request,
+              description: "Streaming request bodies are not supported in this runtime"
+            })
+          })
+        )
+      }
+      return Stream.mkArrayBuffer(request.body.stream).pipe(
+        Effect.mapError((cause) =>
+          new HttpClientError.HttpClientError({
+            reason: new HttpClientError.EncodeError({ request, cause })
+          })
+        ),
+        Effect.flatMap(send)
       )
     }
   }
@@ -168,11 +236,15 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
  * has no effect unless `RequestInit` sets `redirect: "manual"`. 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`.
+ * streams with `duplex: "half"` when the runtime supports it; see
+ * `StreamBodyFallback` for the unsupported case. Any `content-length` header is
+ * removed before calling `fetch`. Chrome passes the support check but rejects
+ * streaming uploads over HTTP/1.1, which surfaces as a `TransportError`, and
+ * browsers only deliver the response after the entire request body has been sent.
  *
  * @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 StreamBodyFallback} for opting into buffering on unsupported runtimes
  * @see {@link HttpClient.TracerPropagationEnabled} for leaving `b3` and `traceparent` off a browser request
  *
  * @stability unstable

package/src/http/HttpClient.ts

@@ -2456,12 +2456,20 @@ export const tapRequest: {
 )
 
 /**
- * Adds a `Ref` of cookies to the client for handling cookies across requests.
+ * Adds a `Ref` of stored cookies to the client for handling cookies across
+ * requests.
  *
  * **When to use**
  *
  * Use to add shared cookie storage to a client so response cookies are retained
- * and sent by later requests.
+ * and sent by later requests to a matching host, path, and scheme.
+ *
+ * **Details**
+ *
+ * Response cookies are merged into the ref with `Cookies.mergeIntoArray` for
+ * the response URL. Before each request, `Cookies.toRequestCookieHeader` selects
+ * the cookies for the request URL and sets them as the `cookie` header. Expiry
+ * uses the current `Clock`.
  *
  * @stability unstable
  * @category cookies
@@ -2469,52 +2477,66 @@ export const tapRequest: {
  */
 export const withCookiesRef: {
   /**
-   * Adds a `Ref` of cookies to the client for handling cookies across requests.
+   * Adds a `Ref` of stored cookies to the client for handling cookies across
+   * requests.
    *
    * **When to use**
    *
    * Use to add shared cookie storage to a client so response cookies are retained
-   * and sent by later requests.
+   * and sent by later requests to a matching host, path, and scheme.
+   *
+   * **Details**
+   *
+   * Response cookies are merged into the ref with `Cookies.mergeIntoArray` for
+   * the response URL. Before each request, `Cookies.toRequestCookieHeader` selects
+   * the cookies for the request URL and sets them as the `cookie` header. Expiry
+   * uses the current `Clock`.
    *
    * @stability unstable
    * @category cookies
    * @since 4.0.0
    */
-  (ref: Ref.Ref<Cookies.Cookies>): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R>
+  (ref: Ref.Ref<ReadonlyArray<Cookies.Cookie>>): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R>
   /**
-   * Adds a `Ref` of cookies to the client for handling cookies across requests.
+   * Adds a `Ref` of stored cookies to the client for handling cookies across
+   * requests.
    *
    * **When to use**
    *
    * Use to add shared cookie storage to a client so response cookies are retained
-   * and sent by later requests.
+   * and sent by later requests to a matching host, path, and scheme.
+   *
+   * **Details**
+   *
+   * Response cookies are merged into the ref with `Cookies.mergeIntoArray` for
+   * the response URL. Before each request, `Cookies.toRequestCookieHeader` selects
+   * the cookies for the request URL and sets them as the `cookie` header. Expiry
+   * uses the current `Clock`.
    *
    * @stability unstable
    * @category cookies
    * @since 4.0.0
    */
-  <E, R>(self: HttpClient.With<E, R>, ref: Ref.Ref<Cookies.Cookies>): HttpClient.With<E, R>
+  <E, R>(self: HttpClient.With<E, R>, ref: Ref.Ref<ReadonlyArray<Cookies.Cookie>>): HttpClient.With<E, R>
 } = dual(
   2,
   <E, R>(
     self: HttpClient.With<E, R>,
-    ref: Ref.Ref<Cookies.Cookies>
+    ref: Ref.Ref<ReadonlyArray<Cookies.Cookie>>
   ): HttpClient.With<E, R> =>
     makeWith(
       (request: Effect.Effect<HttpClientRequest.HttpClientRequest, E, R>) =>
-        Effect.tap(
-          self.postprocess(request),
-          (response) => Ref.update(ref, (cookies) => Cookies.merge(cookies, response.cookies))
-        ),
+        Effect.tap(self.postprocess(request), (response) => {
+          const now = Fiber.getCurrent()!.getRef(Clock).currentTimeMillisUnsafe()
+          return Ref.update(ref, Cookies.mergeIntoArray(response.url, response.cookies, now))
+        }),
       (request) =>
         Effect.flatMap(self.preprocess(request), (request) =>
-          Effect.map(
-            Ref.get(ref),
-            (cookies) =>
-              Cookies.isEmpty(cookies)
-                ? request
-                : HttpClientRequest.setHeader(request, "cookie", Cookies.toCookieHeader(cookies))
-          ))
+          Effect.map(Ref.get(ref), (cookies) => {
+            const now = Fiber.getCurrent()!.getRef(Clock).currentTimeMillisUnsafe()
+            const header = Cookies.toRequestCookieHeader(cookies, request.url, now)
+            return header === undefined ? request : HttpClientRequest.setHeader(request, "cookie", header)
+          }))
     )
 )
 
@@ -2980,7 +3002,38 @@ class InterruptibleResponse implements HttpClientResponse.HttpClientResponse, Pi
   }
 }
 
-const isTransientError = (error: unknown) => Cause.isTimeoutError(error) || isTransientHttpError(error)
+/**
+ * Returns `true` for an error that `retryTransient` retries by default: a
+ * timeout, a transport error, or a status code error with a transient response.
+ *
+ * **When to use**
+ *
+ * Use to classify failures the same way `retryTransient` does, for example in a
+ * custom retry policy or a circuit breaker.
+ *
+ * **Example** (Classifying client errors)
+ *
+ * ```ts import.meta.vitest
+ * import { Cause } from "effect"
+ * import { HttpClient, HttpClientError, HttpClientRequest } from "effect/http"
+ *
+ * const request = HttpClientRequest.get("https://example.com")
+ * const transportError = new HttpClientError.HttpClientError({
+ *   reason: new HttpClientError.TransportError({ request })
+ * })
+ *
+ * HttpClient.isTransientError(transportError) // => true
+ * HttpClient.isTransientError(new Cause.TimeoutError()) // => true
+ * HttpClient.isTransientError(new Error("boom")) // => false
+ * ```
+ *
+ * @see {@link isTransientResponse} for the response statuses it accepts
+ * @see {@link retryTransient} for the retry policy that uses it
+ * @stability unstable
+ * @category predicates
+ * @since 4.1.0
+ */
+export const isTransientError = (error: unknown): boolean => Cause.isTimeoutError(error) || isTransientHttpError(error)
 
 const isTransientHttpError = (error: unknown) =>
   Error.isHttpClientError(error) &&
@@ -3014,7 +3067,21 @@ const isTooManyRequestsHttpClientError = (
 ): error is Error.HttpClientError & { readonly reason: Error.StatusCodeError } =>
   Error.isHttpClientError(error) && error.reason._tag === "StatusCodeError" && error.reason.response.status === 429
 
-const isTransientResponse = (response: HttpClientResponse.HttpClientResponse) =>
+/**
+ * Returns `true` for a response whose status `retryTransient` retries by
+ * default: 408, 429, 500, 502, 503 or 504.
+ *
+ * **When to use**
+ *
+ * Use to retry the same responses as `retryTransient` in a custom retry policy.
+ *
+ * @see {@link isTransientError} for the matching error predicate
+ * @see {@link retryTransient} for the retry policy that uses it
+ * @stability unstable
+ * @category predicates
+ * @since 4.1.0
+ */
+export const isTransientResponse = (response: HttpClientResponse.HttpClientResponse): boolean =>
   response.status === 408 ||
   response.status === 429 ||
   response.status === 500 ||

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
@@ -1694,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
   }