effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/unstable/http/FetchHttpClient.ts

@@ -68,7 +68,7 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
             method: request.method,
             headers,
             body,
-            duplex: request.body._tag === "Stream" ? "half" : undefined,
+            duplex: typeof ReadableStream !== "undefined" && body instanceof ReadableStream ? "half" : undefined,
             signal
           } as any),
         catch: (cause) =>

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

@@ -28,6 +28,12 @@ import * as QS from "./queryString.ts"
 const FULL_PATH_REGEXP = /^https?:\/\/.*?\//
 const OPTIONAL_PARAM_REGEXP = /(\/:[^/()]*?)\?(\/?)/
 
+const emptyParamsArray: ReadonlyArray<string> = []
+
+// Matches one terminal parameter without wildcard, regex, or static suffix syntax.
+const CLEAN_SINGLE_PARAM_REGEXP = /^[^:*(]*\/:[^/:*(.-]+$/
+const isCleanSingleTrailingParam = (path: string): boolean => CLEAN_SINGLE_PARAM_REGEXP.test(path)
+
 interface Route<A = unknown> {
   readonly method: string
   readonly path: Router.PathInput
@@ -55,6 +61,11 @@ class RouterImpl<A> implements Router.Router<A> {
   readonly options: Router.RouterConfig
   routes: Array<Route> = []
   trees: Record<string, StaticNode> = Object.create(null)
+  staticRoutes: Record<string, Map<string, Handler>> = Object.create(null)
+  singleParamRoutes: Record<string, Map<string, Handler>> = Object.create(null)
+  singleParamDisabled: Record<string, boolean> = Object.create(null)
+  readonly brothersNodesStack: Array<BrotherNode> = []
+  readonly singleParamArray: Array<string> = [""]
 
   on(
     method: string | Iterable<string>,
@@ -253,6 +264,32 @@ class RouterImpl<A> implements Router.Router<A> {
     const route = { method, path, pattern, params, handler }
     this.routes.push(route)
     currentNode.addRoute(route)
+
+    // Cache static routes by normalized path for direct lookup.
+    if (params.length === 0) {
+      const staticKey = pattern.split("::").join(":").split("%").join("%25")
+      const store = this.staticRoutes[method] ??= new Map()
+      if (!store.has(staticKey)) {
+        store.set(staticKey, currentNode.handlerStorage!.unconstrainedHandler!)
+      }
+    } else if (isCleanSingleTrailingParam(path)) {
+      // Cache "/prefix/:param" routes for direct prefix matching.
+      if (this.singleParamDisabled[method] !== true) {
+        let prefix = path.slice(0, path.indexOf(":"))
+        if (!this.options.caseSensitive) {
+          prefix = prefix.toLowerCase()
+        }
+        prefix = prefix.split("%").join("%25")
+        const store = this.singleParamRoutes[method] ??= new Map()
+        if (!store.has(prefix)) {
+          store.set(prefix, currentNode.handlerStorage!.unconstrainedHandler!)
+        }
+      }
+    } else if (/[(*]|[^/]:|:[^/]*[-.]/.test(path)) {
+      // Complex parameters may shadow a cached single-parameter route.
+      this.singleParamDisabled[method] = true
+      delete this.singleParamRoutes[method]
+    }
   }
 
   has(method: string, path: string): boolean {
@@ -273,48 +310,101 @@ class RouterImpl<A> implements Router.Router<A> {
     let currentNode: Node | undefined = this.trees[method]
     if (currentNode === undefined) return undefined
 
-    if (path.charCodeAt(0) !== 47) {
-      // 47 is '/'
-      path = path.replace(FULL_PATH_REGEXP, "/")
+    let querystring = ""
+    let shouldDecodeParam = false
+
+    // Skip normalization for canonical lowercase paths.
+    let clean = path.charCodeAt(0) === 47 &&
+      (path.length === 1 || path.charCodeAt(path.length - 1) !== 47)
+    if (clean) {
+      for (let i = 1; i < path.length; i++) {
+        const code = path.charCodeAt(i)
+        if (
+          code === 37 || code === 63 || code === 59 || code === 35 ||
+          (code >= 65 && code <= 90) ||
+          (code === 47 && path.charCodeAt(i - 1) === 47)
+        ) {
+          clean = false
+          break
+        }
+      }
     }
 
-    // This must be run before sanitizeUrl as the resulting function
-    // .sliceParameter must be constructed with same URL string used
-    // throughout the rest of this function.
-    if (this.options.ignoreDuplicateSlashes) {
-      path = removeDuplicateSlashes(path)
-    }
+    if (!clean) {
+      if (path.charCodeAt(0) !== 47) {
+        // 47 is '/'
+        path = path.replace(FULL_PATH_REGEXP, "/")
+      }
 
-    let sanitizedUrl
-    let querystring
-    let shouldDecodeParam
+      // This must be run before sanitizeUrl as the resulting function
+      // .sliceParameter must be constructed with same URL string used
+      // throughout the rest of this function.
+      if (this.options.ignoreDuplicateSlashes) {
+        path = removeDuplicateSlashes(path)
+      }
 
-    try {
-      sanitizedUrl = safeDecodeURI(path)
-      path = sanitizedUrl.path
-      querystring = sanitizedUrl.querystring
-      shouldDecodeParam = sanitizedUrl.shouldDecodeParam
-    } catch (error) {
-      return undefined
-    }
+      let sanitizedUrl
+      try {
+        sanitizedUrl = safeDecodeURI(path)
+        path = sanitizedUrl.path
+        querystring = sanitizedUrl.querystring
+        shouldDecodeParam = sanitizedUrl.shouldDecodeParam
+      } catch (error) {
+        return undefined
+      }
 
-    if (this.options.ignoreTrailingSlash) {
-      path = trimLastSlash(path)
+      if (this.options.ignoreTrailingSlash) {
+        path = trimLastSlash(path)
+      }
     }
 
     const originPath = path
 
-    if (this.options.caseSensitive === false) {
+    if (!clean && this.options.caseSensitive === false) {
       path = path.toLowerCase()
     }
 
     const maxParamLength = this.options.maxParamLength
 
+    const staticStore = this.staticRoutes[method]
+    if (staticStore !== undefined) {
+      const handle = staticStore.get(path)
+      if (handle !== undefined) {
+        return {
+          handler: handle.handler as A,
+          params: handle.createParams(emptyParamsArray),
+          searchParams: QS.parse(querystring)
+        } as const
+      }
+    }
+
+    const singleParamStore = this.singleParamRoutes[method]
+    if (singleParamStore !== undefined) {
+      const prefixLength = path.lastIndexOf("/") + 1
+      const handle = singleParamStore.get(path.slice(0, prefixLength))
+      if (handle !== undefined && path.length > prefixLength) {
+        let param = originPath.slice(prefixLength)
+        if (shouldDecodeParam) {
+          param = safeDecodeURIComponent(param)
+        }
+        if (param.length <= maxParamLength) {
+          this.singleParamArray[0] = param
+          return {
+            handler: handle.handler as A,
+            params: handle.createParams(this.singleParamArray),
+            searchParams: QS.parse(querystring)
+          } as const
+        }
+      }
+    }
+
     let pathIndex = (currentNode as StaticNode).prefix.length
     const params = []
     const pathLen = path.length
 
-    const brothersNodesStack: Array<BrotherNode> = []
+    // Reuse this router's synchronous backtracking stack.
+    const brothersNodesStack = this.brothersNodesStack
+    brothersNodesStack.length = 0
 
     while (true) {
       if (pathIndex === pathLen && currentNode.isLeafNode) {
@@ -577,18 +667,12 @@ class StaticNode extends ParentNode {
   private setPrefix(prefix: string) {
     this.prefix = prefix
 
+    // Child selection already matched the first character.
     if (prefix.length === 1) {
       this.matchPrefix = (_path, _pathIndex) => true
     } else {
-      const len = prefix.length
-      this.matchPrefix = function(path, pathIndex) {
-        for (let i = 1; i < len; i++) {
-          if (path.charCodeAt(pathIndex + i) !== this.prefix.charCodeAt(i)) {
-            return false
-          }
-        }
-        return true
-      }
+      const tail = prefix.slice(1)
+      this.matchPrefix = (path, pathIndex) => path.startsWith(tail, pathIndex + 1)
     }
   }
 
@@ -745,6 +829,9 @@ const assert: Assert = (condition, message) => {
 }
 
 function removeDuplicateSlashes(path: string): Router.PathInput {
+  if (path.indexOf("//") === -1) {
+    return path as Router.PathInput
+  }
   return path.replace(/\/\/+/g, "/") as Router.PathInput
 }
 
@@ -755,10 +842,29 @@ function trimLastSlash(path: string): Router.PathInput {
   return path as Router.PathInput
 }
 
+// Compile safe, unique parameter names into a stable null-prototype shape.
+// Other names and codegen-restricted runtimes use assignment.
+const safeParamName = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+const isCompilableParamName = (name: string): boolean => name !== "__proto__" && safeParamName.test(name)
+
 function compileCreateParams(
   params: ReadonlyArray<string>
 ): (paramsArray: ReadonlyArray<string>) => Record<string, string> {
   const len = params.length
+  if (len === 0) {
+    return () => Object.create(null)
+  }
+  if (params.every(isCompilableParamName) && new Set(params).size === len) {
+    try {
+      // eslint-disable-next-line no-new-func
+      return new Function(
+        "a",
+        `return {__proto__:null,${params.map((name, i) => `${name}:a[${i}]`).join(",")}}`
+      ) as (paramsArray: ReadonlyArray<string>) => Record<string, string>
+    } catch {
+      // Use assignment when CSP blocks Function construction.
+    }
+  }
   return function(paramsArray) {
     const paramsObject: Record<string, string> = Object.create(null)
     for (let i = 0; i < len; i++) {

package/src/unstable/http/FindMyWay.ts

@@ -30,8 +30,10 @@ import * as internal from "./FindMyWay/internal/router.ts"
  */
 
 /**
- * @since 4.0.0
+ * Configuration for router path matching.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface RouterConfig {
   readonly ignoreTrailingSlash: boolean
@@ -41,14 +43,18 @@ export interface RouterConfig {
 }
 
 /**
- * @since 4.0.0
+ * Route path accepted by the router.
+ *
  * @category models
+ * @since 4.0.0
  */
 export type PathInput = `/${string}` | "*"
 
 /**
- * @since 4.0.0
+ * Mutable router used to register and resolve route handlers.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface Router<A> {
   readonly on: (method: string | Iterable<string>, path: PathInput, handler: A) => void
@@ -58,8 +64,10 @@ export interface Router<A> {
 }
 
 /**
- * @since 4.0.0
+ * Result of a successful route lookup.
+ *
  * @category models
+ * @since 4.0.0
  */
 export interface FindResult<A> {
   readonly handler: A
@@ -68,7 +76,9 @@ export interface FindResult<A> {
 }
 
 /**
- * @since 4.0.0
+ * Creates an empty mutable router.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const make: <A>(options?: Partial<RouterConfig>) => Router<A> = internal.make

package/src/unstable/http/Headers.ts

@@ -19,8 +19,6 @@ import * as Predicate from "../../Predicate.ts"
 import * as Record from "../../Record.ts"
 import * as Redactable from "../../Redactable.ts"
 import * as Redacted from "../../Redacted.ts"
-import * as Schema from "../../Schema.ts"
-import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import type { Mutable } from "../../Types.ts"
 
 /**
@@ -109,49 +107,6 @@ const make = (input: Record.ReadonlyRecord<string, string>): Mutable<Headers> =>
  */
 export const Equivalence: Equ.Equivalence<Headers> = Record.makeEquivalence(Equ.strictEqual<string>())
 
-/**
- * Schema interface for `Headers` values encoded as records of string header values.
- *
- * @category schemas
- * @since 4.0.0
- */
-export interface HeadersSchema extends Schema.declare<Headers, { readonly [x: string]: string }> {}
-
-/**
- * Schema for `Headers` values encoded as records of string header values.
- *
- * **Details**
- *
- * Decoding normalizes header names through `fromInput`; encoding returns a plain record.
- *
- * @category schemas
- * @since 4.0.0
- */
-export const HeadersSchema: HeadersSchema = Schema.declare(
-  isHeaders,
-  {
-    representation: {
-      id: "effect/http/Headers",
-      payload: null
-    },
-    toCode: () => ({
-      runtime: "Headers.HeadersSchema",
-      Type: "Headers.Headers",
-      importDeclarations: [`import * as Headers from "effect/unstable/http/Headers"`]
-    }),
-    expected: "Headers",
-    toEquivalence: () => Equivalence,
-    toCodec: () =>
-      Schema.link<Headers>()(
-        Schema.Record(Schema.String, Schema.String),
-        SchemaTransformation.transform({
-          decode: (input) => fromInput(input),
-          encode: (headers) => ({ ...headers })
-        })
-      )
-  }
-)
-
 /**
  * Input accepted when constructing headers.
  *
@@ -694,7 +649,7 @@ export const redact: {
         }
       } else {
         for (const name in self) {
-          if (key.test(name)) {
+          if (name.search(key) !== -1) {
             out[name] = Redacted.make(self[name])
           }
         }
@@ -730,10 +685,10 @@ export const isRedactedName = (
   for (let i = 0; i < patterns.length; i++) {
     const pattern = patterns[i]
     if (typeof pattern === "string") {
-      if (pattern.toLowerCase() === name) {
+      if (pattern.toLowerCase() === name.toLowerCase()) {
         return true
       }
-    } else if (pattern.test(name)) {
+    } else if (name.search(pattern) !== -1) {
       return true
     }
   }

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
+        ))
   )