@effect/platform 0.11.4 → 0.12.0

package/src/FileSystem.ts

@@ -219,7 +219,7 @@ export interface FileSystem {
    */
   readonly truncate: (
     path: string,
-    length?: Size
+    length?: SizeInput
   ) => Effect.Effect<never, PlatformError, void>
   /**
    * Change the file system timestamps of the file at `path`.
@@ -255,11 +255,19 @@ export interface FileSystem {
  */
 export type Size = Brand.Branded<bigint, "Size">
 
+/**
+ * Represents a size in bytes.
+ *
+ * @since 1.0.0
+ * @category model
+ */
+export type SizeInput = bigint | number | Size
+
 /**
  * @since 1.0.0
  * @category constructor
  */
-export const Size: (bytes: number | bigint) => Size = internal.Size
+export const Size: (bytes: SizeInput) => Size = internal.Size
 
 /**
  * @since 1.0.0
@@ -360,9 +368,9 @@ export interface SinkOptions extends OpenFileOptions {}
  */
 export interface StreamOptions {
   readonly bufferSize?: number
-  readonly bytesToRead?: Size
-  readonly chunkSize?: Size
-  readonly offset?: Size
+  readonly bytesToRead?: SizeInput
+  readonly chunkSize?: SizeInput
+  readonly offset?: SizeInput
 }
 
 /**
@@ -422,28 +430,15 @@ export const isFile = (u: unknown): u is File => typeof u === "object" && u !==
  * @category model
  */
 export interface File {
-  readonly [FileTypeId]: (_: never) => unknown
+  readonly [FileTypeId]: FileTypeId
   readonly fd: File.Descriptor
   readonly stat: Effect.Effect<never, PlatformError, File.Info>
-  readonly seek: (
-    offset: Size,
-    from: SeekMode
-  ) => Effect.Effect<never, never, void>
-  readonly read: (
-    buffer: Uint8Array
-  ) => Effect.Effect<never, PlatformError, Size>
-  readonly readAlloc: (
-    size: Size
-  ) => Effect.Effect<never, PlatformError, Option<Uint8Array>>
-  readonly truncate: (
-    length?: Size
-  ) => Effect.Effect<never, PlatformError, void>
-  readonly write: (
-    buffer: Uint8Array
-  ) => Effect.Effect<never, PlatformError, Size>
-  readonly writeAll: (
-    buffer: Uint8Array
-  ) => Effect.Effect<never, PlatformError, void>
+  readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<never, never, void>
+  readonly read: (buffer: Uint8Array) => Effect.Effect<never, PlatformError, Size>
+  readonly readAlloc: (size: SizeInput) => Effect.Effect<never, PlatformError, Option<Uint8Array>>
+  readonly truncate: (length?: SizeInput) => Effect.Effect<never, PlatformError, void>
+  readonly write: (buffer: Uint8Array) => Effect.Effect<never, PlatformError, Size>
+  readonly writeAll: (buffer: Uint8Array) => Effect.Effect<never, PlatformError, void>
 }
 
 /**

package/src/Http/App.ts

@@ -0,0 +1,19 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Effect from "@effect/io/Effect"
+import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import type * as ServerResponse from "@effect/platform/Http/ServerResponse"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface HttpApp<R, E, A> extends Effect.Effect<R | ServerRequest.ServerRequest, E, A> {
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type Default<R, E> = HttpApp<R, E, ServerResponse.ServerResponse>

package/src/Http/Body.ts

@@ -2,6 +2,8 @@
  * @since 1.0.0
  */
 import type * as Effect from "@effect/io/Effect"
+import type * as PlatformError from "@effect/platform/Error"
+import type * as FileSystem from "@effect/platform/FileSystem"
 import * as internal from "@effect/platform/internal/http/body"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Stream_ from "@effect/stream/Stream"
@@ -22,7 +24,13 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export type Body = Empty | Raw | Bytes | BytesEffect | FormData | Stream
+export type Body = Empty | Raw | Uint8Array | EffectBody | FormData | Stream
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type NonEffect = Exclude<Body, EffectBody>
 
 /**
  * @since 1.0.0
@@ -73,49 +81,57 @@ export const raw: (body: unknown) => Raw = internal.raw
  * @since 1.0.0
  * @category models
  */
-export interface Bytes extends Body.Proto {
-  readonly _tag: "Bytes"
-  readonly body: Uint8Array
+export interface Uint8Array extends Body.Proto {
+  readonly _tag: "Uint8Array"
+  readonly body: globalThis.Uint8Array
+  readonly contentType: string
+  readonly contentLength: number
 }
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const bytes: (body: Uint8Array) => Bytes = internal.bytes
+export const uint8Array: (body: globalThis.Uint8Array) => Uint8Array = internal.uint8Array
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const text: (body: string, contentType?: string) => Bytes = internal.text
+export const text: (body: string, contentType?: string) => Uint8Array = internal.text
 
 /**
  * @since 1.0.0
  * @category models
  */
-export interface BytesEffect extends Body.Proto {
-  readonly _tag: "BytesEffect"
-  readonly body: Effect.Effect<never, unknown, Uint8Array>
+export interface EffectBody extends Body.Proto {
+  readonly _tag: "Effect"
+  readonly effect: Effect.Effect<never, unknown, NonEffect>
 }
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const bytesEffect: (body: Effect.Effect<never, unknown, Uint8Array>) => BytesEffect = internal.bytesEffect
+export const effect: (body: Effect.Effect<never, unknown, NonEffect>) => EffectBody = internal.effect
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const json: (body: unknown) => BytesEffect = internal.json
+export const unsafeJson: (body: unknown) => Uint8Array = internal.unsafeJson
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const jsonSchema: <I, A>(schema: Schema.Schema<I, A>) => (body: A) => BytesEffect = internal.jsonSchema
+export const json: (body: unknown) => EffectBody = internal.json
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const jsonSchema: <I, A>(schema: Schema.Schema<I, A>) => (body: A) => EffectBody = internal.jsonSchema
 
 /**
  * @since 1.0.0
@@ -138,11 +154,22 @@ export const formData: (body: globalThis.FormData) => FormData = internal.formDa
  */
 export interface Stream extends Body.Proto {
   readonly _tag: "Stream"
-  readonly stream: Stream_.Stream<never, unknown, Uint8Array>
+  readonly stream: Stream_.Stream<never, unknown, globalThis.Uint8Array>
+  readonly contentType: string
+  readonly contentLength?: number
 }
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const stream: (body: Stream_.Stream<never, unknown, Uint8Array>) => Stream = internal.stream
+export const stream: (body: Stream_.Stream<never, unknown, globalThis.Uint8Array>) => Stream = internal.stream
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const file: (
+  path: string,
+  options?: FileSystem.StreamOptions & { readonly contentType?: string }
+) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, Stream> = internal.file

package/src/Http/Client.ts

@@ -2,6 +2,7 @@
  * @since 1.0.0
  */
 import type * as Context from "@effect/data/Context"
+import type { Pipeable } from "@effect/data/Pipeable"
 import type * as Predicate from "@effect/data/Predicate"
 import type * as Effect from "@effect/io/Effect"
 import type * as Layer from "@effect/io/Layer"
@@ -17,7 +18,7 @@ import type * as Schema from "@effect/schema/Schema"
  * @since 1.0.0
  * @category models
  */
-export interface Client<R, E, A> {
+export interface Client<R, E, A> extends Pipeable {
   (request: ClientRequest.ClientRequest): Effect.Effect<R, E, A>
 }
 
@@ -48,7 +49,7 @@ export const Client: Context.Tag<Client.Default, Client.Default> = internal.tag
  * @since 1.0.0
  * @category layers
  */
-export const fetchLayer: Layer.Layer<never, never, Client.Default> = internal.fetchLayer
+export const layer: Layer.Layer<never, never, Client.Default> = internal.layer
 
 /**
  * @since 1.0.0
@@ -184,6 +185,16 @@ export const filterStatusOk: <R, E>(
   self: Client.WithResponse<R, E>
 ) => Client.WithResponse<R, Error.ResponseError | E> = internal.filterStatusOk
 
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: (
+  f: (
+    request: ClientRequest.ClientRequest.NonEffectBody
+  ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
+) => Client.Default = internal.make
+
 /**
  * @since 1.0.0
  * @category mapping & sequencing

package/src/Http/ClientRequest.ts

@@ -2,6 +2,9 @@
  * @since 1.0.0
  */
 import type { Pipeable } from "@effect/data/Pipeable"
+import type * as Effect from "@effect/io/Effect"
+import type * as PlatformError from "@effect/platform/Error"
+import type * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as Headers from "@effect/platform/Http/Headers"
@@ -36,6 +39,19 @@ export interface ClientRequest extends Pipeable {
   readonly body: Body.Body
 }
 
+/**
+ * @since 1.0.0
+ */
+export namespace ClientRequest {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface NonEffectBody extends ClientRequest {
+    readonly body: Body.NonEffect
+  }
+}
+
 /**
  * @since 1.0.0
  * @category models
@@ -253,10 +269,19 @@ export const setBody: {
  * @since 1.0.0
  * @category combinators
  */
-export const binaryBody: {
+export const uint8ArrayBody: {
   (body: Uint8Array, contentType?: string): (self: ClientRequest) => ClientRequest
   (self: ClientRequest, body: Uint8Array, contentType?: string): ClientRequest
-} = internal.binaryBody
+} = internal.uint8ArrayBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const effectBody: {
+  (body: Effect.Effect<never, unknown, Body.NonEffect>): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: Effect.Effect<never, unknown, Body.NonEffect>): ClientRequest
+} = internal.effectBody
 
 /**
  * @since 1.0.0
@@ -276,6 +301,15 @@ export const jsonBody: {
   (self: ClientRequest, body: unknown): ClientRequest
 } = internal.jsonBody
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const unsafeJsonBody: {
+  (body: unknown): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, body: unknown): ClientRequest
+} = internal.unsafeJsonBody
+
 /**
  * @since 1.0.0
  * @category combinators
@@ -318,3 +352,19 @@ export const streamBody: {
     options?: { readonly contentType?: string; readonly contentLength?: number }
   ): ClientRequest
 } = internal.streamBody
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const fileBody: {
+  (
+    path: string,
+    options?: FileSystem.StreamOptions & { readonly contentType?: string }
+  ): (self: ClientRequest) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest>
+  (
+    self: ClientRequest,
+    path: string,
+    options?: FileSystem.StreamOptions & { readonly contentType?: string }
+  ): Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest>
+} = internal.fileBody

package/src/Http/ClientResponse.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import type * as Effect from "@effect/io/Effect"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
 import type * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
@@ -11,7 +12,17 @@ export {
    * @since 1.0.0
    * @category schema
    */
-  parseSchema
+  schemaBodyJson,
+  /**
+   * @since 1.0.0
+   * @category schema
+   */
+  schemaBodyUrlParams,
+  /**
+   * @since 1.0.0
+   * @category schema
+   */
+  schemaHeaders
 } from "@effect/platform/Http/IncomingMessage"
 
 /**
@@ -33,6 +44,7 @@ export type TypeId = typeof TypeId
 export interface ClientResponse extends IncomingMessage.IncomingMessage<Error.ResponseError> {
   readonly [TypeId]: TypeId
   readonly status: number
+  readonly formData: Effect.Effect<never, Error.ResponseError, FormData>
 }
 
 /**

package/src/Http/FormData.ts

@@ -1,14 +1,22 @@
 /**
  * @since 1.0.0
  */
-import type * as Error from "@effect/platform/Http/ClientError"
+import type * as Chunk from "@effect/data/Chunk"
+import type * as Data from "@effect/data/Data"
+import type * as Option from "@effect/data/Option"
+import type * as Effect from "@effect/io/Effect"
+import type * as FiberRef from "@effect/io/FiberRef"
+import type * as FileSystem from "@effect/platform/FileSystem"
+import * as internal from "@effect/platform/internal/http/formData"
+import type * as ParseResult from "@effect/schema/ParseResult"
+import type * as Schema from "@effect/schema/Schema"
 import type * as Stream from "@effect/stream/Stream"
 
 /**
  * @since 1.0.0
  * @category type ids
  */
-export const TypeId = Symbol.for("@effect/platform/Http/FormData")
+export const TypeId: unique symbol = internal.TypeId
 
 /**
  * @since 1.0.0
@@ -41,7 +49,7 @@ export namespace Part {
  * @category models
  */
 export interface Field extends Part.Proto {
-  readonly _tag: "FormDataField"
+  readonly _tag: "Field"
   readonly key: string
   readonly contentType: string
   readonly value: string
@@ -56,6 +64,114 @@ export interface File extends Part.Proto {
   readonly key: string
   readonly name: string
   readonly contentType: string
-  readonly content: Stream.Stream<never, Error.RequestError, Uint8Array>
-  readonly source?: unknown
+  readonly content: Stream.Stream<never, FormDataError, Uint8Array>
 }
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const ErrorTypeId: unique symbol = internal.ErrorTypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type ErrorTypeId = typeof ErrorTypeId
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export interface FormDataError extends Data.Case {
+  readonly [ErrorTypeId]: ErrorTypeId
+  readonly _tag: "FormDataError"
+  readonly reason: "FileTooLarge" | "FieldTooLarge" | "InternalError" | "Parse"
+  readonly error: unknown
+}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export const FormDataError: (
+  reason: FormDataError["reason"],
+  error: unknown
+) => FormDataError = internal.FormDataError
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = internal.maxFieldSize
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withMaxFieldSize: {
+  (size: FileSystem.SizeInput): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: FileSystem.SizeInput): Effect.Effect<R, E, A>
+} = internal.withMaxFieldSize
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = internal.maxFileSize
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withMaxFileSize: {
+  (size: Option.Option<FileSystem.SizeInput>): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: Option.Option<FileSystem.SizeInput>): Effect.Effect<R, E, A>
+} = internal.withMaxFileSize
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = internal.fieldMimeTypes
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withFieldMimeTypes: {
+  (mimeTypes: ReadonlyArray<string>): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, mimeTypes: ReadonlyArray<string>): Effect.Effect<R, E, A>
+} = internal.withFieldMimeTypes
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export const toRecord: (formData: FormData) => Record<string, string | Array<globalThis.File>> = internal.toRecord
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const filesSchema: Schema.Schema<ReadonlyArray<globalThis.File>, ReadonlyArray<globalThis.File>> =
+  internal.filesSchema
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaJson: <I, A>(
+  schema: Schema.Schema<I, A>
+) => {
+  (field: string): (formData: FormData) => Effect.Effect<never, FormDataError | ParseResult.ParseError, A>
+  (formData: FormData, field: string): Effect.Effect<never, FormDataError | ParseResult.ParseError, A>
+} = internal.schemaJson
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaRecord: <I extends Readonly<Record<string, string | ReadonlyArray<globalThis.File>>>, A>(
+  schema: Schema.Schema<I, A>
+) => (formData: FormData) => Effect.Effect<never, ParseResult.ParseError, A> = internal.schemaRecord

package/src/Http/Headers.ts

@@ -3,6 +3,7 @@
  */
 import { dual } from "@effect/data/Function"
 import * as HashMap from "@effect/data/HashMap"
+import type * as Option from "@effect/data/Option"
 
 /**
  * @since 1.0.0
@@ -41,7 +42,34 @@ export const fromInput: (input?: Input) => Headers = (input) => {
  * @since 1.0.0
  * @category combinators
  */
-export const set = dual<
+export const has: {
+  (key: string): (self: Headers) => boolean
+  (self: Headers, key: string): boolean
+} = dual<
+  (key: string) => (self: Headers) => boolean,
+  (self: Headers, key: string) => boolean
+>(2, (self, key) => HashMap.has(self, key.toLowerCase()))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const get: {
+  (key: string): (self: Headers) => Option.Option<string>
+  (self: Headers, key: string): Option.Option<string>
+} = dual<
+  (key: string) => (self: Headers) => Option.Option<string>,
+  (self: Headers, key: string) => Option.Option<string>
+>(2, (self, key) => HashMap.get(self, key.toLowerCase()))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const set: {
+  (key: string, value: string): (self: Headers) => Headers
+  (self: Headers, key: string, value: string): Headers
+} = dual<
   (key: string, value: string) => (self: Headers) => Headers,
   (self: Headers, key: string, value: string) => Headers
 >(3, (self, key, value) => HashMap.set(self, key.toLowerCase(), value))
@@ -50,7 +78,10 @@ export const set = dual<
  * @since 1.0.0
  * @category combinators
  */
-export const setAll = dual<
+export const setAll: {
+  (headers: Input): (self: Headers) => Headers
+  (self: Headers, headers: Input): Headers
+} = dual<
   (headers: Input) => (self: Headers) => Headers,
   (self: Headers, headers: Input) => Headers
 >(2, (self, headers) =>
@@ -63,7 +94,10 @@ export const setAll = dual<
  * @since 1.0.0
  * @category combinators
  */
-export const remove = dual<
+export const remove: {
+  (key: string): (self: Headers) => Headers
+  (self: Headers, key: string): Headers
+} = dual<
   (key: string) => (self: Headers) => Headers,
   (self: Headers, key: string) => Headers
 >(2, (self, key) => HashMap.remove(self, key.toLowerCase()))

package/src/Http/IncomingMessage.ts

@@ -1,8 +1,14 @@
 /**
  * @since 1.0.0
  */
+import { dual } from "@effect/data/Function"
+import * as Global from "@effect/data/Global"
+import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
+import * as FiberRef from "@effect/io/FiberRef"
+import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Headers from "@effect/platform/Http/Headers"
+import type * as UrlParams from "@effect/platform/Http/UrlParams"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import type * as Stream from "@effect/stream/Stream"
@@ -28,9 +34,8 @@ export interface IncomingMessage<E> {
   readonly headers: Headers.Headers
   readonly json: Effect.Effect<never, E, unknown>
   readonly text: Effect.Effect<never, E, string>
+  readonly urlParams: Effect.Effect<never, E, UrlParams.UrlParams>
   readonly arrayBuffer: Effect.Effect<never, E, ArrayBuffer>
-  readonly formData: Effect.Effect<never, E, FormData>
-  // readonly formDataStream: Stream.Stream<never, Error.TransportError, FormData.Part>
   readonly stream: Stream.Stream<never, E, Uint8Array>
 }
 
@@ -38,8 +43,46 @@ export interface IncomingMessage<E> {
  * @since 1.0.0
  * @category schema
  */
-export const parseSchema = <I, A>(schema: Schema.Schema<I, A>) => {
+export const schemaBodyJson = <I, A>(schema: Schema.Schema<I, A>) => {
   const parse = Schema.parse(schema)
   return <E>(self: IncomingMessage<E>): Effect.Effect<never, E | ParseResult.ParseError, A> =>
     Effect.flatMap(self.json, parse)
 }
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaBodyUrlParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
+  const parse = Schema.parse(schema)
+  return <E>(self: IncomingMessage<E>): Effect.Effect<never, E | ParseResult.ParseError, A> =>
+    Effect.flatMap(self.urlParams, (_) => parse(Object.fromEntries(_)))
+}
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaHeaders = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
+  const parse = Schema.parse(schema)
+  return <E>(self: IncomingMessage<E>): Effect.Effect<never, ParseResult.ParseError, A> =>
+    parse(Object.fromEntries(self.headers))
+}
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const maxBodySize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = Global.globalValue(
+  "@effect/platform/Http/ImcomingMessage/maxBodySize",
+  () => FiberRef.unsafeMake(Option.none<FileSystem.Size>())
+)
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withMaxBodySize = dual<
+  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<R, E, A>
+>(2, (effect, size) => Effect.locally(effect, maxBodySize, Option.map(size, FileSystem.Size)))