@effect/platform 0.43.10 → 0.44.0

package/src/internal/http/body.ts

@@ -40,8 +40,8 @@ class RawImpl implements Body.Raw {
   readonly _tag = "Raw"
   constructor(
     readonly body: unknown,
-    readonly contentType?: string,
-    readonly contentLength?: number
+    readonly contentType?: string | undefined,
+    readonly contentLength?: number | undefined
   ) {
     this[TypeId] = TypeId
   }
@@ -79,7 +79,7 @@ export const text = (body: string, contentType?: string): Body.Uint8Array =>
 export const unsafeJson = (body: unknown): Body.Uint8Array => text(JSON.stringify(body), "application/json")
 
 /** @internal */
-export const json = (body: unknown): Effect.Effect<never, Body.BodyError, Body.Uint8Array> =>
+export const json = (body: unknown): Effect.Effect<Body.Uint8Array, Body.BodyError> =>
   Effect.try({
     try: () => unsafeJson(body),
     catch: (error) => BodyError({ _tag: "JsonError", error })
@@ -90,9 +90,9 @@ export const urlParams = (urlParams: UrlParams.UrlParams): Body.Uint8Array =>
   text(UrlParams.toString(urlParams), "application/x-www-form-urlencoded")
 
 /** @internal */
-export const jsonSchema = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
+export const jsonSchema = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
   const encode = Schema.encode(schema)
-  return (body: A): Effect.Effect<R, Body.BodyError, Body.Uint8Array> =>
+  return (body: A): Effect.Effect<Body.Uint8Array, Body.BodyError, R> =>
     Effect.flatMap(
       Effect.mapError(encode(body), (error) => BodyError({ _tag: "SchemaError", error })),
       json
@@ -103,7 +103,7 @@ export const jsonSchema = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
 export const file = (
   path: string,
   options?: FileSystem.StreamOptions & { readonly contentType?: string }
-): Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, Body.Stream> =>
+): Effect.Effect<Body.Stream, PlatformError.PlatformError, FileSystem.FileSystem> =>
   Effect.flatMap(
     FileSystem.FileSystem,
     (fs) =>
@@ -120,7 +120,7 @@ export const fileInfo = (
   path: string,
   info: FileSystem.File.Info,
   options?: FileSystem.StreamOptions & { readonly contentType?: string }
-): Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, Body.Stream> =>
+): Effect.Effect<Body.Stream, PlatformError.PlatformError, FileSystem.FileSystem> =>
   Effect.map(
     FileSystem.FileSystem,
     (fs) =>
@@ -152,9 +152,9 @@ class StreamImpl implements Body.Stream {
   readonly [TypeId]: Body.TypeId
   readonly _tag = "Stream"
   constructor(
-    readonly stream: Stream_.Stream<never, unknown, Uint8Array>,
+    readonly stream: Stream_.Stream<Uint8Array, unknown>,
     readonly contentType: string,
-    readonly contentLength?: number
+    readonly contentLength?: number | undefined
   ) {
     this[TypeId] = TypeId
   }
@@ -162,7 +162,7 @@ class StreamImpl implements Body.Stream {
 
 /** @internal */
 export const stream = (
-  body: Stream_.Stream<never, unknown, Uint8Array>,
-  contentType?: string,
-  contentLength?: number
+  body: Stream_.Stream<Uint8Array, unknown>,
+  contentType?: string | undefined,
+  contentLength?: number | undefined
 ): Body.Stream => new StreamImpl(body, contentType ?? "application/octet-stream", contentLength)

package/src/internal/http/client.ts

@@ -26,7 +26,7 @@ export const TypeId: Client.TypeId = Symbol.for(
 ) as Client.TypeId
 
 /** @internal */
-export const tag = Context.Tag<Client.Client.Default>(TypeId)
+export const tag = Context.GenericTag<Client.Client.Default>("@effect/platform/Http/Client")
 
 const clientProto = {
   [TypeId]: TypeId,
@@ -38,8 +38,8 @@ const clientProto = {
 /** @internal */
 export const make = <R, E, A, R2, E2>(
   execute: (
-    request: Effect.Effect<R2, E2, ClientRequest.ClientRequest>
-  ) => Effect.Effect<R, E, A>,
+    request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>
+  ) => Effect.Effect<A, E, R>,
   preprocess: Client.Client.Preprocess<R2, E2>
 ): Client.Client<R, E, A> => {
   function client(request: ClientRequest.ClientRequest) {
@@ -68,16 +68,12 @@ const addB3Headers = (req: ClientRequest.ClientRequest) =>
 export const makeDefault = (
   f: (
     request: ClientRequest.ClientRequest
-  ) => Effect.Effect<
-    never,
-    Error.HttpClientError,
-    ClientResponse.ClientResponse
-  >
+  ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError>
 ): Client.Client.Default => make(Effect.flatMap(f), addB3Headers)
 
 /** @internal */
-export const Fetch = Context.Tag<Client.Fetch, typeof globalThis.fetch>(
-  Symbol.for("@effect/platform/Http/Client/Fetch")
+export const Fetch = Context.GenericTag<Client.Fetch, typeof globalThis.fetch>(
+  "@effect/platform/Http/Client/Fetch"
 )
 
 /** @internal */
@@ -148,16 +144,16 @@ export const layer = Layer.succeed(tag, fetch())
 export const transform = dual<
   <R, E, A, R1, E1, A1>(
     f: (
-      effect: Effect.Effect<R, E, A>,
+      effect: Effect.Effect<A, E, R>,
       request: ClientRequest.ClientRequest
-    ) => Effect.Effect<R1, E1, A1>
+    ) => Effect.Effect<A1, E1, R1>
   ) => (self: Client.Client<R, E, A>) => Client.Client<R | R1, E | E1, A1>,
   <R, E, A, R1, E1, A1>(
     self: Client.Client<R, E, A>,
     f: (
-      effect: Effect.Effect<R, E, A>,
+      effect: Effect.Effect<A, E, R>,
       request: ClientRequest.ClientRequest
-    ) => Effect.Effect<R1, E1, A1>
+    ) => Effect.Effect<A1, E1, R1>
   ) => Client.Client<R | R1, E | E1, A1>
 >(2, (self, f) =>
   make(
@@ -168,11 +164,11 @@ export const transform = dual<
 /** @internal */
 export const transformResponse = dual<
   <R, E, A, R1, E1, A1>(
-    f: (effect: Effect.Effect<R, E, A>) => Effect.Effect<R1, E1, A1>
+    f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ) => (self: Client.Client<R, E, A>) => Client.Client<R1, E1, A1>,
   <R, E, A, R1, E1, A1>(
     self: Client.Client<R, E, A>,
-    f: (effect: Effect.Effect<R, E, A>) => Effect.Effect<R1, E1, A1>
+    f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ) => Client.Client<R1, E1, A1>
 >(2, (self, f) => make((request) => f(self.execute(request)), self.preprocess))
 
@@ -180,7 +176,7 @@ export const transformResponse = dual<
 export const catchTag: {
   <K extends E extends { _tag: string } ? E["_tag"] : never, E, R1, E1, A1>(
     tag: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
   ): <R, A>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
@@ -195,7 +191,7 @@ export const catchTag: {
   >(
     self: Client.Client<R, E, A>,
     tag: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
   ): Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
 } = dual(
   3,
@@ -210,7 +206,7 @@ export const catchTag: {
   >(
     self: Client.Client<R, E, A>,
     tag: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
+    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
   ): Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A> => transformResponse(self, Effect.catchTag(tag, f))
 )
 
@@ -242,7 +238,7 @@ export const catchTags: {
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<infer R, any, any> ? R
+      ) => Effect.Effect<any, any, infer R> ? R
         : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
@@ -256,7 +252,7 @@ export const catchTags: {
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<any, any, infer A> ? A
+      ) => Effect.Effect<infer A, any, any> ? A
         : never
     }[keyof Cases]
   >
@@ -287,7 +283,7 @@ export const catchTags: {
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<infer R, any, any> ? R
+      ) => Effect.Effect<any, any, infer R> ? R
         : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
@@ -301,7 +297,7 @@ export const catchTags: {
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<any, any, infer A> ? A
+      ) => Effect.Effect<infer A, any, any> ? A
         : never
     }[keyof Cases]
   >
@@ -334,7 +330,7 @@ export const catchTags: {
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<infer R, any, any> ? R
+      ) => Effect.Effect<any, any, infer R> ? R
         : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
@@ -348,7 +344,7 @@ export const catchTags: {
     | {
       [K in keyof Cases]: Cases[K] extends (
         ...args: Array<any>
-      ) => Effect.Effect<any, any, infer A> ? A
+      ) => Effect.Effect<infer A, any, any> ? A
         : never
     }[keyof Cases]
   > => transformResponse(self, Effect.catchTags(cases))
@@ -357,17 +353,17 @@ export const catchTags: {
 /** @internal */
 export const catchAll: {
   <E, R2, E2, A2>(
-    f: (e: E) => Effect.Effect<R2, E2, A2>
+    f: (e: E) => Effect.Effect<A2, E2, R2>
   ): <R, A>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E2, A2 | A>
   <R, E, A, R2, E2, A2>(
     self: Client.Client<R, E, A>,
-    f: (e: E) => Effect.Effect<R2, E2, A2>
+    f: (e: E) => Effect.Effect<A2, E2, R2>
   ): Client.Client<R | R2, E2, A2 | A>
 } = dual(
   2,
   <R, E, A, R2, E2, A2>(
     self: Client.Client<R, E, A>,
-    f: (e: E) => Effect.Effect<R2, E2, A2>
+    f: (e: E) => Effect.Effect<A2, E2, R2>
   ): Client.Client<R | R2, E2, A2 | A> => transformResponse(self, Effect.catchAll(f))
 )
 
@@ -375,14 +371,14 @@ export const catchAll: {
 export const filterOrElse = dual<
   <A, R2, E2, B>(
     f: Predicate.Predicate<A>,
-    orElse: (a: A) => Effect.Effect<R2, E2, B>
+    orElse: (a: A) => Effect.Effect<B, E2, R2>
   ) => <R, E>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R2 | R, E2 | E, A | B>,
   <R, E, A, R2, E2, B>(
     self: Client.Client<R, E, A>,
     f: Predicate.Predicate<A>,
-    orElse: (a: A) => Effect.Effect<R2, E2, B>
+    orElse: (a: A) => Effect.Effect<B, E2, R2>
   ) => Client.Client<R2 | R, E2 | E, A | B>
 >(3, (self, f, orElse) => transformResponse(self, Effect.filterOrElse(f, orElse)))
 
@@ -445,11 +441,11 @@ export const map = dual<
 /** @internal */
 export const mapEffect = dual<
   <A, R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, B>
+    f: (a: A) => Effect.Effect<B, E2, R2>
   ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E | E2, B>,
   <R, E, A, R2, E2, B>(
     self: Client.Client<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, B>
+    f: (a: A) => Effect.Effect<B, E2, R2>
   ) => Client.Client<R | R2, E | E2, B>
 >(2, (self, f) => transformResponse(self, Effect.flatMap(f)))
 
@@ -469,7 +465,7 @@ export const mapRequestEffect = dual<
   <R2, E2>(
     f: (
       a: ClientRequest.ClientRequest
-    ) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R | R2, E | E2, A>,
@@ -477,7 +473,7 @@ export const mapRequestEffect = dual<
     self: Client.Client<R, E, A>,
     f: (
       a: ClientRequest.ClientRequest
-    ) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => Client.Client<R | R2, E | E2, A>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(self.preprocess(request), f)))
 
@@ -497,7 +493,7 @@ export const mapInputRequestEffect = dual<
   <R2, E2>(
     f: (
       a: ClientRequest.ClientRequest
-    ) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R | R2, E | E2, A>,
@@ -505,7 +501,7 @@ export const mapInputRequestEffect = dual<
     self: Client.Client<R, E, A>,
     f: (
       a: ClientRequest.ClientRequest
-    ) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => Client.Client<R | R2, E | E2, A>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(f(request), self.preprocess)))
 
@@ -528,23 +524,23 @@ export const retry: {
 
 /** @internal */
 export const schemaFunction = dual<
-  <SR, SI, SA>(
-    schema: Schema.Schema<SR, SI, SA>
+  <SA, SI, SR>(
+    schema: Schema.Schema<SA, SI, SR>
   ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => (
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<R | SR, E | ParseResult.ParseError | Error.RequestError, A>,
-  <R, E, A, SR, SI, SA>(
+  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>,
+  <R, E, A, SA, SI, SR>(
     self: Client.Client<R, E, A>,
-    schema: Schema.Schema<SR, SI, SA>
+    schema: Schema.Schema<SA, SI, SR>
   ) => (
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<R | SR, E | ParseResult.ParseError | Error.RequestError, A>
+  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
 >(2, (self, schema) => {
   const encode = Schema.encode(schema)
   return (request) => (a) =>
@@ -571,23 +567,23 @@ export const schemaFunction = dual<
 /** @internal */
 export const tap = dual<
   <A, R2, E2, _>(
-    f: (a: A) => Effect.Effect<R2, E2, _>
+    f: (a: A) => Effect.Effect<_, E2, R2>
   ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E | E2, A>,
   <R, E, A, R2, E2, _>(
     self: Client.Client<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, _>
+    f: (a: A) => Effect.Effect<_, E2, R2>
   ) => Client.Client<R | R2, E | E2, A>
 >(2, (self, f) => transformResponse(self, Effect.tap(f)))
 
 /** @internal */
 export const tapRequest = dual<
   <R2, E2, _>(
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R | R2, E | E2, A>,
   <R, E, A, R2, E2, _>(
     self: Client.Client<R, E, A>,
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ) => Client.Client<R | R2, E | E2, A>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.tap(self.preprocess(request), f)))

package/src/internal/http/clientRequest.ts

@@ -323,11 +323,11 @@ export const textBody = dual<
 export const jsonBody = dual<
   (
     body: unknown
-  ) => (self: ClientRequest.ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>,
+  ) => (self: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError>,
   (
     self: ClientRequest.ClientRequest,
     body: unknown
-  ) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
+  ) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError>
 >(2, (self, body) => Effect.map(internalBody.json(body), (body) => setBody(self, body)))
 
 /** @internal */
@@ -343,12 +343,12 @@ export const fileBody = dual<
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
   ) => (
     self: ClientRequest.ClientRequest
-  ) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest.ClientRequest>,
+  ) => Effect.Effect<ClientRequest.ClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>,
   (
     self: ClientRequest.ClientRequest,
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
-  ) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest.ClientRequest>
+  ) => Effect.Effect<ClientRequest.ClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
 >(
   (args) => isClientRequest(args[0]),
   (self, path, options) => Effect.map(internalBody.file(path, options), (body) => setBody(self, body))
@@ -361,16 +361,16 @@ export const fileWebBody = dual<
 >(2, (self, file) => setBody(self, internalBody.fileWeb(file)))
 
 /** @internal */
-export const schemaBody = <R, I, A>(schema: Schema.Schema<R, I, A>): {
-  (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
-  (self: ClientRequest.ClientRequest, body: A): Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
+export const schemaBody = <A, I, R>(schema: Schema.Schema<A, I, R>): {
+  (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>
+  (self: ClientRequest.ClientRequest, body: A): Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>
 } => {
   const encode = internalBody.jsonSchema(schema)
   return dual<
     (
       body: A
-    ) => (self: ClientRequest.ClientRequest) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>,
-    (self: ClientRequest.ClientRequest, body: A) => Effect.Effect<R, Body.BodyError, ClientRequest.ClientRequest>
+    ) => (self: ClientRequest.ClientRequest) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>,
+    (self: ClientRequest.ClientRequest, body: A) => Effect.Effect<ClientRequest.ClientRequest, Body.BodyError, R>
   >(2, (self, body) => Effect.map(encode(body), (body) => setBody(self, body)))
 }
 
@@ -396,18 +396,18 @@ export const formDataBody = dual<
 /** @internal */
 export const streamBody = dual<
   (
-    body: Stream.Stream<never, unknown, Uint8Array>,
+    body: Stream.Stream<Uint8Array, unknown>,
     options?: {
-      readonly contentType?: string
-      readonly contentLength?: number
+      readonly contentType?: string | undefined
+      readonly contentLength?: number | undefined
     }
   ) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
   (
     self: ClientRequest.ClientRequest,
-    body: Stream.Stream<never, unknown, Uint8Array>,
+    body: Stream.Stream<Uint8Array, unknown>,
     options?: {
-      readonly contentType?: string
-      readonly contentLength?: number
+      readonly contentType?: string | undefined
+      readonly contentLength?: number | undefined
     }
   ) => ClientRequest.ClientRequest
 >(

package/src/internal/http/clientResponse.ts

@@ -44,7 +44,7 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     return Option.none()
   }
 
-  get stream(): Stream.Stream<never, Error.ResponseError, Uint8Array> {
+  get stream(): Stream.Stream<Uint8Array, Error.ResponseError> {
     return this.source.body
       ? Stream.fromReadableStream(() => this.source.body!, (_) =>
         internalError.responseError({
@@ -61,7 +61,7 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
       }))
   }
 
-  get json(): Effect.Effect<never, Error.ResponseError, unknown> {
+  get json(): Effect.Effect<unknown, Error.ResponseError> {
     return Effect.tryMap(this.text, {
       try: (text) => text === "" ? null : JSON.parse(text) as unknown,
       catch: (_) =>
@@ -74,8 +74,8 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     })
   }
 
-  private textBody?: Effect.Effect<never, Error.ResponseError, string>
-  get text(): Effect.Effect<never, Error.ResponseError, string> {
+  private textBody?: Effect.Effect<string, Error.ResponseError>
+  get text(): Effect.Effect<string, Error.ResponseError> {
     return this.textBody ??= Effect.tryPromise({
       try: () => this.source.text(),
       catch: (_) =>
@@ -88,7 +88,7 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     }).pipe(Effect.cached, Effect.runSync)
   }
 
-  get urlParamsBody(): Effect.Effect<never, Error.ResponseError, UrlParams.UrlParams> {
+  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, Error.ResponseError> {
     return Effect.flatMap(this.text, (_) =>
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
@@ -102,8 +102,8 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
       }))
   }
 
-  private formDataBody?: Effect.Effect<never, Error.ResponseError, FormData>
-  get formData(): Effect.Effect<never, Error.ResponseError, FormData> {
+  private formDataBody?: Effect.Effect<FormData, Error.ResponseError>
+  get formData(): Effect.Effect<FormData, Error.ResponseError> {
     return this.formDataBody ??= Effect.tryPromise({
       try: () => this.source.formData(),
       catch: (_) =>
@@ -116,8 +116,8 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     }).pipe(Effect.cached, Effect.runSync)
   }
 
-  private arrayBufferBody?: Effect.Effect<never, Error.ResponseError, ArrayBuffer>
-  get arrayBuffer(): Effect.Effect<never, Error.ResponseError, ArrayBuffer> {
+  private arrayBufferBody?: Effect.Effect<ArrayBuffer, Error.ResponseError>
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, Error.ResponseError> {
     return this.arrayBufferBody ??= Effect.tryPromise({
       try: () => this.source.arrayBuffer(),
       catch: (_) =>
@@ -135,14 +135,14 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
 export const schemaJson = <
   R,
   I extends {
-    readonly status?: number
-    readonly headers?: Readonly<Record<string, string>>
-    readonly body?: unknown
+    readonly status?: number | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
+    readonly body?: unknown | undefined
   },
   A
->(schema: Schema.Schema<R, I, A>) => {
+>(schema: Schema.Schema<A, I, R>) => {
   const parse = Schema.decodeUnknown(schema)
-  return (self: ClientResponse.ClientResponse): Effect.Effect<R, Error.ResponseError | ParseResult.ParseError, A> =>
+  return (self: ClientResponse.ClientResponse): Effect.Effect<A, Error.ResponseError | ParseResult.ParseError, R> =>
     Effect.flatMap(
       self.json,
       (body) =>
@@ -158,13 +158,13 @@ export const schemaJson = <
 export const schemaNoBody = <
   R,
   I extends {
-    readonly status?: number
-    readonly headers?: Readonly<Record<string, string>>
+    readonly status?: number | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
   },
   A
->(schema: Schema.Schema<R, I, A>) => {
+>(schema: Schema.Schema<A, I, R>) => {
   const parse = Schema.decodeUnknown(schema)
-  return (self: ClientResponse.ClientResponse): Effect.Effect<R, ParseResult.ParseError, A> =>
+  return (self: ClientResponse.ClientResponse): Effect.Effect<A, ParseResult.ParseError, R> =>
     parse({
       status: self.status,
       headers: self.headers

package/src/internal/http/etag.ts

@@ -7,7 +7,7 @@ export const GeneratorTypeId: Etag.GeneratorTypeId = Symbol.for(
 ) as Etag.GeneratorTypeId
 
 /** @internal */
-export const tag = Context.Tag<Etag.Generator>(GeneratorTypeId)
+export const tag = Context.GenericTag<Etag.Generator>("@effect/platform/Http/Etag/Generator")
 
 /** @internal */
 export const toString = (self: Etag.Etag): string => {

package/src/internal/http/middleware.ts

@@ -20,7 +20,7 @@ export const loggerDisabled = globalValue(
 )
 
 /** @internal */
-export const withLoggerDisabled = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<R, E, A> =>
+export const withLoggerDisabled = <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.zipRight(
     FiberRef.set(loggerDisabled, true),
     self
@@ -36,11 +36,11 @@ export const currentTracerDisabledWhen = globalValue(
 export const withTracerDisabledWhen = dual<
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
-  ) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <R, E, A>(
-    effect: Effect.Effect<R, E, A>,
+    effect: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(2, (self, pred) => Effect.locally(self, currentTracerDisabledWhen, pred))
 
 /** @internal */