@effect/platform 0.43.10 → 0.44.0

package/src/Http/Multipart.ts

@@ -5,7 +5,6 @@ import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Channel from "effect/Channel"
 import type * as Chunk from "effect/Chunk"
-import type * as Data from "effect/Data"
 import type * as Effect from "effect/Effect"
 import type * as FiberRef from "effect/FiberRef"
 import type * as Option from "effect/Option"
@@ -68,7 +67,7 @@ export interface File extends Part.Proto {
   readonly key: string
   readonly name: string
   readonly contentType: string
-  readonly content: Stream.Stream<never, MultipartError, Uint8Array>
+  readonly content: Stream.Stream<Uint8Array, MultipartError>
 }
 
 /**
@@ -107,7 +106,7 @@ export type ErrorTypeId = typeof ErrorTypeId
  * @since 1.0.0
  * @category errors
  */
-export interface MultipartError extends Data.Case {
+export interface MultipartError {
   readonly [ErrorTypeId]: ErrorTypeId
   readonly _tag: "MultipartError"
   readonly reason: "FileTooLarge" | "FieldTooLarge" | "BodyTooLarge" | "TooManyParts" | "InternalError" | "Parse"
@@ -140,8 +139,8 @@ export const maxParts: FiberRef.FiberRef<Option.Option<number>> = internal.maxPa
  * @category fiber refs
  */
 export const withMaxParts: {
-  (count: Option.Option<number>): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
-  <R, E, A>(effect: Effect.Effect<R, E, A>, count: Option.Option<number>): Effect.Effect<R, E, A>
+  (count: Option.Option<number>): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <R, E, A>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>): Effect.Effect<A, E, R>
 } = internal.withMaxParts
 
 /**
@@ -155,8 +154,8 @@ export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = internal.maxFiel
  * @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>
+  (size: FileSystem.SizeInput): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <R, E, A>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput): Effect.Effect<A, E, R>
 } = internal.withMaxFieldSize
 
 /**
@@ -170,8 +169,8 @@ export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = in
  * @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>
+  (size: Option.Option<FileSystem.SizeInput>): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <R, E, A>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>): Effect.Effect<A, E, R>
 } = internal.withMaxFileSize
 
 /**
@@ -185,26 +184,25 @@ export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = internal.f
  * @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>
+  (mimeTypes: ReadonlyArray<string>): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <R, E, A>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>): Effect.Effect<A, E, R>
 } = internal.withFieldMimeTypes
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const filesSchema: Schema.Schema<never, ReadonlyArray<PersistedFile>, ReadonlyArray<PersistedFile>> =
-  internal.filesSchema
+export const filesSchema: Schema.Schema<ReadonlyArray<PersistedFile>> = internal.filesSchema
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaJson: <R, I, A>(
-  schema: Schema.Schema<R, I, A>
+export const schemaJson: <A, I, R>(
+  schema: Schema.Schema<A, I, R>
 ) => {
-  (field: string): (persisted: Persisted) => Effect.Effect<R, ParseResult.ParseError, A>
-  (persisted: Persisted, field: string): Effect.Effect<R, ParseResult.ParseError, A>
+  (field: string): (persisted: Persisted) => Effect.Effect<A, ParseResult.ParseError, R>
+  (persisted: Persisted, field: string): Effect.Effect<A, ParseResult.ParseError, R>
 } = internal.schemaJson
 
 /**
@@ -212,8 +210,8 @@ export const schemaJson: <R, I, A>(
  * @category schema
  */
 export const schemaPersisted: <R, I extends Persisted, A>(
-  schema: Schema.Schema<R, I, A>
-) => (persisted: Persisted) => Effect.Effect<R, ParseResult.ParseError, A> = internal.schemaPersisted
+  schema: Schema.Schema<A, I, R>
+) => (persisted: Persisted) => Effect.Effect<A, ParseResult.ParseError, R> = internal.schemaPersisted
 
 /**
  * @since 1.0.0
@@ -222,21 +220,20 @@ export const schemaPersisted: <R, I extends Persisted, A>(
 export const makeChannel: <IE>(
   headers: Record<string, string>,
   bufferSize?: number
-) => Channel.Channel<never, IE, Chunk.Chunk<Uint8Array>, unknown, MultipartError | IE, Chunk.Chunk<Part>, unknown> =
+) => Channel.Channel<Chunk.Chunk<Part>, Chunk.Chunk<Uint8Array>, MultipartError | IE, IE, unknown, unknown> =
   internal.makeChannel
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const makeConfig: (headers: Record<string, string>) => Effect.Effect<never, never, Multipasta.BaseConfig> =
-  internal.makeConfig
+export const makeConfig: (headers: Record<string, string>) => Effect.Effect<Multipasta.BaseConfig> = internal.makeConfig
 
 /**
  * @since 1.0.0
  * @category constructors
  */
 export const toPersisted: (
-  stream: Stream.Stream<never, MultipartError, Part>,
-  writeFile?: (path: string, file: File) => Effect.Effect<FileSystem.FileSystem, MultipartError, void>
-) => Effect.Effect<FileSystem.FileSystem | Path.Path | Scope.Scope, MultipartError, Persisted> = internal.toPersisted
+  stream: Stream.Stream<Part, MultipartError>,
+  writeFile?: (path: string, file: File) => Effect.Effect<void, MultipartError, FileSystem.FileSystem>
+) => Effect.Effect<Persisted, MultipartError, FileSystem.FileSystem | Path.Path | Scope.Scope> = internal.toPersisted

package/src/Http/Multiplex.ts

@@ -27,7 +27,7 @@ export interface Multiplex<R, E> extends App.Default<R, E | Error.RouteNotFound>
   readonly [TypeId]: TypeId
   readonly apps: ReadonlyArray<
     readonly [
-      predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R, E, boolean>,
+      predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>,
       app: App.Default<R, E>
     ]
   >
@@ -45,7 +45,7 @@ export const empty: Multiplex<never, never> = internal.empty
  */
 export const make: <R, E>(
   apps: Iterable<
-    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R, E, boolean>, app: App.Default<R, E>]
+    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<R, E>]
   >
 ) => Multiplex<R, E> = internal.make
 
@@ -55,12 +55,12 @@ export const make: <R, E>(
  */
 export const add: {
   <R2, E2, R3, E3>(
-    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R2, E2, boolean>,
+    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<R3, E3>
   ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R3 | R, E2 | E3 | E>
   <R, E, R2, E2, R3, E3>(
     self: Multiplex<R, E>,
-    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R2, E2, boolean>,
+    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<R3, E3>
   ): Multiplex<R | R2 | R3, E | E2 | E3>
 } = internal.add

package/src/Http/Platform.ts

@@ -38,11 +38,11 @@ export interface Platform {
   readonly fileResponse: (
     path: string,
     options?: ServerResponse.Options.WithContent & FileSystem.StreamOptions
-  ) => Effect.Effect<never, Error.PlatformError, ServerResponse.ServerResponse>
+  ) => Effect.Effect<ServerResponse.ServerResponse, Error.PlatformError>
   readonly fileWebResponse: (
     file: Body.Body.FileLike,
     options?: ServerResponse.Options.WithContent & FileSystem.StreamOptions
-  ) => Effect.Effect<never, never, ServerResponse.ServerResponse>
+  ) => Effect.Effect<ServerResponse.ServerResponse>
 }
 
 /**
@@ -68,4 +68,4 @@ export const make: (
       options?: FileSystem.StreamOptions | undefined
     ) => ServerResponse.ServerResponse
   }
-) => Effect.Effect<FileSystem.FileSystem | Etag.Generator, never, Platform> = internal.make
+) => Effect.Effect<Platform, never, FileSystem.FileSystem | Etag.Generator> = internal.make

package/src/Http/Router.ts

@@ -86,9 +86,9 @@ export declare namespace Route {
    * @since 1.0.0
    */
   export type Handler<R, E> = Effect.Effect<
-    R | RouteContext | ServerRequest.ServerRequest,
+    ServerResponse.ServerResponse,
     E,
-    ServerResponse.ServerResponse
+    R | RouteContext | ServerRequest.ServerRequest
   >
 }
 
@@ -126,9 +126,9 @@ export const RouteContext: Context.Tag<RouteContext, RouteContext> = internal.Ro
  * @category route context
  */
 export const params: Effect.Effect<
-  RouteContext,
+  Readonly<Record<string, string | undefined>>,
   never,
-  Readonly<Record<string, string | undefined>>
+  RouteContext
 > = internal.params
 
 /**
@@ -136,9 +136,9 @@ export const params: Effect.Effect<
  * @category route context
  */
 export const searchParams: Effect.Effect<
-  RouteContext,
+  Readonly<Record<string, string>>,
   never,
-  Readonly<Record<string, string>>
+  RouteContext
 > = internal.searchParams
 
 /**
@@ -146,24 +146,24 @@ export const searchParams: Effect.Effect<
  * @category route context
  */
 export const schemaParams: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<R, I, A>
-) => Effect.Effect<RouteContext | R, ParseResult.ParseError, A> = internal.schemaParams
+  schema: Schema.Schema<A, I, R>
+) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaParams
 
 /**
  * @since 1.0.0
  * @category route context
  */
 export const schemaPathParams: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<R, I, A>
-) => Effect.Effect<RouteContext | R, ParseResult.ParseError, A> = internal.schemaPathParams
+  schema: Schema.Schema<A, I, R>
+) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaPathParams
 
 /**
  * @since 1.0.0
  * @category route context
  */
 export const schemaSearchParams: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<R, I, A>
-) => Effect.Effect<RouteContext | R, ParseResult.ParseError, A> = internal.schemaSearchParams
+  schema: Schema.Schema<A, I, R>
+) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaSearchParams
 
 /**
  * @since 1.0.0
@@ -590,7 +590,7 @@ export const catchTags: {
     | Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
     | Exclude<
       {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer R, any, any> ? R : never
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
       }[keyof Cases],
       RouteContext | ServerRequest.ServerRequest | Scope.Scope
     >,
@@ -618,7 +618,7 @@ export const catchTags: {
     | Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
     | Exclude<
       {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<infer R, any, any> ? R : never
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
       }[keyof Cases],
       RouteContext | ServerRequest.ServerRequest | Scope.Scope
     >,
@@ -657,7 +657,7 @@ export const provideService: {
 export const provideServiceEffect: {
   <T extends Context.Tag<any, any>, R1, E1>(
     tag: T,
-    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ): <R, E>(
     self: Router<R, E>
   ) => Router<
@@ -668,7 +668,7 @@ export const provideServiceEffect: {
   <R, E, T extends Context.Tag<any, any>, R1, E1>(
     self: Router<R, E>,
     tag: T,
-    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ): Router<
     | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
     | Exclude<Exclude<R, Context.Tag.Identifier<T>>, RouteContext | ServerRequest.ServerRequest | Scope.Scope>,

package/src/Http/Server.ts

@@ -30,17 +30,17 @@ export interface Server {
   readonly [TypeId]: TypeId
   readonly serve: {
     <R, E>(httpApp: App.Default<R, E>): Effect.Effect<
-      Exclude<R, ServerRequest.ServerRequest> | Scope.Scope,
+      void,
       never,
-      void
+      Exclude<R, ServerRequest.ServerRequest> | Scope.Scope
     >
     <R, E, App extends App.Default<any, any>>(
       httpApp: App.Default<R, E>,
       middleware: Middleware.Middleware.Applied<R, E, App>
     ): Effect.Effect<
-      Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest> | Scope.Scope,
+      void,
       never,
-      void
+      Exclude<R, ServerRequest.ServerRequest> | Scope.Scope
     >
   }
   readonly address: Address
@@ -56,13 +56,13 @@ export interface ServeOptions {
 
 /**
  * @since 1.0.0
- * @category models
+ * @category address
  */
 export type Address = UnixAddress | TcpAddress
 
 /**
  * @since 1.0.0
- * @category models
+ * @category address
  */
 export interface TcpAddress {
   readonly _tag: "TcpAddress"
@@ -72,7 +72,7 @@ export interface TcpAddress {
 
 /**
  * @since 1.0.0
- * @category models
+ * @category address
  */
 export interface UnixAddress {
   readonly _tag: "UnixAddress"
@@ -94,7 +94,7 @@ export const make: (
     readonly serve: (
       httpApp: App.Default<never, unknown>,
       middleware?: Middleware.Middleware
-    ) => Effect.Effect<Scope.Scope, never, void>
+    ) => Effect.Effect<void, never, Scope.Scope>
     readonly address: Address
   }
 ) => Server = internal.make
@@ -106,23 +106,23 @@ export const make: (
 export const serve: {
   (): <R, E>(
     httpApp: App.Default<R, E>
-  ) => Layer.Layer<Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>, never, never>
+  ) => Layer.Layer<never, never, Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, App extends App.Default<any, any>>(
     middleware: Middleware.Middleware.Applied<R, E, App>
   ): (
     httpApp: App.Default<R, E>
   ) => Layer.Layer<
-    Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
     never,
-    never
+    never,
+    Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
   >
   <R, E>(
     httpApp: App.Default<R, E>
-  ): Layer.Layer<Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>, never, never>
+  ): Layer.Layer<never, never, Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
   <R, E, App extends App.Default<any, any>>(
     httpApp: App.Default<R, E>,
     middleware: Middleware.Middleware.Applied<R, E, App>
-  ): Layer.Layer<Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>, never, never>
+  ): Layer.Layer<never, never, Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>>
 } = internal.serve
 
 /**
@@ -132,21 +132,56 @@ export const serve: {
 export const serveEffect: {
   (): <R, E>(
     httpApp: App.Default<R, E>
-  ) => Effect.Effect<Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>, never, void>
+  ) => Effect.Effect<void, never, Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>>
   <R, E, App extends App.Default<any, any>>(
     middleware: Middleware.Middleware.Applied<R, E, App>
   ): (
     httpApp: App.Default<R, E>
   ) => Effect.Effect<
-    Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+    void,
     never,
-    void
+    Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>
   >
   <R, E>(
     httpApp: App.Default<R, E>
-  ): Effect.Effect<Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>, never, void>
+  ): Effect.Effect<void, never, Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>>
   <R, E, App extends App.Default<any, any>>(
     httpApp: App.Default<R, E>,
     middleware: Middleware.Middleware.Applied<R, E, App>
-  ): Effect.Effect<Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>, never, void>
+  ): Effect.Effect<void, never, Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>>
 } = internal.serveEffect
+
+/**
+ * @since 1.0.0
+ * @category address
+ */
+export const formatAddress: (address: Address) => string = internal.formatAddress
+
+/**
+ * @since 1.0.0
+ * @category address
+ */
+export const addressWith: <R, E, A>(
+  effect: (address: Address) => Effect.Effect<A, E, R>
+) => Effect.Effect<A, E, Server | R> = internal.addressWith
+
+/**
+ * @since 1.0.0
+ * @category address
+ */
+export const addressFormattedWith: <R, E, A>(
+  effect: (address: string) => Effect.Effect<A, E, R>
+) => Effect.Effect<A, E, Server | R> = internal.addressFormattedWith
+
+/**
+ * @since 1.0.0
+ * @category address
+ */
+export const logAddress: Effect.Effect<void, never, Server> = internal.logAddress
+
+/**
+ * @since 1.0.0
+ * @category address
+ */
+export const withLogAddress: <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R | Exclude<Server, A>> =
+  internal.withLogAddress

package/src/Http/ServerError.ts

@@ -2,7 +2,6 @@
  * @since 1.0.0
  */
 import type * as Cause from "effect/Cause"
-import type * as Data from "effect/Data"
 import type * as FiberId from "effect/FiberId"
 import * as internal from "../internal/http/serverError.js"
 import type * as ServerRequest from "./ServerRequest.js"
@@ -34,7 +33,7 @@ export declare namespace HttpError {
    * @since 1.0.0
    * @category models
    */
-  export interface Proto extends Data.Case {
+  export interface Proto {
     readonly [TypeId]: TypeId
     readonly _tag: string
   }
@@ -42,7 +41,7 @@ export declare namespace HttpError {
   /**
    * @since 1.0.0
    */
-  export type ProvidedFields = TypeId | "_tag" | keyof Data.Case
+  export type ProvidedFields = TypeId | "_tag"
 }
 
 /**

package/src/Http/ServerRequest.ts

@@ -48,11 +48,11 @@ export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.Req
   readonly method: Method
 
   readonly multipart: Effect.Effect<
-    Scope.Scope | FileSystem.FileSystem | Path.Path,
+    Multipart.Persisted,
     Multipart.MultipartError,
-    Multipart.Persisted
+    Scope.Scope | FileSystem.FileSystem | Path.Path
   >
-  readonly multipartStream: Stream.Stream<never, Multipart.MultipartError, Multipart.Part>
+  readonly multipartStream: Stream.Stream<Multipart.Part, Multipart.MultipartError>
 
   readonly modify: (
     options: {
@@ -74,9 +74,9 @@ export const ServerRequest: Context.Tag<ServerRequest, ServerRequest> = internal
  * @category accessors
  */
 export const persistedMultipart: Effect.Effect<
-  Scope.Scope | FileSystem.FileSystem | Path.Path | ServerRequest,
+  unknown,
   Multipart.MultipartError,
-  unknown
+  Scope.Scope | FileSystem.FileSystem | Path.Path | ServerRequest
 > = internal.multipartPersisted
 
 /**
@@ -84,27 +84,27 @@ export const persistedMultipart: Effect.Effect<
  * @category schema
  */
 export const schemaHeaders: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<R, I, A>
-) => Effect.Effect<ServerRequest | R, ParseResult.ParseError, A> = internal.schemaHeaders
+  schema: Schema.Schema<A, I, R>
+) => Effect.Effect<A, ParseResult.ParseError, ServerRequest | R> = internal.schemaHeaders
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaBodyJson: <R, I, A>(
-  schema: Schema.Schema<R, I, A>
-) => Effect.Effect<ServerRequest | R, Error.RequestError | ParseResult.ParseError, A> = internal.schemaBodyJson
+export const schemaBodyJson: <A, I, R>(
+  schema: Schema.Schema<A, I, R>
+) => Effect.Effect<A, Error.RequestError | ParseResult.ParseError, ServerRequest | R> = internal.schemaBodyJson
 
 /**
  * @since 1.0.0
  * @category schema
  */
 export const schemaBodyForm: <R, I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ) => Effect.Effect<
-  ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path | R,
+  A,
   Multipart.MultipartError | Error.RequestError | ParseResult.ParseError,
-  A
+  ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path | R
 > = internal.schemaBodyForm
 
 /**
@@ -112,33 +112,33 @@ export const schemaBodyForm: <R, I extends Multipart.Persisted, A>(
  * @category schema
  */
 export const schemaBodyUrlParams: <R, I extends Readonly<Record<string, string>>, A>(
-  schema: Schema.Schema<R, I, A>
-) => Effect.Effect<ServerRequest | R, Error.RequestError | ParseResult.ParseError, A> = internal.schemaBodyUrlParams
+  schema: Schema.Schema<A, I, R>
+) => Effect.Effect<A, Error.RequestError | ParseResult.ParseError, ServerRequest | R> = internal.schemaBodyUrlParams
 
 /**
  * @since 1.0.0
  * @category schema
  */
 export const schemaBodyMultipart: <R, I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ) => Effect.Effect<
-  R | ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
+  A,
   Multipart.MultipartError | ParseResult.ParseError,
-  A
+  R | ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path
 > = internal.schemaBodyMultipart
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaBodyFormJson: <R, I, A>(
-  schema: Schema.Schema<R, I, A>
+export const schemaBodyFormJson: <A, I, R>(
+  schema: Schema.Schema<A, I, R>
 ) => (
   field: string
 ) => Effect.Effect<
-  R | ServerRequest | FileSystem.FileSystem | Path.Path | Scope.Scope,
+  A,
   ParseResult.ParseError | Error.RequestError,
-  A
+  R | ServerRequest | FileSystem.FileSystem | Path.Path | Scope.Scope
 > = internal.schemaBodyFormJson
 
 /**

package/src/Http/ServerResponse.ts

@@ -28,10 +28,10 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface ServerResponse extends Effect.Effect<never, never, ServerResponse> {
+export interface ServerResponse extends Effect.Effect<ServerResponse> {
   readonly [TypeId]: TypeId
   readonly status: number
-  readonly statusText?: string
+  readonly statusText?: string | undefined
   readonly headers: Headers.Headers
   readonly body: Body.Body
 }
@@ -95,15 +95,15 @@ export const text: (body: string, options?: Options.WithContentType) => ServerRe
 export const json: (
   body: unknown,
   options?: Options.WithContent
-) => Effect.Effect<never, Body.BodyError, ServerResponse> = internal.json
+) => Effect.Effect<ServerResponse, Body.BodyError> = internal.json
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const schemaJson: <R, I, A>(
-  schema: Schema.Schema<R, I, A>
-) => (body: A, options?: Options.WithContent | undefined) => Effect.Effect<R, Body.BodyError, ServerResponse> =
+export const schemaJson: <A, I, R>(
+  schema: Schema.Schema<A, I, R>
+) => (body: A, options?: Options.WithContent | undefined) => Effect.Effect<ServerResponse, Body.BodyError, R> =
   internal.schemaJson
 
 /**
@@ -134,8 +134,7 @@ export const formData: (body: FormData, options?: Options.WithContent) => Server
  * @since 1.0.0
  * @category constructors
  */
-export const stream: (body: Stream.Stream<never, unknown, Uint8Array>, options?: Options) => ServerResponse =
-  internal.stream
+export const stream: (body: Stream.Stream<Uint8Array, unknown>, options?: Options) => ServerResponse = internal.stream
 
 /**
  * @since 1.0.0
@@ -144,7 +143,7 @@ export const stream: (body: Stream.Stream<never, unknown, Uint8Array>, options?:
 export const file: (
   path: string,
   options?: Options & FileSystem.StreamOptions
-) => Effect.Effect<Platform.Platform, PlatformError.PlatformError, ServerResponse> = internal.file
+) => Effect.Effect<ServerResponse, PlatformError.PlatformError, Platform.Platform> = internal.file
 
 /**
  * @since 1.0.0
@@ -153,7 +152,7 @@ export const file: (
 export const fileWeb: (
   file: Body.Body.FileLike,
   options?: Options.WithContent & FileSystem.StreamOptions
-) => Effect.Effect<Platform.Platform, never, ServerResponse> = internal.fileWeb
+) => Effect.Effect<ServerResponse, never, Platform.Platform> = internal.fileWeb
 
 /**
  * @since 1.0.0

package/src/Http/UrlParams.ts

@@ -182,7 +182,7 @@ export const toString = (self: UrlParams): string => new URLSearchParams(self as
  * @since 1.0.0
  * @category constructors
  */
-export const makeUrl = <E>(url: string, params: UrlParams, onError: (e: unknown) => E): Effect.Effect<never, E, URL> =>
+export const makeUrl = <E>(url: string, params: UrlParams, onError: (e: unknown) => E): Effect.Effect<URL, E> =>
   Effect.try({
     try: () => {
       const urlInstance = new URL(url, baseUrl())
@@ -207,18 +207,18 @@ const baseUrl = (): string | undefined => {
  * @since 1.0.0
  * @category schema
  */
-export const schemaJson = <R, I, A>(schema: Schema.Schema<R, I, A>): {
+export const schemaJson = <A, I, R>(schema: Schema.Schema<A, I, R>): {
   (
     field: string
-  ): (self: UrlParams) => Effect.Effect<R, ParseResult.ParseError, A>
+  ): (self: UrlParams) => Effect.Effect<A, ParseResult.ParseError, R>
   (
     self: UrlParams,
     field: string
-  ): Effect.Effect<R, ParseResult.ParseError, A>
+  ): Effect.Effect<A, ParseResult.ParseError, R>
 } => {
   const parse = Schema.decodeUnknown(Schema.parseJson(schema))
   return dual<
-    (field: string) => (self: UrlParams) => Effect.Effect<R, ParseResult.ParseError, A>,
-    (self: UrlParams, field: string) => Effect.Effect<R, ParseResult.ParseError, A>
+    (field: string) => (self: UrlParams) => Effect.Effect<A, ParseResult.ParseError, R>,
+    (self: UrlParams, field: string) => Effect.Effect<A, ParseResult.ParseError, R>
   >(2, (self, field) => parse(Option.getOrElse(getLast(self, field), () => "")))
 }