effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/unstable/http/HttpBody.ts

@@ -11,12 +11,14 @@
  *
  * @since 4.0.0
  */
+import * as ByteSize from "../../ByteSize.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { format } from "../../Formatter.ts"
 import * as Inspectable from "../../Inspectable.ts"
-import type * as PlatformError from "../../PlatformError.ts"
+import * as Option from "../../Option.ts"
+import * as PlatformError from "../../PlatformError.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
@@ -224,20 +226,27 @@ export const raw = (
  */
 export class Uint8Array extends Proto {
   readonly _tag = "Uint8Array"
-  readonly body: globalThis.Uint8Array
   readonly contentType: string
   readonly contentLength: number
+  /** Original text retained for adapters that can skip encoding. */
+  readonly text: string | undefined
+  private _body: globalThis.Uint8Array | undefined
 
   constructor(
-    body: globalThis.Uint8Array,
+    body: globalThis.Uint8Array | undefined,
     contentType: string,
-    contentLength: number
+    contentLength: number,
+    text?: string
   ) {
     super()
-    this.body = body
+    this._body = body
+    this.text = text
     this.contentType = contentType
     this.contentLength = contentLength
   }
+  get body(): globalThis.Uint8Array {
+    return this._body ??= encodeText(this.text!)
+  }
   toJSON(): unknown {
     const toString = this.contentType.startsWith("text/") || this.contentType.endsWith("json")
     return {
@@ -265,18 +274,38 @@ export const uint8Array = (body: globalThis.Uint8Array, contentType?: string): U
 
 const encoder = new TextEncoder()
 
+// Buffer encodes UTF-8 faster than TextEncoder when available.
+const buffer = (globalThis as {
+  readonly Buffer?: {
+    readonly from: (body: string, encoding: "utf8") => globalThis.Uint8Array
+    readonly byteLength: (body: string, encoding: "utf8") => number
+  }
+}).Buffer
+const encodeText: (body: string) => globalThis.Uint8Array = buffer !== undefined
+  ? (body) => buffer.from(body, "utf8")
+  : (body) => encoder.encode(body)
+
 /**
  * Creates a UTF-8 encoded text HTTP body.
  *
  * **Details**
  *
- * The content type defaults to `text/plain`.
+ * The content type defaults to `text/plain`. Text bodies are encoded lazily.
  *
  * @category constructors
  * @since 4.0.0
  */
-export const text = (body: string, contentType?: string): Uint8Array =>
-  uint8Array(encoder.encode(body), contentType ?? "text/plain")
+export const text = (body: string, contentType?: string): Uint8Array => {
+  if (typeof body !== "string") {
+    // Preserve untyped callers that relied on TextEncoder coercion.
+    body = body === undefined ? "" : String(body)
+  }
+  if (buffer !== undefined) {
+    return new Uint8Array(undefined, contentType ?? "text/plain", buffer.byteLength(body, "utf8"), body)
+  }
+  const bytes = encoder.encode(body)
+  return new Uint8Array(bytes, contentType ?? "text/plain", bytes.length, body)
+}
 
 /**
  * Creates a JSON HTTP body using `JSON.stringify`, throwing if serialization fails.
@@ -484,18 +513,44 @@ export const stream = (
   contentLength?: number
 ): Stream => new Stream(body, contentType ?? "application/octet-stream", contentLength)
 
-const fileContentLength = (
-  size: FileSystem.SizeInput,
+const fileRangeSize = (
+  input: ByteSize.Input,
+  field: string,
+  method: string
+): Effect.Effect<ByteSize.ByteSize, PlatformError.PlatformError> => {
+  const size = ByteSize.fromInput(input)
+  return Option.isSome(size)
+    ? Effect.succeed(size.value)
+    : Effect.fail(PlatformError.badArgument({
+      module: "HttpBody",
+      method,
+      description: `Invalid ${field}: ${input}`
+    }))
+}
+
+const fileContentLength = Effect.fnUntraced(function*(
+  size: ByteSize.ByteSize,
+  method: string,
   options?: {
-    readonly bytesToRead?: FileSystem.SizeInput | undefined
-    readonly offset?: FileSystem.SizeInput | undefined
+    readonly bytesToRead?: ByteSize.Input | undefined
+    readonly offset?: ByteSize.Input | undefined
   }
-): number => {
-  const available = Math.max(0, Number(size) - Number(options?.offset ?? 0))
-  return options?.bytesToRead === undefined
-    ? available
-    : Math.min(available, Math.max(0, Number(options.bytesToRead)))
-}
+): Effect.fn.Return<number, PlatformError.PlatformError> {
+  const offset = options?.offset === undefined ? ByteSize.zero : yield* fileRangeSize(options.offset, "offset", method)
+  const bytesToRead = options?.bytesToRead === undefined
+    ? undefined
+    : yield* fileRangeSize(options.bytesToRead, "bytesToRead", method)
+  const available = offset >= size ? BigInt("0") : size - offset
+  const length = bytesToRead === undefined || bytesToRead > available ? available : bytesToRead
+  if (length > BigInt(Number.MAX_SAFE_INTEGER)) {
+    return yield* Effect.fail(PlatformError.badArgument({
+      module: "HttpBody",
+      method,
+      description: `Content length exceeds Number.MAX_SAFE_INTEGER: ${length}`
+    }))
+  }
+  return Number(length)
+})
 
 /**
  * Creates a streaming HTTP body for a file path.
@@ -505,27 +560,37 @@ const fileContentLength = (
  * The effect requires `FileSystem`, stats the file to set the selected content length, and can fail with
  * `PlatformError`.
  *
+ * Range validation and file access are deferred until the effect runs. Numeric range inputs must be
+ * non-negative safe integers; bigint and byte-size strings can represent larger values. Malformed strings,
+ * negative values, and non-finite, fractional, or unsafe numbers fail with `PlatformError` / `BadArgument`.
+ *
+ * The selected length is calculated exactly with bigint arithmetic and clamped to the bytes available after
+ * `offset` (zero at or past EOF). Since `Stream.contentLength` is a number, a final length above
+ * `Number.MAX_SAFE_INTEGER` fails with `BadArgument`. Larger sizes, offsets, and byte counts are valid when
+ * the final clamped length is representable; the resulting Content-Length header preserves that exact length.
+ *
  * @category constructors
  * @since 4.0.0
  */
 export const file = (
   path: string,
   options?: {
-    readonly bytesToRead?: FileSystem.SizeInput | undefined
-    readonly chunkSize?: FileSystem.SizeInput | undefined
-    readonly offset?: FileSystem.SizeInput | undefined
+    readonly bytesToRead?: ByteSize.Input | undefined
+    readonly chunkSize?: number | undefined
+    readonly offset?: ByteSize.Input | undefined
     readonly contentType?: string | undefined
   }
 ): Effect.Effect<Stream, PlatformError.PlatformError, FileSystem.FileSystem> =>
   Effect.flatMap(
     FileSystem.FileSystem,
     (fs) =>
-      Effect.map(fs.stat(path), (info) =>
-        stream(
-          fs.stream(path, options),
-          options?.contentType,
-          fileContentLength(info.size, options)
-        ))
+      Effect.flatMap(fs.stat(path), (info) =>
+        Effect.map(fileContentLength(info.size, "file", options), (contentLength) =>
+          stream(
+            fs.stream(path, options),
+            options?.contentType,
+            contentLength
+          )))
   )
 
 /**
@@ -536,6 +601,11 @@ export const file = (
  * The effect requires `FileSystem`, uses the provided file size to determine the selected content length, and can
  * fail with `PlatformError`.
  *
+ * Like {@link file}, this constructor validates ranges lazily and calculates the EOF-clamped length with exact
+ * bigint arithmetic. Invalid range inputs and final lengths above `Number.MAX_SAFE_INTEGER` fail with
+ * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts remain valid when the final length
+ * is representable as a safe integer, preserving the exact Content-Length header.
+ *
  * @category constructors
  * @since 4.0.0
  */
@@ -543,18 +613,19 @@ export const fileFromInfo = (
   path: string,
   info: FileSystem.File.Info,
   options?: {
-    readonly bytesToRead?: FileSystem.SizeInput | undefined
-    readonly chunkSize?: FileSystem.SizeInput | undefined
-    readonly offset?: FileSystem.SizeInput | undefined
+    readonly bytesToRead?: ByteSize.Input | undefined
+    readonly chunkSize?: number | undefined
+    readonly offset?: ByteSize.Input | undefined
     readonly contentType?: string | undefined
   }
 ): Effect.Effect<Stream, PlatformError.PlatformError, FileSystem.FileSystem> =>
-  Effect.map(
+  Effect.flatMap(
     FileSystem.FileSystem,
     (fs) =>
-      stream(
-        fs.stream(path, options),
-        options?.contentType,
-        fileContentLength(info.size, options)
-      )
+      Effect.map(fileContentLength(info.size, "fileFromInfo", options), (contentLength) =>
+        stream(
+          fs.stream(path, options),
+          options?.contentType,
+          contentLength
+        ))
   )

package/src/unstable/http/HttpClient.ts

@@ -348,9 +348,9 @@ const catch_: {
   <E, E2, R2>(
     f: (e: E) => Effect.Effect<HttpClientResponse.HttpClientResponse, E2, R2>
   ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E2, R2 | R>
-  <E, R, A2, E2, R2>(
+  <E, R, E2, R2>(
     self: HttpClient.With<E, R>,
-    f: (e: E) => Effect.Effect<A2, E2, R2>
+    f: (e: E) => Effect.Effect<HttpClientResponse.HttpClientResponse, E2, R2>
   ): HttpClient.With<E2, R | R2>
 } = dual(
   2,
@@ -1976,36 +1976,43 @@ export const followRedirects: {
   makeWith(
     (request) => {
       const loop = (
-        request: HttpClientRequest.HttpClientRequest,
+        request: Effect.Effect<HttpClientRequest.HttpClientRequest, E, R>,
         redirects: number
       ): Effect.Effect<HttpClientResponse.HttpClientResponse, E, R> =>
-        Effect.flatMap(
-          self.postprocess(Effect.succeed(request)),
-          (response) => {
-            if (
-              response.status < 300 || response.status >= 400 || !response.headers.location ||
-              redirects >= (maxRedirects ?? 10)
-            ) {
-              return Effect.succeed(response)
-            }
-            const url = new URL(response.headers.location, response.request.url)
-            let nextRequest = request
-            if (
-              ((response.status === 301 || response.status === 302) && request.method === "POST") ||
-              (response.status === 303 && request.method !== "GET" && request.method !== "HEAD")
-            ) {
-              nextRequest = HttpClientRequest.setMethod(nextRequest, "GET")
-              nextRequest = HttpClientRequest.setBody(nextRequest, HttpBody.empty)
-            }
-            if (url.origin !== new URL(response.request.url).origin) {
-              nextRequest = HttpClientRequest.removeHeader(nextRequest, "authorization")
-              nextRequest = HttpClientRequest.removeHeader(nextRequest, "proxy-authorization")
-              nextRequest = HttpClientRequest.removeHeader(nextRequest, "cookie")
+        Effect.suspend(() => {
+          let currentRequest: HttpClientRequest.HttpClientRequest | undefined
+          return Effect.flatMap(
+            self.postprocess(Effect.map(request, (request) => {
+              currentRequest = request
+              return request
+            })),
+            (response) => {
+              if (
+                response.status < 300 || response.status >= 400 || !response.headers.location ||
+                redirects >= (maxRedirects ?? 10)
+              ) {
+                return Effect.succeed(response)
+              }
+              const url = new URL(response.headers.location, response.request.url)
+              const request = currentRequest ?? response.request
+              let nextRequest = request
+              if (
+                ((response.status === 301 || response.status === 302) && request.method === "POST") ||
+                (response.status === 303 && request.method !== "GET" && request.method !== "HEAD")
+              ) {
+                nextRequest = HttpClientRequest.setMethod(nextRequest, "GET")
+                nextRequest = HttpClientRequest.setBody(nextRequest, HttpBody.empty)
+              }
+              if (url.origin !== new URL(response.request.url).origin) {
+                nextRequest = HttpClientRequest.removeHeader(nextRequest, "authorization")
+                nextRequest = HttpClientRequest.removeHeader(nextRequest, "proxy-authorization")
+                nextRequest = HttpClientRequest.removeHeader(nextRequest, "cookie")
+              }
+              return loop(Effect.succeed(HttpClientRequest.setUrl(nextRequest, url)), redirects + 1)
             }
-            return loop(HttpClientRequest.setUrl(nextRequest, url), redirects + 1)
-          }
-        )
-      return Effect.flatMap(request, (request) => loop(request, 0))
+          )
+        })
+      return loop(request, 0)
     },
     self.preprocess
   ))
@@ -2040,7 +2047,7 @@ export const TracerHeaderFilter = Context.Reference<
  * @category services
  * @since 4.0.0
  */
-export const TracerPropagationEnabled = Context.Reference<boolean>("effect/HttpClient/TracerPropagationEnabled", {
+export const TracerPropagationEnabled = Context.Reference<boolean>("effect/http/HttpClient/TracerPropagationEnabled", {
   defaultValue: constTrue
 })
 
@@ -2142,6 +2149,10 @@ class InterruptibleResponse implements HttpClientResponse.HttpClientResponse, Pi
     return this.original.request
   }
 
+  get url() {
+    return this.original.url
+  }
+
   get status() {
     return this.original.status
   }

package/src/unstable/http/HttpClientRequest.ts

@@ -9,6 +9,7 @@
  *
  * @since 4.0.0
  */
+import type * as ByteSize from "../../ByteSize.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
@@ -1168,6 +1169,13 @@ export const bodyStream: {
 /**
  * Creates a file-backed request body from a filesystem path and sets it on the request.
  *
+ * **Details**
+ *
+ * Uses {@link HttpBody.file} to validate ranges lazily and calculate the EOF-clamped content length with exact
+ * bigint arithmetic. Invalid range inputs or a final length above `Number.MAX_SAFE_INTEGER` fail with
+ * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts are valid when the final length is
+ * representable as a safe integer. The request's Content-Length header contains that exact length.
+ *
  * @category combinators
  * @since 4.0.0
  */
@@ -1175,21 +1183,35 @@ export const bodyFile: {
   /**
    * Creates a file-backed request body from a filesystem path and sets it on the request.
    *
+   * **Details**
+   *
+   * Uses {@link HttpBody.file} to validate ranges lazily and calculate the EOF-clamped content length with exact
+   * bigint arithmetic. Invalid range inputs or a final length above `Number.MAX_SAFE_INTEGER` fail with
+   * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts are valid when the final length is
+   * representable as a safe integer. The request's Content-Length header contains that exact length.
+   *
    * @category combinators
    * @since 4.0.0
    */
   (
     path: string,
     options?: {
-      readonly bytesToRead?: FileSystem.SizeInput | undefined
-      readonly chunkSize?: FileSystem.SizeInput | undefined
-      readonly offset?: FileSystem.SizeInput | undefined
+      readonly bytesToRead?: ByteSize.Input | undefined
+      readonly chunkSize?: number | undefined
+      readonly offset?: ByteSize.Input | undefined
       readonly contentType?: string
     }
   ): (self: HttpClientRequest) => Effect.Effect<HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
   /**
    * Creates a file-backed request body from a filesystem path and sets it on the request.
    *
+   * **Details**
+   *
+   * Uses {@link HttpBody.file} to validate ranges lazily and calculate the EOF-clamped content length with exact
+   * bigint arithmetic. Invalid range inputs or a final length above `Number.MAX_SAFE_INTEGER` fail with
+   * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts are valid when the final length is
+   * representable as a safe integer. The request's Content-Length header contains that exact length.
+   *
    * @category combinators
    * @since 4.0.0
    */
@@ -1197,9 +1219,9 @@ export const bodyFile: {
     self: HttpClientRequest,
     path: string,
     options?: {
-      readonly bytesToRead?: FileSystem.SizeInput | undefined
-      readonly chunkSize?: FileSystem.SizeInput | undefined
-      readonly offset?: FileSystem.SizeInput | undefined
+      readonly bytesToRead?: ByteSize.Input | undefined
+      readonly chunkSize?: number | undefined
+      readonly offset?: ByteSize.Input | undefined
       readonly contentType?: string
     }
   ): Effect.Effect<HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
@@ -1209,9 +1231,9 @@ export const bodyFile: {
     self: HttpClientRequest,
     path: string,
     options?: {
-      readonly bytesToRead?: FileSystem.SizeInput | undefined
-      readonly chunkSize?: FileSystem.SizeInput | undefined
-      readonly offset?: FileSystem.SizeInput | undefined
+      readonly bytesToRead?: ByteSize.Input | undefined
+      readonly chunkSize?: number | undefined
+      readonly offset?: ByteSize.Input | undefined
       readonly contentType?: string
     }
   ): Effect.Effect<HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem> =>
@@ -1257,18 +1279,10 @@ const fromWebBody = (request: globalThis.Request, method: HttpMethod): HttpBody.
   }
   return HttpBody.raw(request.body, {
     contentType: request.headers.get("content-type") ?? undefined,
-    contentLength: parseContentLength(request.headers.get("content-length"))
+    contentLength: bodyInternal.parseContentLength(request.headers.get("content-length"))
   })
 }
 
-const parseContentLength = (contentLength: string | null): number | undefined => {
-  if (contentLength === null) {
-    return undefined
-  }
-  const parsed = Number.parseInt(contentLength, 10)
-  return Number.isNaN(parsed) ? undefined : parsed
-}
-
 /**
  * Converts an `HttpClientRequest` safely to a Web `Request` as a `Result`, failing when the request URL is invalid.
  *

package/src/unstable/http/HttpClientResponse.ts

@@ -21,7 +21,7 @@ import type { Unify } from "../../Unify.ts"
 import * as Cookies from "./Cookies.ts"
 import * as Headers from "./Headers.ts"
 import * as Error from "./HttpClientError.ts"
-import type * as HttpClientRequest from "./HttpClientRequest.ts"
+import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -66,6 +66,11 @@ export const TypeId = "~effect/http/HttpClientResponse"
 export interface HttpClientResponse extends HttpIncomingMessage.HttpIncomingMessage<Error.HttpClientError>, Pipeable {
   readonly [TypeId]: typeof TypeId
   readonly request: HttpClientRequest.HttpClientRequest
+  /**
+   * The resolved URL, including query parameters and excluding the hash.
+   * Uses the final URL when redirects are followed. Empty if unknown.
+   */
+  readonly url: string
   readonly status: number
   readonly cookies: Cookies.Cookies
   readonly formData: Effect.Effect<FormData, Error.HttpClientError>
@@ -98,7 +103,7 @@ export const schemaJson = <
   schema: Schema.ConstraintCodec<A, I, RD, unknown>,
   options?: (ParseOptions & HttpIncomingMessage.JsonOptions) | undefined
 ) => {
-  const decode = Schema.decodeEffect(Schema.toCodecJson(schema).annotate({ options }))
+  const decode = Schema.decodeEffect(Schema.toCodecJson(schema), options)
   const decodeBody = HttpIncomingMessage.schemaBodyJson(Schema.Unknown, options)
   return (
     self: HttpClientResponse
@@ -129,7 +134,7 @@ export const schemaNoBody = <
   schema: Schema.Codec<A, I, RD, RE>,
   options?: ParseOptions | undefined
 ) => {
-  const decode = Schema.decodeEffect(schema.annotate({ options }))
+  const decode = Schema.decodeEffect(schema, options)
   return (self: HttpClientResponse): Effect.Effect<A, Schema.SchemaError, RD> =>
     decode({
       status: self.status,
@@ -299,6 +304,14 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
     return this.source.status
   }
 
+  get url(): string {
+    if (this.source.url) return this.source.url.split("#")[0]
+    const url = HttpClientRequest.toUrl(this.request)
+    if (Option.isNone(url)) return ""
+    url.value.hash = ""
+    return url.value.href
+  }
+
   get headers(): Headers.Headers {
     return Headers.fromInput(this.source.headers)
   }